create_project_structure.sh

#!/bin/bash


#
# File .......... create_project_structure.sh
# Author ........ Steve Haywood
# Version ....... 1.0
# Date .......... 29 December 2021
# Description ...
#   Simple script to create a possible project directory structure for combined
# firmware, hardware, operating system & software development. Very much work
# in progress and by all means not a golden solution to anything.
#


# Print instructions
function print_args {
  printf "\n"
  printf "Create project (FW, HW, OS & SW) directory structure\n"
  printf "\n"
  printf "Usage: %s dir\n" $1
  printf "\n"
  printf "Where: dir .... Project directory to create & populate\n"
  printf "\n"
  printf "Example: %s ~/projects/example_project\n" $1
  printf "Example: %s /usr/projects/hello_world\n" $1
  printf "\n"
  exit 1
}


# Deal with command line arguments
if [ $# != 1 ]; then
  print_args $0
fi


# Get project base directory
base=$1


# Echo operation
echo "Creating project directory structure @ ${base}"


# Project directories
declare -a dirs=(
  # Firmware
  "fw/src/constraint"
  "fw/src/design"
  "fw/src/diagram"
  "fw/src/document"
  "fw/src/ip"
  "fw/src/ip_repo"
  "fw/src/other"
  "fw/src/script"
  "fw/src/testbench"
  "fw/vivado"
  # Hardware
  "hw/src/schematic"
  # Operating System
  "os/src/other"
  # Software
  "sw/src/c"
  "sw/src/other"
  "sw/src/script"
  "sw/vitis"
)


# Iterate through directories
for dir in "${dirs[@]}"
do
#  echo "Creating ... ${base}/${dir}"
  mkdir -p "${base}/${dir}"
done


# Create C source starter file
touch "${base}/sw/src/c/$(basename $base).c"

create_vivado_project.sh

#!/bin/bash

#
# File .......... create_vivado_project.sh
# Author ........ Steve Haywood
# Version ....... 1.0
# Date .......... 03 May 2021
# Description ...
#   Very simple script to launch Vivado and run the TCL script. Should be run
# in the project host directory that contains the fw & sw subdirectories, for
# example :-
#
# user@host:~/projects/project$ create_vivado_project.sh
# user@host:~/projects/project$ create_vivado_project.sh build
#

# Get command line arguments
if [ $# == 1 ]; then
  arg1=$1
else
  arg1=""
fi

# Get script location
dir_script=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

# Get present working directory
dir_pwd=$(pwd)

# Set directory structure
dir_base="fw"
dir_fw_project="vivado"

# Sanity check directory structure
if [ -d "${dir_pwd}/${dir_base}" ]; then
  if [ ! -e "${dir_pwd}/${dir_base}/${dir_fw_project}" ]; then

    # Launch Vivado
    if [ "$arg1" == "build" ]; then
      vivado -nojournal -nolog -notrace -mode gui -source "${dir_script}/create_vivado_project.tcl" -tclargs build &
    else
      vivado -nojournal -nolog -notrace -mode gui -source "${dir_script}/create_vivado_project.tcl" &
    fi

  else
    echo "Error: Firmware project directory \"${dir_base}/${dir_fw_project}\" already exists, exiting."
  fi
else
  echo "Error: Firmware base directory \"${dir_base}\" does not exists, exiting."
fi

create_vivado_project.tcl

#
# File .......... create_vivado_project.tcl
# Author ........ Steve Haywood
# Version ....... 1.0
# Date .......... 23 December 2021
# Description ...
#   Simple Tcl script to create a new Vivado project, import external
# sources and (optionally) generate the bitstream & export the hardware.
#

puts "Set Global variables"
set dir_firmware    "fw/vivado"
set dir_user        "../src"
set dir_diagram     "$dir_user/diagram"
set dir_design      "$dir_user/design"
set dir_ip          "$dir_user/ip"
set dir_ip_repo     "$dir_user/ip_repo"
set dir_constraint  "$dir_user/constraint"
set dir_testbench   "$dir_user/testbench"
set dir_script      "$dir_user/script"

puts "NOTE: Create project directory, project & change PWD"
create_project project $dir_firmware -part xc7z020clg484-1
cd $dir_firmware

puts "NOTE: Add local IP Repository"
if {[file exist $dir_ip_repo]} {
  set_property  ip_repo_paths  $dir_ip_repo [current_project]
  update_ip_catalog
}

puts "NOTE: Add scripts"
add_files -quiet -norecurse -fileset utils_1 $dir_script
set tcls [get_files *.tcl]
foreach tcl $tcls {
  set tcl_name [file tail $tcl]
  switch $tcl_name {
    "pre_synth.tcl" {
      set_property STEPS.SYNTH_DESIGN.TCL.PRE [ get_files $tcl -of [get_fileset utils_1] ] [get_runs synth_1]
    }
    "post_bit.tcl" {
      set_property STEPS.WRITE_BITSTREAM.TCL.POST [ get_files $tcl -of [get_fileset utils_1] ] [get_runs impl_1]
    }
    default {
      puts "NOTE: Unfamiliar tcl script found - $tcl_name"
    }
  }
}

puts "NOTE: Add block designs"
add_files -quiet -norecurse [glob -nocomplain "$dir_diagram/*/*.bd"]

puts "NOE: Add design sources"
add_files -quiet -norecurse $dir_design

puts "NOTE: Add IPs"
add_files -quiet [glob -nocomplain "$dir_ip/*/*.xci"]

puts "NOTE: Add constraints"
add_files -quiet -norecurse -fileset constrs_1 $dir_constraint

puts "NOTE: Add testbench sources"
add_files -quiet -norecurse -fileset sim_1 $dir_testbench

puts "NOTE: Recreate (by opening) all block designs..."
set bds [glob -nocomplain "$dir_diagram/*/*.bd"]
foreach bd $bds {
  puts "NOTE: Open \"$bd\" block design"
  open_bd_design $bd
}

puts "NOTE: Generate all (none-overwrite) block designs wrappers..."
set bds [get_bd_designs -quiet]
foreach bd $bds {
  puts "NOTE: Generate \"$bd\" block design wrapper"
  set bd_file [get_files $bd.bd]
  set bd_path [file dirname $bd_file]
  set wrapper_files [glob -nocomplain $bd_path/hdl/${bd}_wrapper.*]
  if {[llength $wrapper_files] == 0} {
    set wrapper_file [make_wrapper -files $bd_file -top]
  }
  add_files -quiet -norecurse $bd_path/hdl
}

puts "NOTE: Close all block designs..."
set bds [get_bd_designs -quiet]
foreach bd $bds {
  puts "NOTE: Close \"$bd\" block design"
  close_bd_design $bd
}

puts "NOTE: Check for build argument..."
if { $argc == 1 } {
  set arg0 [lindex $argv 0]
  if { $arg0 == "build" } {
    puts "NOTE: Generate bitstream & export hardware"
    launch_runs impl_1 -to_step write_bitstream -jobs 4
    wait_on_run impl_1
    write_hw_platform -fixed -include_bit -force -file ../system_wrapper.xsa
  }
}

puts "NOTE: That's all folks!"

create_vitis_project.sh

#!/bin/bash

#
# File .......... create_vitis_project.sh
# Author ........ Steve Haywood
# Version ....... 1.0
# Date .......... 03 May 2021
# Description ...
#   Very simple script to launch the Xilinx software command-line tool,
# run the TCL script and launch Vitis. Should be run in the project host
# directory that contains the fw & sw subdirectories, for example :-
#
# user@host:~/projects/project$ create_vitis_project.sh
# user@host:~/projects/project$ create_vitis_project.sh build
#

# Get command line arguments
if [ $# == 1 ]; then
  arg1=$1
else
  arg1=""
fi

# Get script location
dir_script=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

# Get present working directory
dir_pwd=$(pwd)

# Set directory structure
dir_base="sw"
dir_sw_project="vitis"

# Sanity check directory structure
if [ -d "${dir_pwd}/${dir_base}" ]; then
  if [ ! -e "${dir_pwd}/${dir_base}/${dir_sw_project}" ]; then

    # Get last element of path (project name)
    dir_project=${dir_pwd##*/}

    # Call Xilinx Software Commandline Tool
    if [ "$arg1" == "build" ]; then
      xsct "${dir_script}/create_vitis_project.tcl" "${dir_project}" build
    else
      xsct "${dir_script}/create_vitis_project.tcl" "${dir_project}"
    fi

    # Launch Vitis
    vitis -workspace "${dir_base}/${dir_sw_project}" &

  else
    echo "Error: Software project directory \"${dir_base}/${dir_sw_project}\" already exists, exiting."
  fi
else
  echo "Error: Software base directory \"${dir_base}\" does not exists, exiting."
fi

create_vitis_project.tcl

#
# File .......... create_vitis_project.tcl
# Author ........ Steve Haywood
# Version ....... 1.0
# Date .......... 21 Dec 2021
# Description ...
#   Simple Tcl script to create a new Vitis application, import external
# sources and (optionally) build the application.
#

# Check for project name argument, exit if not found.
if { $argc == 0 } {
  puts "Error: No project name provided, exiting..."
  exit 1
}
set project [lindex $argv 0]

# Create and build new project.
setws sw/vitis
app create -name $project -hw fw/system_wrapper.xsa -os standalone -proc ps7_cortexa9_0 -template {Empty Application(C)}
set abs_path [file normalize sw/src/c]
importsources -name $project -path $abs_path -soft-link
if { $argc > 1 } {
  set arg1 [lindex $argv 1]
  if { $arg1 == "build" } {
    app build -name $project
  }
}

xilinx_2021_2.sh

#!/bin/bash

# Setup Vitis, Vivado, Vitis HLS & DocNav environment
source /opt/Xilinx/Vivado/2021.2/settings64.sh
# Setup PetaLinux environment
source /opt/Xilinx/PetaLinux/2021.2/tool/settings.sh

xilinx.sh

#!/bin/bash

#
# File .......... xilinx.sh
# Author ........ Steve Haywood
# Version ....... 1.0
# Date .......... 8 February 2021
# Description ...
#   Determine and list which Xilinx tools are available and let the user select
# the require ones to use. Does not reverse any previously selected tools upon
# selecting news ones so to is cleaner to use in a new Terminal session.
#

# Define install base location
dir_base="/opt/Xilinx"
#dir_base="/mnt/Xilinx"

# Define number of tools (Vivado, SDK, Vitis & PetaLinux)
tools=4

# Define tool directories, executables & settings scripts
dir_tool=("Vivado" "SDK" "Vitis" "PetaLinux")
exe_tool=("vivado" "xsdk" "vitis" "petalinux-build")
set_tool=("settings64.sh" "settings64.sh" "settings64.sh" "tool/settings.sh")







# MY OVERRIDE
#dir_base="/media/secondary/Xilinx"
#set_tool=("settings64.sh" "settings64.sh" "settings64.sh" "settings.sh")







# Define terminal colours
col_default=$(tput sgr0)
col_red=$(tput setaf 1)
col_green=$(tput setaf 2)
col_blue=$(tput setaf 4)
col_fail_pass=(${col_red} ${col_green})

# Exit if script wasn't sourced
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  printf "Script needs to be sourced : source ${BASH_SOURCE[0]}\n"
  exit 1
fi

# Get array of directories at base location
readarray -t dirs < <(find "${dir_base}/${dir_tool[0]}" -mindepth 1 -maxdepth 1 -printf '%P\n')

# Sort directories array
dirs=($(IFS=$'\n'; echo "${dirs[*]}" | sort))

# Determine and list what tools are installed
declare -A table
printf "Xilinx tools available tools at ${dir_base} :-\n"
for ((dir=1; dir<=${#dirs[@]}; dir++)); do
  printf "${dir}) ${dirs[$((dir-1))]}"
  for ((tool=0; tool<${tools}; tool++)); do
    table[${dir}, ${tool}]=$([ ! -d "${dir_base}/${dir_tool[${tool}]}/${dirs[$((dir-1))]}" ]; echo $?)
    printf "${col_default} - "
    printf "${col_fail_pass[${table[${dir}, ${tool}]}]}"
    printf "${dir_tool[${tool}]}"
    printf "${col_default}"
  done
  printf "\n"
done
printf "0) Exit\n"
printf "Please select tools required or exit"

# Obtain user input and source settings for selected tools
while true; do
  read -p " : " sel
  if ! [[ "${sel}" =~ ^[0-9]+$ ]] ; then
    # User input is not a number
    printf "Invalid choice, select again"
  elif [ ${sel} -ge 1 ] && [ ${sel} -le ${#dirs[@]} ]; then
    # User input is out of range
    printf "\nTools are as follows :-\n" "${sel}"
    for ((tool=0; tool<${tools}; tool++)); do
      if [ ${table[${sel}, ${tool}]} -eq 1 ]; then
        source "${dir_base}/${dir_tool[${tool}]}/${dirs[$((sel - 1))]}/${set_tool[${tool}]}" > /dev/null 2>&1
        printf "${col_blue}${exe_tool[${tool}]}${col_default} @ "
        bin=$(which "${exe_tool[${tool}]}")
        if [ -z ${bin} ]; then
          printf "${col_red}Not found!"
        else
          printf "${col_green}%s" "${bin}"
        fi
        printf "${col_default}\n"
      fi
    done
    break
  elif [ ${sel} -eq 0 ]; then
    printf "Quiting without selection!\n"
    break
  else
    printf "Invalid choice, select again"
  fi
done

.bashrc (partial)

200. # Aliases
     
201. alias xilinx='source xilinx.sh'
     
202. alias minized='minicom -D /dev/ttyACM0 -b 115200'
     
203. 
     
204. # Paths
     
205. PATH="~/projects/common/fw/src/script:"$PATH
     
206. PATH="~/projects/common/other/src/script:"$PATH
     
207. PATH="~/projects/common/sw/src/script:"$PATH