#include <hardware/uart>
...
// Task function
void serialTask(void *pvParams) {

    char input;
    char echo_msg[30];

    // Initializing serial communications
    // Parameters 8n1 9600
    uart_init(uart0, 9600);
    // Setting up UART with default pins
    gpio_set_function(0, GPIO_FUNC_UART);
    gpio_set_function(1, GPIO_FUNC_UART);

    // Eternal loop
    while(1) {
        // Receiving 1 character at a time to the input-variable
        input = uart_getc(uart0);
        // Sending back a string
        sprintf(echo_msg, "Received: %c\n", input);
        uart_puts(uart0, echo_msg);
        // Politely sleeping for a second
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

int main(void) {
    ...
    stdio_init_all();
    ...
    return 0;
}

// Handler function
void uartFxn() {
    // Now new data is available, it is given to some other function for handling (just for example)
    do_something_fast(uart_getc(uart0));
}

void uartTask(void *pvParams) {
    
    uart_init(uart0, 9600);

    gpio_set_function(0, GPIO_FUNC_UART);
    gpio_set_function(1, GPIO_FUNC_UART);

    // Assigning an interruption handler uartFxn for the interruptions of UART0
    irq_set_exclusive_handler(UART0_IRQ, uartFxn);
    // Start receiving interruptions
    irq_set_enabled(UART0_IRQ, true);

    // We tell the UART that we want to receive interruptions,
    // when new data is available
    uart_set_irq_enables(uart0, true, false);

    while(1) {
        //Infinite loop.
        tight_loop_contents();
        //Here for instance, we could check if there is new data and operate with it. 
    }
}

int main() {
    ...
    stdio_init_all();
    ...
    return 0;
}

void sensorTask(void *pvParameters) {
    float temperature;
    // Initializing I2C-bus
    i2c_init(i2c_default, 400*1000);
    // Setting the default pins for I2C to be used by our program
    gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);
    gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);
    gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);
    gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);

    // Read and write buffers for I2C messages
   
   uint8_t txBuffer[1]; // Now we send one byte
   uint8_t rxBuffer[2]; // Now we receive two bytes
   
   txBuffer [0] = HDC2021_TEMP_LOW; 

    while(1) {
        if(i2c_write_blocking(i2c_default, HDC2021_I2C_ADDRESS , txBuffer, 1, true) != PICO_ERROR_GENERIC) {
            if(i2c_read_blocking(i2c_default, HDC2021_I2C_ADDRESS, rxBuffer, 2, false) != PICO_ERROR_GENERIC) {                
                // Changing the 2-byte data in rxBuffer
                // into a temperature value (formula in exercise material)
                //PART OF THE LAB SESSION.
                temperature = ... ;

                // Temperature value to console window
                printf("%f", temperature);
            }
        }
        else {
            printf("I2C Bus fault\n");
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
    // Closing the I2C connection, though the infinite loop never gets here
    i2c_deinit(i2c_default);
}

int main() {
    ...
    stdio_init_all();
    //Code to create the sensorTask. Seen in previous slides

    //Starting the schedule.
    vTaskStartScheduler();
    return 0;
}

    i2c_init(i2c_default, 400*1000);

    gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);
    gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);
    gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);
    gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);

    uint8_t txBuffer[1];
    uint8_t rxBuffer[2];

    txBuffer[0] = HDC2021_TEMP_LOW;

       if(i2c_write_blocking(i2c_default, HDC2021_I2C_ADDRESS, txBuffer, 1, true) != PICO_ERROR_GENERIC) {
            ...
        }
        else {
            printf("I2C Bus fault\n");
        }

...
    if(i2c_read_blocking(i2c_default, HDC2021_I2C_ADDRESS, rxBuffer, 2, false) != PICO_ERROR_GENERIC) {
    temperature = ... ;
    printf("%f", temperature);
    }
    else {
    printf("I2C Bus fault\n");
    }
...

   ...
   i2c_deinit(i2c_default);
   ...

pico_enable_stdio_usb(your_target 1)
pico_enable_stdio_uart(your_target 0)  // optional

#include "stdio.h"
#include "pico/stdlib.h"
#include "pico/stdio.h"  

int main(void) {
    stdio_init_all();                 // or stdio_usb_init();

    while (!stdio_usb_connected()) {  // optional: wait for a terminal
        sleep_ms(10);
    }

    puts("USB ready.");

    while(1) {
        int ch = getchar_timeout_us(1000);   // non-blocking poll
        if (ch >= 0) {
            putchar_raw((char)ch);        // echo back exactly what we received
        }
        // Example block write elsewhere:
        // fwrite(buf, 1, len, stdout);
        // stdio_flush();
        tight_loop_contents();
    }
}

#include "pico/stdio.h"

#include "FreeRTOS.h"
#include "task.h"
#include "tusb.h"

#define CDC_ITF_TX      1


// ---- Task generating sensor data ----
static void sensorTask (void *arg){
    char buf[BUFFER_SIZE]; 

    while (!tud_mounted() || !tud_cdc_n_connected(1)){
        vTaskDelay(pdMS_TO_TICKS(50));
    }

    while (1) {
        int temp = ....; // Obtained somewhere else in the code
        int lux  = ....; // Obtained somewhere else in the code. 
        
        if (tud_cdc_n_connected(CDC_ITF_TX)){
            // Send them using tud_cdc_n_write
            snprintf(buf, BUFFER_SIZE, "%d, %d\n", temp, lux);
            tud_cdc_n_write(CDC_ITF_TX, buf, strlen(buf));
            tud_cdc_n_write_flush(CDC_ITF_TX);
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}


// ---- Task running USB stack ----
static void usbTask(void *arg) {
    (void)arg;
    while (1) {
        tud_task();              // With FreeRTOS, wait for events
                                 // Do not add vTaskDelay.
    }
}


int main (void) {

    // Create tasks
    TaskHandle_t hUsb = NULL;
    xTaskCreate(usbTask, "usb", 1024, NULL, 3, &hUsb);
    xTaskCreate(sensorTask, "app", 1024, NULL, 2, NULL);

    #if (configNUMBER_OF_CORES > 1)
        vTaskCoreAffinitySet(hUsb, 1u << 0);
    #endif
     // Initialize TinyUSB first. This code should be just before to vTaskStartScheduler();
    tusb_init();
    vTaskStartScheduler();
}

#include "pico/stdio.h"

#include "FreeRTOS.h"
#include "task.h"
#include "tusb.h"

// callback when data is received on a CDC interface
void tud_cdc_rx_cb(uint8_t itf){   
    // allocate buffer for the data on the stack
    uint8_t buf[CFG_TUD_CDC_RX_BUFSIZE + 1];

    // read the available data 
    // | IMPORTANT: do this for CDC0 as well, otherwise
    // | printing to CDC0 can stall (its RX buffer fills up)
    // | before the next time this function is called
    uint32_t count = tud_cdc_n_read(itf, buf, sizeof(buf));

    // check if the data was received on the second CDC interface
    if (itf == 1) {
        // Process the data here (e.g., store in a buffer or send to another task).
        // ...

        // Be gentle and send an OK back. 
        tud_cdc_n_write(itf, (uint8_t const *) "OK\n", 3);
        tud_cdc_n_write_flush(itf);
    }

    // Optional: if you need a C-string, you can terminate it:
    // if (count < sizeof(buf)) buf[count] = '\0';
}

#include "pico/stdio.h"

#include "FreeRTOS.h"
#include "task.h"
#include "tusb.h"
#include "usbSerialDebug/helper.h"

#define CDC_ITF_TX  1
// #define BUFFER_SIZE  ...  // define this to a suitable size if not defined elsewhere

// ---- Task generating sensor data ----
static void sensorTask(void *arg) {
    char buf[BUFFER_SIZE];

    // Wait until USB is mounted and CDC1 is connected (data port)
    while (!tud_mounted() || !tud_cdc_n_connected(CDC_ITF_TX)) {
        vTaskDelay(pdMS_TO_TICKS(50));
    }

    while (1) {
        int temp = ....; // Obtained somewhere else in the code
        int lux  = ....; // Obtained somewhere else in the code

        // Send sensor data over CDC1 using TinyUSB (computer reads /dev/ttyACM1 on Unix)
        if (tud_cdc_n_connected(CDC_ITF_TX)) {
            snprintf(buf, BUFFER_SIZE, "%d, %d\n", temp, lux);
            tud_cdc_n_write(CDC_ITF_TX, buf, strlen(buf));
            tud_cdc_n_write_flush(CDC_ITF_TX);
        }

        // Send debug text over CDC0 using the helper library (computer reads /dev/ttyACM0 on Unix)
        if (usb_serial_connected()) {
            snprintf(buf, BUFFER_SIZE, "temp:%d, light:%d\n", temp, lux);
            usb_serial_print(buf);
            usb_serial_flush();
        }

        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// ---- Task running USB stack ----
static void usbTask(void *arg) {
    (void)arg;
    while (1) {
        tud_task();              // With FreeRTOS, wait for events
                                 // Do not add vTaskDelay.
    }
}

int main(void) {

    // Create tasks
    TaskHandle_t hUsb = NULL;
    xTaskCreate(usbTask, "usb", 1024, NULL, 3, &hUsb);
    xTaskCreate(sensorTask, "app", 1024, NULL, 2, NULL);

    #if (configNUMBER_OF_CORES > 1)
        vTaskCoreAffinitySet(hUsb, 1u << 0);
    #endif
    // This two functions should be just before vTaskStartScheduler
    // Initialize TinyUSB first
    tusb_init();

    // Initialize helper library to write via CDC0
    usb_serial_init();
    vTaskStartScheduler();
}