There are severals ways to compile the firmware. As the traditional way, check the original Building from Source document, however, Docker is recommended because it provides a very clean way to go from source to a .bin file.

Using Docker and Kitematic

Docker command-line reference

Using Buddyworks and other CI platforms

Notes for Buddy.Works (and other CI platforms)

Using ARM on Debian host

All in one script for ARM on Debian host

1. Install Docker
2. Get Kitematic
3. Install GitHub Desktop

If you are using Windows, line endings may produce some errors. For example: 'python/r' not found messages are product of a problem with the line endings. This must be done prior to cloning the repository for compilation to succeed. To prevent this, configure git to not manipulate these line endings, open a terminal and execute: y git config --global core.autocrlf false

You can also check the current configuration by omitting the false at the end of the command.

Important: If you want to collaborate to the project, Fork the repository to your own account and continue this instructions from your own fork.

Open Github Desktop, and click "Open with Github Desktop" from the main page of the repository (or your fork), under the button "Code".

Finally, create a build folder inside of the repository. From Github Desktop, just click "Repository / Show in Explorer" and create an empty folder named build. This folder will be used for the compilation output.

Note: You need to make sure you have also cloned the hackrf folder. to do that run: git submodule update --init --recursive

Open up a terminal in the root of the cloned git repo and run: docker build -t portapack-dev -f dockerfile-nogit .

(the image only works on x86 systems, if you are running docker on an arm system, as a workaround, you can get it build and run an amd64 image but it will run in x86 emulation and will be slow. To make the amd64 image use: docker build --platform linux/amd64 -t portapack-dev -f dockerfile-nogit . )

After its built the docker image, go back to docker and you should see this screen under images

Click on the blue run button and then click the dropdown to expand Optional Settings.

Make sure they look like this:

Host path is the root of your repo.

After that click run!

Note: Come across a /usr/bin/env: ‘python\r’: No such file or directory error? RTFM and go back to step 2 https://github.com/eried/portapack-mayhem/wiki/Compile-firmware#step-2-clone-the-repository

Everytime you run the container you prepared in the previous step, it will compile the source and (if successful) leave the results in build/firmware/

If you have additional questions, please check this guide.

If you are inclined for using the command line, you can try the following:

• Clone the repository and submodules:

git clone https://github.com/eried/portapack-mayhem.git
cd portapack-mayhem
git submodule update --init --recursive

• For building: docker build -t portapackccache -f dockerfile-nogit .

• For running (in the root of the repo): docker run -it -v ${PWD}:/havoc portapackccache

Remember that you have to create a build folder before running the image.

You can use the following _yml _as your template for your CI platform (pipeline export from buddy.works):

- pipeline: "Build firmware"`
  `trigger_mode: "ON_EVERY_PUSH"`
  `ref_name: "master"`
  `ref_type: "BRANCH"`
  `auto_clear_cache: true`
  `trigger_condition: "ALWAYS"`
  `actions:`
  `- action: "Build Docker image"`
    `type: "DOCKERFILE"`
    `dockerfile_path: "dockerfile-nogit"`
    `do_not_prune_images: true`
    `trigger_condition: "ALWAYS"`
  `- action: "Execute: mkdir build"`
    `type: "BUILD"`
    `working_directory: "/buddy/portapack-havoc"`
    `docker_image_name: "library/ubuntu"`
    `docker_image_tag: "18.04"`
    `execute_commands:`
    `- "mkdir -p build"`
    `volume_mappings:`
    `- "/:/buddy/portapack-havoc"`
    `trigger_condition: "ALWAYS"`
    `shell: "BASH"`
  `- action: "Run Docker Image"`
    `type: "RUN_DOCKER_CONTAINER"`
    `use_image_from_action: true`
    `volume_mappings:`
    `- "/:/havoc"`
    `trigger_condition: "ALWAYS"`
    `shell: "SH"

If you decide to ignore this guide and use the command line instead, you will need to include submodules

git clone --recurse-submodules --remote-submodules <url>

• Untested on other linux flavors

• Thanks to @aj#3566 from discord for it

• For convenience the compiler will be installed to /opt/build

• Needed steps

1. Update a Debian based OS
2. Install the necessary ARM compiler to /opt/armbin (if not done before)
3. Link ARM compiler to your bash environment
4. Clone Mayhem repository from GitHub (if not done before)
5. Giver user permission to the Mayhem repository
6. Create makefile through cmake and compile
7. Flash the firmware

• Once done you only need to call 'make' in the /opt/portapack-mayhem/firmware/build directory

• You can speed up the building process by calling 'make -j 8' instead, where 8 is the number of physical CPU cores (if you have some compiling errors to check it's better to call it without '-j 8')

• Use the following commands while logged into your every day user profile. :)

sudo apt-get update
sudo apt-get install -y git tar wget dfu-util cmake python3 bzip2 lz4 curl hackrf python3-distutils python3-setuptools
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py; python3 get-pip.py
pip install pyyaml

sudo mkdir /opt/build
cd /opt/build
sudo wget -O gcc-arm-none-eabi.tar.bz2 'https://developer.arm.com/-/media/Files/downloads/gnu-rm/9-2020q2/gcc-arm-none-eabi-9-2020-q2-update-x86_64-linux.tar.bz2?revision=05382cca-1721-44e1-ae19-1e7c3dc96118&la=en&hash=D7C9D18FCA2DD9F894FD9F3C3DC9228498FA281A'
sudo mkdir armbin
sudo tar --strip=1 -xjvf gcc-arm-none-eabi.tar.bz2 -C armbin

echo 'PATH=/opt/build/armbin/bin:/opt/build/armbin/lib:$PATH' >> ~/.bashrc
source ~/.bashrc

cd /opt
sudo git clone --recurse-submodules https://github.com/eried/portapack-mayhem.git

sudo chown -R my_user:my_usergroup /opt/portapack-mayhem

cd /opt/portapack-mayhem
mkdir build
cd build
cmake ..
make

If you want, use -j argument to increase the compile speed, for example make -j to auto decide the numbers of threads to compile, or manually set the thread numbers, for example make -j4

Developers wishing to test selected functions in the firmware code by running them on their linux PC can also use the command make build_tests and then ctest --output-on-failure to run the tests.

hackrf_spiflash -w /opt/portapack-mayhem/build/firmware/portapack-h1_h2-mayhem.bin

If you want to have all these commands in one go, go to https://github.com/GullCode/compile-flash-mayhem and download compile-flash-mayhem.sh and adjust it to fit your needs

• Linux Aarch64 gcc-arm-none-eabi-9-2020-q2-update-aarch64-linux.tar.bz2
• Toolsets archive
• Compilation error after changing toolsets