Lab 12: Mutexes and Message Queues

#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>

void blinkHandler(void);
K_THREAD_DEFINE(blinkThread_id, 1024, blinkHandler, NULL, NULL, NULL, 7, 0, 100); (1)

void rotateHandler(void);
K_THREAD_DEFINE(rotateThread_id, 1024, rotateHandler, NULL, NULL, NULL, 7, 0, 10000); (2)

#define FIRST_PIN 13
#define NUM_LEDS 4
#define PORT0_NI DT_NODELABEL(gpio0)
const struct device *port = DEVICE_DT_GET(PORT0_NI);
gpio_port_value_t led_mask = ((1<<NUM_LEDS) - 1) << FIRST_PIN; (3)
K_MUTEX_DEFINE(ledMutex); (4)

int main(void) {
    if (device_is_ready(port)) {
        for (int pin = FIRST_PIN; pin < FIRST_PIN+NUM_LEDS; pin++) {
            gpio_pin_configure(port, pin, GPIO_OUTPUT_INACTIVE | GPIO_ACTIVE_LOW);
        }
    } else return -1;
    return 0;
}

void blinkHandler(void) {
    while (true) {
        k_mutex_lock(&ledMutex, K_FOREVER); (5)
        for (int i = 0; i < 10; i++) {
            gpio_port_toggle_bits(port, led_mask);
            k_msleep(500);
        }
        k_mutex_unlock(&ledMutex); (6)
        k_msleep(5000);
    }
}

void rotateHandler(void) {
    while (true) {
        k_mutex_lock(&ledMutex, K_FOREVER);
        for (int pin = FIRST_PIN; pin < FIRST_PIN + NUM_LEDS; pin++) {
            gpio_port_set_masked(port, led_mask, BIT(pin));
            k_msleep(200);
        }
        gpio_port_set_masked(port, led_mask, 0);
        k_mutex_unlock(&ledMutex);
    }
}

#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/adc.h>

struct temp_data_t { (1)
    float temperature; // in Celsius
    uint32_t timestamp; // in milliseconds
};
K_MSGQ_DEFINE(temp_msgq, sizeof(struct temp_data_t), 5, 1); (2)

void recordData(void);
K_THREAD_DEFINE(recorderThread_id, 1024, recordData, NULL, NULL, NULL, 7, 0, 0);

#define TMP36 DT_NODELABEL(temp0)
#define MV_AT_25C DT_PROP(TMP36, vtemp25)
#define MV_PER_DEG_C DT_PROP(TMP36, sensor_slope)
#define NUM_ADC_READINGS 10
const struct adc_dt_spec tmp36 = ADC_DT_SPEC_GET(TMP36);

LOG_MODULE_REGISTER(Lab12b, LOG_LEVEL_DBG);

int main(void) {
    struct temp_data_t data;
    while (true) {
        while (k_msgq_get(&temp_msgq, &data, K_NO_WAIT) == 0) { (3)
            LOG_INF("Temperature: %.1f C, Timestamp: %u", data.temperature, data.timestamp);
        }
        k_msleep(10000);
    }
}

void recordData(void) {
    struct temp_data_t data;
    int err;
    uint16_t buf;
    int val_mV;
    float T_in_C;
    struct adc_sequence tmp_reading = {
        .buffer = &buf,
        .buffer_size = sizeof(buf)
    };
    adc_channel_setup_dt(&tmp36);
    adc_sequence_init_dt(&tmp36, &tmp_reading);

    while (true) {
        adc_read_dt(&tmp36, &tmp_reading);
        val_mV = (int)buf;
        adc_raw_to_millivolts_dt(&tmp36, &val_mV);
        T_in_C = 25.0 + ((float)val_mV - (float)MV_AT_25C)/(float)MV_PER_DEG_C;
        data.temperature = T_in_C; (4)
        data.timestamp = k_uptime_get_32(); (5)
        k_msgq_put(&temp_msgq, &data, K_FOREVER); (6)
        k_msleep(1000);
    }
}