default.nix

-let
-  mozillaOverlay = import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz);
-  pkgs = import <nixpkgs> { overlays = [ mozillaOverlay ]; };
-in
+{ mozillaOverlay ? import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz),
+  pkgs ? import <nixpkgs> { overlays = [ mozillaOverlay ]; },
+  firmwareSrc ? ./card10-sys/firmware,
+}:
 with pkgs;
 let
   rust = rustChannelOfTargets "nightly" null [ "thumbv7em-none-eabi" ];
@@ -11,7 +11,7 @@ let
   };
   epic-stubs = stdenv.mkDerivation {
     name = "epic-stubs";
-    src = ./c;
+    src = firmwareSrc;
     buildInputs = [ gcc python3 ];
     buildPhase = ''
       ${python3}/bin/python epicardium/api/genapi.py -H epicardium/epicardium.h -c client.c -s server.c
@@ -25,10 +25,13 @@ let
     name = "rust-card10";
     version = "0.0.0";
     src = ./.;
-    cargoSha256 = "10nims5j9r0d7pcfbbj8ycqxhcx7n07958jvkib29b0sf9c6qh3z";
+    cargoSha256 = "16vchzfk50crr7kbiy84d1spq072ywa7s5jz886nvh7hah94w4a1";
     buildInputs = [ pkgsCross.arm-embedded.stdenv.cc ];
     prePatch = ''
-      cp ${epic-stubs}/client.c l0dable/src/
+      cp ${epic-stubs}/client.c card10-sys/vendor/
+    '' + lib.optionalString (firmwareSrc != ./card10-sys/firmware) ''
+      rm -r card10-sys/firmware
+      cp -r ${firmwareSrc} card10-sys/firmware
     '';
     NIX_DEBUG=1;
     LIBCLANG_PATH="${llvmPackages.libclang}/lib";

draw-image/Cargo.toml

+[package]
+name = "draw-image"
+version = "0.0.0"
+authors = ["Rafael Caricio <crates.rs@caric.io>"]
+edition = "2018"
+
+[dependencies]
+card10-l0dable = { path = "../card10-l0dable" }
+embedded-graphics = { version = "0.5.2" }
+
+[build-dependencies]
+cc = "1.0"
+
+[[bin]]
+name = "draw-image"
+path = "src/main.rs"

draw-image/README.md

+Draw Image
+==========
+
+Images need to be converted to a bitmap of 16BPP for inclusion with `include_bytes!()`. You can convert an image using:
+
+```
+convert image.png -flip -type truecolor -define bmp:subtype=RGB565 -depth 16 -strip image.bmp
+```
+
+then
+
+```
+tail -c $bytes image.bmp > image.raw // where $bytes is w * h * 2
+```
+
+This will remove the BMP header leaving the raw pixel data E.g 160x80 image will have 160 * 80 * 2 bytes of raw data.
\ No newline at end of file

draw-image/src/main.rs

+#![no_std]
+#![no_main]
+
+use card10_l0dable::*;
+use embedded_graphics::prelude::*;
+
+use embedded_graphics::image::Image16BPP;
+use embedded_graphics::pixelcolor::Rgb565;
+
+main!(main);
+fn main() {
+    let mut display = Display::open();
+    let mut framebuffer = display.framebuffer();
+
+    let image: Image16BPP<Rgb565> =
+        Image16BPP::new(include_bytes!("applewatch-160x80.raw"), 160, 80);
+    framebuffer.draw(&image);
+    framebuffer.send();
+
+    loop {
+        let buttons = Buttons::read();
+        if buttons.left_top() {
+            break;
+        }
+    }
+}

example/Cargo.toml

@@ -5,7 +5,8 @@ version = "0.0.0"
 authors = ["Astro <astro@spaceboyz.net>"]
 
 [dependencies]
-card10-l0dable = { path = "../l0dable" }
+card10-l0dable = { path = "../card10-l0dable" }
+card10-alloc = { path = "../card10-alloc" }
 
 [build-dependencies]
 cc = "1.0"

example/src/main.rs

 #![no_std]
 #![no_main]
 
-use card10_l0dable::*;
 use core::fmt::{self, Write};
+use card10_l0dable::*;
+/// Allows you to `use alloc::*;`
+extern crate alloc;
 
 main!(main);
 fn main() {
+    let heap_size = card10_alloc::init(4096);
+    println!("Heap size: {}", heap_size);
+
     let result = run();
     if let Err(error) = result {
         writeln!(UART, "error: {}\r", error).unwrap();
@@ -20,6 +25,10 @@ fn run() -> Result<(), Error> {
     let g = BHI160::<Gyroscope>::start()?;
     let o = BHI160::<Orientation>::start()?;
 
+    set_rocket(Rocket::Blue, 20);
+    set_rocket(Rocket::Yellow, 20);
+    set_rocket(Rocket::Green, 10);
+
     let display = Display::open();
     let light = LightSensor::start();
 
@@ -42,25 +51,25 @@ fn run() -> Result<(), Error> {
         }
 
         display.clear(Color::yellow());
-        display.print(160 - t, 10, b"Hello Rust\0", Color::white(), Color::black());
+        display!(display, 160 - t, 10, Color::white(), Color::black(), "Hello Rust {}", t);
 
         let b = Buttons::read();
         if b.left_bottom() {
-            display.print(0, 60, b"LB\0", Color::red(), Color::black());
+            display!(display, 0, 60, Color::red(), Color::black(), "LB");
             vibra::set(true);
         }
         if b.right_bottom() {
-            display.print(80, 60, b"RB\0", Color::red(), Color::black());
+            display!(display, 80, 60, Color::red(), Color::black(), "RB");
             vibra::set(false);
         }
         if b.left_top() {
-            display.print(0, 10, b"LT\0", Color::red(), Color::black());
+            display!(display, 0, 10, Color::red(), Color::black(), "LT");
         }
         if b.right_top() {
-            display.print(80, 10, b"RT\0", Color::red(), Color::black());
+            display!(display, 80, 10, Color::red(), Color::black(), "RT");
         }
         if b.right_top() {
-            display.print(80, 30, b"Reset\0", Color::red(), Color::black());
+            display!(display, 80, 30, Color::red(), Color::black(), "Reset");
         }
         writeln!(UART, "Light: {:?}\r", light.get())?;
 

firmware.nix

+{ pkgs ? import <nixpkgs> {},
+  src ? ./.,
+  srcPath ? "card10-sys/firmware",
+}:
+with pkgs;
+
+let
+  cSrc = stdenv.mkDerivation rec {
+    name = "card10-src";
+    inherit src;
+    phases = [ "unpackPhase" "patchPhase" "installPhase" ];
+    nativeBuildInputs = [ git ];
+    prePatch = "cd ${srcPath}";
+    patches = [
+      ./0001-hack-epicardium-reduce-init-delay-from-2s-to-0.1s.patch
+    ];
+    postPatch = ''
+      VERSION="$(git -C ${src} describe --always)"
+      GITHASH="$(git -C ${src} rev-parse HEAD)"
+
+      substituteInPlace tools/version-header.sh \
+        --replace "\$VERSION" "$VERSION" \
+        --replace "\$GITHASH" "$GITHASH" \
+        --replace "git -C" echo
+    '';
+    installPhase = ''
+      cp -ar . $out
+
+      mkdir -p $out/nix-support
+      for f in $out/*.bin ; do
+        echo file binary-dist $f >> $out/nix-support/hydra-build-products
+      done
+    '';
+  };
+  firmware = lib.makeOverridable (attrs: {
+    inherit (attrs) src;
+    firmware = import attrs.src;
+  }) { src = cSrc; };
+in firmware

hydra/combined.nix

+{ pkgs ? import <nixpkgs> {},
+  cFirmware ? <c-firmware>,
+  rkanoid ? <rkanoid>,
+}:
+with pkgs;
+
+let
+  l0dables = buildEnv {
+    name = "l0dables";
+    paths = [ rkanoid ];
+    pathsToLink = [ "/apps" ];
+  };
+  release = import ../release.nix {
+    inherit cFirmware;
+    rustL0dables = l0dables;
+  };
+  releaseZip = stdenv.mkDerivation {
+    name = "card10-combined.zip";
+    nativeBuildInputs = [ release zip ];
+    phases = [ "installPhase" ];
+    installPhase = ''
+      mkdir -p $out/nix-support
+
+      cd ${release}/
+      zip -9r $out/firmware.zip .
+      echo file binary-dist $out/firmware.zip >> $out/nix-support/hydra-build-products
+    '';
+  };
+in {
+  release = lib.hydraJob release;
+  release-zip = lib.hydraJob releaseZip;
+}

hydra/firmware.nix

+{ pkgs ? import <nixpkgs> {},
+}:
+with pkgs;
+
+let
+  firmwareSrc = import ../firmware.nix {
+    inherit pkgs;
+    src = <firmware>;
+    srcPath = ".";
+  };
+  firmwareGit = firmwareSrc.override (oldArgs: {
+    src = oldArgs.src.overrideAttrs (oldAttrs: {
+      name = "${oldAttrs.name}-git";
+      # no more git, .git is dropped by Hydra
+      nativeBuildInputs = [];
+      postPatch = ''
+        VERSION="0.0-git"
+        GITHASH="0000000000000000000000000000000000000000"
+
+        substituteInPlace tools/version-header.sh \
+          --replace "\$VERSION" "$VERSION" \
+          --replace "\$GITHASH" "$GITHASH" \
+          --replace "git -C" echo
+      '';
+    });
+  });
+  firmware = firmwareGit.firmware.overrideAttrs (oldAttrs: {
+    buildCommand = ''
+      ${oldAttrs.buildCommand}
+
+      mkdir -p $out/nix-support
+      for f in $out/**/*.elf $out/card10/*.bin ; do
+        echo file binary-dist $f >> $out/nix-support/hydra-build-products
+      done
+    '';
+  });
+  firmwareZip = stdenv.mkDerivation {
+    name = "card10-firmware.zip";
+    nativeBuildInputs = [ firmware zip ];
+    phases = [ "installPhase" ];
+    installPhase = ''
+      mkdir -p $out/nix-support
+
+      cd ${firmware}/card10/
+      zip -9r $out/firmware.zip .
+      echo file binary-dist $out/firmware.zip >> $out/nix-support/hydra-build-products
+    '';
+  };
+in {
+  firmware = lib.hydraJob firmware;
+  firmware-zip = lib.hydraJob firmwareZip;
+}

hydra/hydra.json

+{
+    "enabled": 1,
+    "type": 0,
+    "hidden": true,
+    "description": "Jobsets",
+    "nixexprinput": "rust-card10",
+    "nixexprpath": "hydra/hydra.nix",
+    "checkinterval": 300,
+    "schedulingshares": 100,
+    "enableemail": false,
+    "emailoverride": "astro@spaceboyz.net",
+    "keepnr": 30,
+    "inputs": {
+        "nixpkgs": { "type": "git", "value": "https://github.com/NixOS/nixpkgs-channels nixos-19.09", "emailresponsible": false },
+        "rust-card10": { "type": "git", "value": "https://git.card10.badge.events.ccc.de/astro/rust-card10.git", "emailresponsible": false }
+    }
+}

hydra/hydra.nix

+{ pkgs ? import <nixpkgs> {} }:
+let
+  jobsets = {
+    c-firmware = {
+      enabled = 1;
+      type = 0;
+      hidden = false;
+      description = "card10 C firmware";
+      nixexprinput = "rust-card10";
+      nixexprpath = "hydra/firmware.nix";
+      checkinterval = 300;
+      schedulingshares = 100;
+      enableemail = true;
+      emailoverride = "astro@spaceboyz.net";
+      keepnr = 3;
+      inputs = {
+        firmware = { type = "git"; value = "https://git.card10.badge.events.ccc.de/card10/firmware.git"; emailresponsible = false; };
+        rust-card10 = { type = "git"; value = "https://git.card10.badge.events.ccc.de/astro/rust-card10.git"; emailresponsible = false; };
+        nixpkgs = { type = "git"; value = "git://github.com/NixOS/nixpkgs.git release-19.09"; emailresponsible = false; };
+      };
+    };
+    rust-l0dables = {
+      enabled = 1;
+      type = 0;
+      hidden = false;
+      description = "card10 Rust l0dable examples";
+      nixexprinput = "rust-card10";
+      nixexprpath = "hydra/l0dables.nix";
+      checkinterval = 300;
+      schedulingshares = 100;
+      enableemail = true;
+      emailoverride = "astro@spaceboyz.net";
+      keepnr = 3;
+      inputs = {
+        firmware = { type = "git"; value = "https://git.card10.badge.events.ccc.de/card10/firmware.git"; emailresponsible = false; };
+        rust-card10 = { type = "git"; value = "https://git.card10.badge.events.ccc.de/astro/rust-card10.git"; emailresponsible = false; };
+        nixpkgs = { type = "git"; value = "git://github.com/NixOS/nixpkgs.git release-19.09"; emailresponsible = false; };
+        mozillaOverlay = { type = "git"; value = "git://github.com/mozilla/nixpkgs-mozilla.git"; emailresponsible = false; };
+      };
+    };
+    firmware-combined = {
+      enabled = 1;
+      type = 0;
+      hidden = false;
+      description = "Prepared firmware with Rust l0dables";
+      nixexprinput = "rust-card10";
+      nixexprpath = "hydra/combined.nix";
+      checkinterval = 300;
+      schedulingshares = 100;
+      enableemail = true;
+      emailoverride = "astro@spaceboyz.net";
+      keepnr = 3;
+      inputs = {
+        rust-card10 = { type = "git"; value = "https://git.card10.badge.events.ccc.de/astro/rust-card10.git"; emailresponsible = false; };
+        c-firmware = { type = "build"; value = "rust-card10:c-firmware:firmware"; emailresponsible = false; };
+        rkanoid = { type = "build"; value = "rust-card10:rust-l0dables:rkanoid"; emailresponsible = false; };
+        nixpkgs = { type = "git"; value = "git://github.com/NixOS/nixpkgs.git release-19.09"; emailresponsible = false; };
+      };
+    };
+  };
+
+  jobsetsJson = pkgs.writeText "jobsets.json" (builtins.toJSON jobsets );
+in
+{
+  jobsets = pkgs.runCommand "rust-card10.json" {} ''
+    cp ${jobsetsJson} $out
+  '';
+}

hydra/l0dables.nix

+{ rustManifest ? ./channel-rust-nightly.toml,
+}:
+let
+  mozillaOverlay = import <mozillaOverlay>;
+  manifestOverlay = self: super: {
+    rustChannelOfTargets = _channel: _date: targets:
+      (super.lib.rustLib.fromManifestFile rustManifest {
+        inherit (super) stdenv fetchurl patchelf;
+      }).rust.override { inherit targets; };
+  };
+  pkgs = (import <nixpkgs> { overlays = [ mozillaOverlay manifestOverlay ]; });
+  project = import ../default.nix {
+    inherit pkgs mozillaOverlay;
+    firmwareSrc = <firmware>;
+  };
+  l0dable = crate: project.l0dables.overrideAttrs (oldAttrs: {
+    name = "${oldAttrs.name}-${crate}";
+    buildPhase = ''
+      pushd ${crate}
+      ${oldAttrs.buildPhase}
+      popd
+    '';
+    installPhase = ''
+      ${oldAttrs.installPhase}
+
+      mkdir -p $out/nix-support
+      for f in $out/apps/*.elf ; do
+        echo file binary-dist $f >> $out/nix-support/hydra-build-products
+      done
+    '';
+  });
+  crates =
+    pkgs.lib.filterAttrs (crate: type:
+      type == "directory" &&
+      builtins.pathExists (<rust-card10> + "/${crate}/Cargo.toml")
+    ) (builtins.readDir <rust-card10>);
+in
+builtins.mapAttrs (crate: type:
+  pkgs.lib.hydraJob (l0dable crate)
+) crates

l0dable/build.rs

-use std::env;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    // Linker script
-    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    File::create(out.join("l0dable.ld"))
-        .unwrap()
-        .write_all(include_bytes!("l0dable.ld"))
-        .unwrap();
-    println!("cargo:rustc-link-search={}", out.display());
-    println!("cargo:rerun-if-changed=l0dable.ld");
-
-    // Link against C code
-    cc::Build::new()
-        .target("thumbv7em-none-eabi")
-        .compiler("arm-none-eabi-gcc")
-        .define("TARGET", "MAX32665")
-        .define("TARGET_UC", "MAX32665")
-        .define("TARGET_LC", "max32665")
-        .define("TARGET_REV", "0x4131")
-        .define("BOARD", "card10")
-        .opt_level_str("s")
-        .debug(true)
-        .flag("-fPIE").flag("-pie")
-        .include("../c/epicardium")
-        .include("../c/lib/sdk/Libraries/CMSIS/Device/Maxim/MAX32665/Include")
-        .include("../c/lib/sdk/Libraries/CMSIS/Include")
-        .include("../c/lib/sdk/Libraries/MAX32665PeriphDriver/Include")
-        .file("../c/lib/sdk/Libraries/MAX32665PeriphDriver/Source/sema.c")
-        .file("../c/lib/sdk/Libraries/MAX32665PeriphDriver/Source/mxc_assert.c")
-        .file("../c/l0dables/lib/hardware.c")
-        .file("../c/epicardium/api/caller.c")
-        .file("src/client.c")
-        .file("../c/lib/gfx/Fonts/font12.c")
-        .file("../c/lib/gfx/Fonts/font16.c")
-        .file("../c/lib/gfx/Fonts/font20.c")
-        .file("../c/lib/gfx/Fonts/font24.c")
-        .file("../c/lib/gfx/Fonts/font8.c")
-        .compile("card10");
-    println!("cargo:rerun-if-changed=src/client.c");
-
-    // Generate bindings to C code
-    let bindings = bindgen::Builder::default()
-        .clang_args(&[
-            "-Isrc",
-            "-I../c/epicardium",
-            "-I../c/lib/sdk/Libraries/CMSIS/Device/Maxim/MAX32665/Include",
-            "-I../c/lib/sdk/Libraries/CMSIS/Include",
-            "-I../c/lib/sdk/Libraries/MAX32665PeriphDriver/Include",
-        ])
-        .header("src/bindings.h")
-        .use_core()
-        .ctypes_prefix("super::ctypes")
-        .generate()
-        .expect("Unable to generate bindings");
-    println!("cargo:rerun-if-changed=src/bindings.h");
-
-    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
-    bindings
-        .write_to_file(out_path.join("bindings.rs"))
-        .expect("Couldn't write bindings!");
-}

l0dable/src/vibra.rs

-use super::bindings::*;
-
-pub fn set(status: bool) {
-    unsafe { epic_vibra_set(status.into()); }
-}
-
-pub fn vibrate(millis: i32) {
-    unsafe { epic_vibra_vibrate(millis); }
-}

openocd.gdb

-target remote :3333
-
-define reset
-    mon mww 0x40000004 0x80000000
-end
-
-# print demangled symbols by default
-set print asm-demangle on
-
-monitor arm semihosting enable
-
-load

release.nix

 { pkgs ? import <nixpkgs> {},
-  jailbreak ? true,
+  cFirmware ? (import ./firmware.nix { inherit pkgs; }).firmware,
+  rustL0dables ? (import ./default.nix {}).l0dables,
 }:
 with pkgs;
 
-let
-  versionSuffix =
-    if jailbreak
-    then "-jailbreak"
-    else "";
-  cSrc = stdenv.mkDerivation {
-    name = "card10-src";
-    src = ./.;
-    phases = [ "unpackPhase" "patchPhase" "installPhase" ];
-    nativeBuildInputs = [ git ];
-    prePatch = "cd c";
-    patches = [
-      ./0001-feat-nix-add-jailbreak-arg.patch
-    ];
-    postPatch = ''
-      VERSION="$(git describe --always)${versionSuffix}"
-      GITHASH="$(git rev-parse HEAD)"
-
-      substituteInPlace tools/version-header.sh \
-        --replace "\$VERSION" "$VERSION" \
-        --replace "\$GITHASH" "$GITHASH"
-    '';
-    installPhase = ''
-      cp -ar . $out
-    '';
-  };
-  cFirmware = import "${cSrc}" { inherit pkgs jailbreak; };
-  rustL0dables = (import ./default.nix).l0dables;
-  release = stdenv.mkDerivation {
+stdenv.mkDerivation {
   name = "card10-firmware";
   buildInputs = [ cFirmware rustL0dables ];
   phases = [ "installPhase" ];
   installPhase = ''
     mkdir $out
     cp -r ${cFirmware}/card10/* $out/
+
     chmod u+w $out/apps
     cp ${rustL0dables}/apps/* $out/apps/
+
+    cat << EOF > $out/card10.cfg
+    execute_elf=true
+    EOF
   '';
-  };
-in release
+}