mohr/obsw
1
0
Fork 0
forked from ROMEO/obsw
Code Pull Requests 1 Actions Releases 4 Activity

Added links

Browse Source
This commit is contained in:
paul nehlich 2024-06-26 14:00:20 +02:00
parent 92f59fd0b4
commit 9986ccd9e9
1 changed files with 7 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
README.md
View File

@ -10,12 +10,17 @@ The Onboard Software (OBSW) is written in Rust for run-time stability. The imple
(design from IRS ROMEO Website) (design from IRS ROMEO Website)
## How to Configure This Repository? TODO ## How to Configure This Repository? #TODO
# First Stage Bootloader (FSBL) # First Stage Bootloader (FSBL)
FSBL code is at https://github.com/Xilinx/embeddedsw/
Is compiled in the folder fsbl-compiled, use it if you don't know that you have to change it.
The FSBL code is at https://github.com/Xilinx/embeddedsw/
See [BUILD_WITH_DOCKER.md](./BUILD_WITH_DOCKER.md) or [BUILD_WITH_CMAKE.md](./BUILD_WITH_CMAKE.md) for build instructions.
## Scope ## Scope
This is the central repository for the flight software of the ROMEO satellite. This is the central repository for the flight software of the ROMEO satellite.
@ -43,142 +48,6 @@ The current working steps are:
Consider using Docker or setting up a local compile toolchain. Consider using Docker or setting up a local compile toolchain.
Please refer to [BUILD_WITH_DOCKER.md](./BUILD_WITH_DOCKER.md) or [BUILD_WITH_CMAKE.md](./BUILD_WITH_CMAKE.md). Please refer to [BUILD_WITH_DOCKER.md](./BUILD_WITH_DOCKER.md) or [BUILD_WITH_CMAKE.md](./BUILD_WITH_CMAKE.md).
## Prerequisits for build with Docker
##### Info
IRS wireguard VPN can cause network issues with docker.
##### Install Docker
If you are using macOS or Windows, please use this tutorial:
- https://www.docker.com/get-started/
On Linux simply use your package manager to install ```docker``` and prepare everything using these commands, to avoid permission denied errors:
```sh
sudo systemctl start docker
sudo groupadd docker
sudo usermod -aG docker $USER
sudo reboot
```
## FSBL
FSBL is the First Stage Boot Loader and prepares the CPU and FPGA configuration for booting up the Second Stage Bootloader and finally the flight software.
##### Clone the repository and build the docker image:
```sh
cd docker/compile_fsbl/
git clone https://github.com/Xilinx/embeddedsw/
docker build -t compile_fsbl .
```
##### To build the FSBL, run the following command in the `docker/compile-fsbl` directory:
```sh
docker run -v ./embeddedsw:/fsbl compile_fsbl /bin/bash -c "cd lib/sw_apps/zynq_fsbl/src && make BOARD=zed SHELL=/bin/bash"
```
## Requirements [TBC]:
1. `cmake`
2. `arm-none-eabi-gcc`
3. `doxygen`
4. `graphviz`
If you want, copy the fsbl.elf to the docker/compile_fsbl directory for easier access:
```sh
cp embeddedsw/lib/sw_apps/zynq_fsbl/src/fsbl.elf .
```
## Steps
1. Configure doxygen:
## mission_rust
##### Build the docker image:
```sh
export DOT_PATH=/usr/local/bin
```
2. Satisfy Rust requirements
```sh
cd ../mission_rust
cargo update
rustup toolchain install nightly
rustup component add rust-src --toolchain nightly-x86_64-unknown-linux-gnu
rustup override set nightly
cargo build -Z build-std
cd docker/compile_mission/
docker build -t compile_mission .
```
3. Configure the ROMEO OBSW repository in `.../obsw/`
##### To build the mission_rust, run the following command in the `docker/compile_mission` directory:
```sh
docker run -v $(pwd)/../../mission_rust:/mission_rust compile_mission /bin/bash -c "cargo build -Z build-std"
```
## obsw
##### Clone the submodules (FreeRTOS and lwIP):
```sh
git submodule init
git submodule update
```
##### Build the docker image:
```sh
cd docker/compile_obsw/
docker build -t compile_obsw .
```
##### To build the obsw, run the following command in the `docker/compile_obsw` directory:
```sh
docker run -v $(pwd)/../..:/obsw compile_obsw /bin/bash -c "mkdir -p build_cli && cd build_cli && cmake -DCMAKE_TOOLCHAIN_FILE=../bsp_z7/cmake/arm-none-eabi.toolchain .. && make -j 8"
```
The romeo-obsw binary can now be found in the `build_cli` directory.
# Debugging on `zedboard`
`zedboard` is the `Xilinx Zynq-7000` development board.
## Requirements [TBC]:
- `OpenOCD`
- `arm-none-eabi-gdb`
## Steps
TODO: discuss this with paul
1. Set Zedboard `boot mode` to JTAG and connect debugging PC to zedboard JTAG and UART USB port.
TODO: what is which port, use distinct name/add a graphic
2. On PC connected to zedboard JTAG USB port:
```sh
openocd -f board/digilent_zedboard.cfg
```
If you have one around, load bitstream at startup (go get a coffee, takes time with onboard JTAG, blue LED lights up when done):
```sh
openocd -f board/digilent_zedboard.cfg -c "init" -c "pld load 0 system.bit"
```
3. To use JTAG Boot for the OBSW, you first need to run the FSBL once.
On build PC (adapt IP if different from debugging PC) in the folder where you build the FSBL as above:
```sh
arm-none-eabi-gdb fsbl.elf
>target extended-remote localhost:3333
>load
>cont
>^C^D^D
```
### (Optional) Automate this run:
```sh
arm-none-eabi-gdb fsbl.elf -iex "target extended-remote localhost:3333" -ex "set pagination off" -ex "load" -ex "break FsblHandoffJtagExit" -ex "cont" -ex="set confirm off" -ex "exit"
```
It will exit after the Zynq is configured and ready to firmware.
Then load the actual OBSW, in the build (`build_cli` in the example above) folder run:
```sh
arm-none-eabi-gdb romeo-obsw
>target extended-remote localhost:3333
>load
>cont >cont
``` ```