Training update

.devcontainer/Dockerfile

@@ -5,7 +5,7 @@ FROM debian:bullseye-slim
 ENV DEBIAN_FRONTEND=noninteractive
 ENV LC_ALL=C.UTF-8
 ENV LANG=C.UTF-8
-ARG NIGHTLY_VERSION=nightly-2022-03-10
+ARG NIGHTLY_VERSION=nightly-2023-02-28
 ARG ESP_IDF_VERSION=v4.4.1
 ARG ESP_BOARD=esp32c3
 

.devcontainer/devcontainer.json

@@ -3,7 +3,7 @@
   "build": {
     "dockerfile": "Dockerfile",
     "args": {
-      "NIGHTLY_VERSION": "nightly-2022-03-10"
+      "NIGHTLY_VERSION": "nightly-2023-02-28"
     }
   },
   "settings": {

.github/workflows/CI.yml

@@ -2,7 +2,10 @@
 name: CI
 
 on:
-  push: {}
+  push:
+    paths-ignore:
+      - "book/"
+      - "book/**"
   pull_request:
     branches: [main]
     paths-ignore:

.gitpod.Dockerfile

@@ -4,7 +4,7 @@ ENV LC_ALL=C.UTF-8
 ENV LANG=C.UTF-8
 ARG CONTAINER_USER=gitpod
 ARG CONTAINER_GROUP=gitpod
-ARG NIGHTLY_VERSION=nightly-2022-03-10
+ARG NIGHTLY_VERSION=nightly-2023-02-28
 ARG ESP_IDF_VERSION=v4.4.1
 ARG ESP_BOARD=esp32c3
 RUN sudo install-packages git curl gcc clang ninja-build libudev-dev \

README.md

@@ -26,10 +26,10 @@ There is:
    * GPIO/Button Interrupts ([Source](./advanced/button-interrupt))
    * Driving an RGB LED
 * Some useful common crates:
-   * [`esp32-c3-dkc02-bsc`](./common/lib/esp32-c3-dkc02-bsc) - Board-Support for the ESP32-C3-DKC02
-   * [`get-uuid`](./common/lib/get-uuid) - provides a compile-time generated UUID
+   * [`get-uuid`](./common/lib/get-uuid) - Provides a compile-time generated UUID
    * [`mqtt-messages`](./common/lib/mqtt-messages) - MQTT helper functions
-   * [`icm42670p`](./common/lib/icm42670p) - basic sensor driver
+   * [`rgb-led`](./common/lib/rgb-led) - Provides support for the RGB LED (WS2812)
+   * [`wifi`](./common/lib/wifi) - Wifi helper functions
 * Some extra bits:
    * [`mqtt-python-client`](./extra/mqtt-python-client) A Python MQTT client, for testing
 

advanced/README.md

@@ -4,20 +4,21 @@ Folders are listed in alphabetical order, not in the order they are taught in th
 
 ## Button Interrupt
 
-`button-interrupt/exercise/src/main.rs` contains the project code skeleton
-`button-interrupt/solution/src/main.rs` contains the solution for the first step of the exercise.
-`button-interrupt/solution/src/main_led.rs` contains the solution for the second step of the exercise. 
+[`button-interrupt/exercise/src/main.rs`](button-interrupt/src/main.rs) contains the project code skeleton
+[`button-interrupt/examples/solution.rs`](button-interrupt/examples/solution.rs) contains the solution for the first step of the exercise.
+[`button-interrupt/examples/solution_led.rs`]((button-interrupt/examples/solution_led.rs) ) contains the solution for the second step of the exercise.
 ## I2C Driver exercise (WIP)
 
-`i2c-driver/exercise/src/icm42670p.rs` will be gap text of a very basic i2c IMU sensor driver. The task is to complete the file, so that running `main.rs` will log the device ID of the driver. The this gap text driver is based on the version of the same name that lives in common, but provides a little bit more functionality.
+[`i2c-driver/exercise/src/icm42670p.rs`](i2c-driver/src/icm42670p.rs) will be gap text of a very basic i2c IMU sensor driver. The task is to complete the file, so that running `main.rs` will log the device ID of the driver. The this gap text driver is based on the version of the same name that lives in common, but provides a little bit more functionality.
 
-`i2c-driver/exercise/src/main.rs` will contain working code. Running it without modifying the driver file will yield errors. 
+[`i2c-driver/exercise/src/main.rs`](i2c-driver/src/main.rs) will contain working code. Running it without modifying the driver file will yield errors.
 
-`i2c-driver/solution/src/icm42670p.rs` provides a solution to the task. 
+[`i2c-driver/exercise/src/icm42670p_solution.rs`](i2c-driver/src/icm42670p_solution.rs) provides a solution to the task.
 
 ## I2C Sensor Reading Exercise (WIP)
 
- `i2c-sensor-reading/exercise/src/main.rs` will be an exercise skeleton that will build. The task is to use an existing driver from crates.io to read out the temperature and humidity sensor over i2c. After that, a second sensor will be read out over the same i2c bus using `shared-bus`. The driver for the second sensor is available locally in `common/`.
+[`i2c-sensor-reading/src/main.rs`](i2c-sensor-reading/src/main.rs) will be an exercise skeleton that will build. The task is to use an existing driver from crates.io to read out the temperature and humidity sensor over i2c. After that, a second sensor will be read out over the same i2c bus using `shared-bus`.
 
-`i2c-sensor-reading/solution/src/main.rs` contains a working solution.
+`i2c-sensor-reading/examples/part_1.rs` contains a working solution for Part 1.
+`i2c-sensor-reading/examples/part_2.rs` contains a working solution for Part 2.
 

advanced/button-interrupt/Cargo.toml

@@ -1,26 +1,31 @@
 [package]
 name = "button-interrupt"
 version = "0.1.0"
-authors = ["Anatol Ulrich <anatol.ulrich@ferrous-systems.com>", "Tanks Transfeld <tanks.transfeld@ferrous-systems.com>"]
+authors = [
+    "Anatol Ulrich <anatol.ulrich@ferrous-systems.com>",
+    "Tanks Transfeld <tanks.transfeld@ferrous-systems.com>",
+    "Sergio Gasquez <sergio.gasquez@gmail.com>",
+]
 edition = "2021"
 resolver = "2"
 
 [profile.release]
 opt-level = "s"
 
 [profile.dev]
-debug = true # Symbols are nice and they don't increase the size on Flash
+debug = true    # Symbols are nice and they don't increase the size on Flash
 opt-level = "z"
 
 [features]
 default = ["native"]
 native = ["esp-idf-sys/native"]
 
 [dependencies]
-esp-idf-sys = { version = "=0.31.5", features = ["binstart"] }
-anyhow = "1"
-esp32-c3-dkc02-bsc = { path = "../../common/lib/esp32-c3-dkc02-bsc" }
+esp-idf-sys = { version = "=0.32.1", features = ["binstart"] }
+anyhow = "=1.0.69"
+rgb-led = { path = "../../common/lib/rgb-led" }
+esp-idf-hal = "=0.40.1"
 
 [build-dependencies]
-embuild = "0.28"
-anyhow = "1"
+embuild = "=0.31.0"
+anyhow = "=1.0.69"

advanced/button-interrupt/examples/solution.rs

@@ -1,45 +1,44 @@
 // reference:
 // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/freertos.html
 
-use std::ptr;
-
+use anyhow::Result;
 use esp_idf_sys::{
-    c_types::c_void, esp, gpio_config, gpio_config_t, gpio_install_isr_service,
-    gpio_int_type_t_GPIO_INTR_POSEDGE, gpio_isr_handler_add, gpio_mode_t_GPIO_MODE_INPUT,
-    xQueueGenericCreate, xQueueGiveFromISR, xQueueReceive, QueueHandle_t,ESP_INTR_FLAG_IRAM,
+    esp, gpio_config, gpio_config_t, gpio_install_isr_service, gpio_int_type_t_GPIO_INTR_POSEDGE,
+    gpio_isr_handler_add, gpio_mode_t_GPIO_MODE_INPUT, xQueueGenericCreate, xQueueGiveFromISR,
+    xQueueReceive, QueueHandle_t, ESP_INTR_FLAG_IRAM,
 };
+use std::ptr;
 
 // This `static mut` holds the queue handle we are going to get from `xQueueGenericCreate`.
 // This is unsafe, but we are careful not to enable our GPIO interrupt handler until after this value has been initialised, and then never modify it again
 static mut EVENT_QUEUE: Option<QueueHandle_t> = None;
 
 #[link_section = ".iram0.text"]
-unsafe extern "C" fn button_interrupt(_: *mut c_void) {
+unsafe extern "C" fn button_interrupt(_: *mut core::ffi::c_void) {
     xQueueGiveFromISR(EVENT_QUEUE.unwrap(), std::ptr::null_mut());
 }
 
-fn main() -> anyhow::Result<()> {
+fn main() -> Result<()> {
     const GPIO_NUM: i32 = 9;
-    
+
     // Configures the button
     let io_conf = gpio_config_t {
         pin_bit_mask: 1 << GPIO_NUM,
         mode: gpio_mode_t_GPIO_MODE_INPUT,
         pull_up_en: true.into(),
         pull_down_en: false.into(),
-        intr_type: gpio_int_type_t_GPIO_INTR_POSEDGE, // positive edge trigger = button down
+        intr_type: gpio_int_type_t_GPIO_INTR_POSEDGE, // Positive edge trigger = button down
     };
 
     // Queue configurations
     const QUEUE_TYPE_BASE: u8 = 0;
-    const ITEM_SIZE: u32 = 0; // we're not posting any actual data, just notifying
+    const ITEM_SIZE: u32 = 0; // We're not posting any actual data, just notifying
     const QUEUE_SIZE: u32 = 1;
 
     unsafe {
         // Writes the button configuration to the registers
         esp!(gpio_config(&io_conf))?;
 
-
         // Installs the generic GPIO interrupt handler
         esp!(gpio_install_isr_service(ESP_INTR_FLAG_IRAM as i32))?;
 
@@ -57,16 +56,16 @@ fn main() -> anyhow::Result<()> {
     // Reads the queue in a loop.
     loop {
         unsafe {
-            // maximum delay
+            // Maximum delay
             const QUEUE_WAIT_TICKS: u32 = 1000;
 
             // Reads the event item out of the queue
             let res = xQueueReceive(EVENT_QUEUE.unwrap(), ptr::null_mut(), QUEUE_WAIT_TICKS);
-            
-            // If the event has the value 0, nothing happens. if it has a different value, the button was pressed. 
+
+            // If the event has the value 0, nothing happens. if it has a different value, the button was pressed.
             match res {
-                1 => println!("button pressed!"),
-                _ => {},
+                1 => println!("Button pressed!"),
+                _ => {}
             };
         }
     }

advanced/button-interrupt/examples/solution_led.rs

@@ -1,49 +1,49 @@
 // reference:
 // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/freertos.html
 
-use std::ptr;
-use esp32_c3_dkc02_bsc as bsc;
-use bsc::led::{RGB8, WS2812RMT};
-
+use anyhow::Result;
+use esp_idf_hal::prelude::Peripherals;
 use esp_idf_sys::{
-    c_types::c_void, esp, gpio_config, gpio_config_t, gpio_install_isr_service,
+    esp, esp_random, gpio_config, gpio_config_t, gpio_install_isr_service,
     gpio_int_type_t_GPIO_INTR_POSEDGE, gpio_isr_handler_add, gpio_mode_t_GPIO_MODE_INPUT,
-    xQueueGenericCreate, xQueueGiveFromISR, xQueueReceive, QueueHandle_t,ESP_INTR_FLAG_IRAM, esp_random,
+    xQueueGenericCreate, xQueueGiveFromISR, xQueueReceive, QueueHandle_t, ESP_INTR_FLAG_IRAM,
 };
+use rgb_led::{RGB8, WS2812RMT};
+use std::ptr;
 
 // This `static mut` holds the queue handle we are going to get from `xQueueGenericCreate`.
 // This is unsafe, but we are careful not to enable our GPIO interrupt handler until after this value has been initialised, and then never modify it again
 static mut EVENT_QUEUE: Option<QueueHandle_t> = None;
 
 #[link_section = ".iram0.text"]
-unsafe extern "C" fn button_interrupt(_: *mut c_void) {
+unsafe extern "C" fn button_interrupt(_: *mut core::ffi::c_void) {
     xQueueGiveFromISR(EVENT_QUEUE.unwrap(), std::ptr::null_mut());
 }
 
-fn main() -> anyhow::Result<()> {
+fn main() -> Result<()> {
+    let peripherals = Peripherals::take().unwrap();
 
-    let mut led = WS2812RMT::new()?;
+    let mut led = WS2812RMT::new(peripherals.pins.gpio2, peripherals.rmt.channel0)?;
     const GPIO_NUM: i32 = 9;
-    
+
     // Configures the button
     let io_conf = gpio_config_t {
         pin_bit_mask: 1 << GPIO_NUM,
         mode: gpio_mode_t_GPIO_MODE_INPUT,
         pull_up_en: true.into(),
         pull_down_en: false.into(),
-        intr_type: gpio_int_type_t_GPIO_INTR_POSEDGE, // positive edge trigger = button down
+        intr_type: gpio_int_type_t_GPIO_INTR_POSEDGE, // Positive edge trigger = button down
     };
 
     // Queue configurations
     const QUEUE_TYPE_BASE: u8 = 0;
-    const ITEM_SIZE: u32 = 0; // we're not posting any actual data, just notifying
+    const ITEM_SIZE: u32 = 0; // We're not posting any actual data, just notifying
     const QUEUE_SIZE: u32 = 1;
 
     unsafe {
         // Writes the button configuration to the registers
         esp!(gpio_config(&io_conf))?;
 
-
         // Installs the generic GPIO interrupt handler
         esp!(gpio_install_isr_service(ESP_INTR_FLAG_IRAM as i32))?;
 
@@ -60,24 +60,22 @@ fn main() -> anyhow::Result<()> {
 
     // Reads the queue in a loop.
     loop {
-
-
         unsafe {
-            // maximum delay
+            // Maximum delay
             const QUEUE_WAIT_TICKS: u32 = 1000;
 
             // Reads the event item out of the queue
             let res = xQueueReceive(EVENT_QUEUE.unwrap(), ptr::null_mut(), QUEUE_WAIT_TICKS);
-            
-            // If the event has the value 0, nothing happens. if it has a different value, the button was pressed. 
-            // If the button was pressed, a function that changes the state of the LED is called. 
-        
+
+            // If the event has the value 0, nothing happens. if it has a different value, the button was pressed.
+            // If the button was pressed, a function that changes the state of the LED is called.
+
             match res {
                 1 => {
                     // Generates random rgb values and sets them in the led.
                     random_light(&mut led);
-                },
-                _ => {},
+                }
+                _ => {}
             };
         }
     }
@@ -93,6 +91,6 @@ fn random_light(led: &mut WS2812RMT) {
 
         color = RGB8::new(r, g, b);
     }
-    
+
     led.set_pixel(color).unwrap();
 }

advanced/button-interrupt/rust-toolchain.toml

@@ -1,5 +1,2 @@
 [toolchain]
-
-
-channel = "nightly-2022-03-10"
-
+channel = "nightly-2023-02-28"

advanced/button-interrupt/src/main.rs

@@ -1,65 +1,61 @@
-// reference:
+// Reference:
 // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/freertos.html
-use std::ptr;
-
+use anyhow::Result;
 use esp_idf_sys::{
-    c_types::c_void, esp, gpio_config, gpio_config_t, gpio_install_isr_service,
+    esp, esp_random, gpio_config, gpio_config_t, gpio_install_isr_service,
     gpio_int_type_t_GPIO_INTR_POSEDGE, gpio_isr_handler_add, gpio_mode_t_GPIO_MODE_INPUT,
-    xQueueGenericCreate, xQueueGiveFromISR, xQueueReceive, QueueHandle_t,ESP_INTR_FLAG_IRAM, esp_random,
+    xQueueGenericCreate, xQueueGiveFromISR, xQueueReceive, QueueHandle_t, ESP_INTR_FLAG_IRAM,
 };
+use std::ptr;
 
 // These imports are needed for part 2.
-use esp32_c3_dkc02_bsc as bsc;
-use bsc::led::{RGB8, WS2812RMT};
+use rgb_led::{RGB8, WS2812RMT};
 
 // 4. Create a `static mut` that holds the queue handle.
 static mut EVENT_QUEUE: Option<QueueHandle_t> = None;
 
-// 6. Define what the interrupt handler does, once the button is pushed. Button_interrupt sends a message into the queue. 
+// 6. Define what the interrupt handler does, once the button is pushed. Button_interrupt sends a message into the queue.
 #[link_section = ".iram0.text"]
-unsafe extern "C" fn button_interrupt(_: *mut c_void) {
+unsafe extern "C" fn button_interrupt(_: *mut core::ffi::c_void) {
     xQueueGiveFromISR(EVENT_QUEUE.unwrap(), std::ptr::null_mut());
 }
 
-fn main() -> anyhow::Result<()> {
+fn main() -> Result<()> {
     const GPIO_NUM: i32 = 9;
 
-    // 1. Add GPIO configuration c struct
+    // 1. Add GPIO configuration C struct
     // let io_conf = gpio_config_t {
     //     ...
     // };
 
     unsafe {
-
-        // 2. write the GPIO configuration into the register
+        // 2. Write the GPIO configuration into the register
         // esp!(...)?;
 
-
         // 3. Install the global GPIO interrupt handler
         // esp!(...)?;
 
         // Queue configurations
         const QUEUE_TYPE_BASE: u8 = 0;
-        const ITEM_SIZE: u32 = 0; 
+        const ITEM_SIZE: u32 = 0;
         const QUEUE_SIZE: u32 = 1;
 
         // 5. Create an event queue
         // EVENT_QUEUE = Some(...);
-
-
+
         // 7. Add the button GPIO and the function to the interrupt handler
         // esp!(...)?;
     }
 
     // The loop in main waits until it gets a message through the rx ("receiver") part of the channel
     loop {
         unsafe {
-            // maximum delay
+            // Maximum delay
             const QUEUE_WAIT_TICKS: u32 = 1000;;
 
             // 8. Receive the event from the queue.
             // let res = ...;
-            
+
             // 9. Handle the value of res.
             // ...
         }