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

    char input;
    char echo_msg[30];

    // Alustetaan sarjaliikenne
    // Parametrit 8n1 9600
    uart_init(uart0, 9600);
    // Asetetaan UART käyttämään oletuspinnejään
    gpio_set_function(0, GPIO_FUNC_UART);
    gpio_set_function(1, GPIO_FUNC_UART);

    // Ikuinen elämä
    while(1) {
        // Vastaanotetaan 1 merkki kerrallaan input-muuttujaan
        input = uart_getc(uart0);
        // Lähetetään merkkijono takaisin
        sprintf(echo_msg, "Received: %c\n", input);
        uart_puts(uart0, echo_msg);
        // Kohteliaasti nukkumaan sekunniksi
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

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

// Käsittelijäfunktio
void uartFxn() {
    // Nyt dataa on saatavilla, se annetaan toisen funktion käsiteltäväksi (esimerkin vuoksi)
    tehdaan_jotain_nopeasti(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);

    // Asetetaan keskeytyksen käsittelijä uartFxn UART0:n keskeytyksille
    irq_set_exclusive_handler(UART0_IRQ, uartFxn);
    // Aletaan vastaanottamaan keskeytyksiä
    irq_set_enabled(UART0_IRQ, true);

    // Kerrotaan UART:ille, että haluamme ottaa vastaan keskeytyksiä,
    // kun dataa on luettavissa.
    uart_set_irq_enables(uart0, true, false);

    while(1) {
        // Ikuinen looppi
        tight_loop_contents();
    }

}

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

// i2c-kirjasto mukaan ohjelmaan
#include <hardware/i2c.h>
...
// Taskifunktio
void sensorTask(void *pvParameters) {
    float temperature;
    
    // Alustetaan I2C-väylä
    i2c_init(i2c_default, 400*1000);
    
    // Asetetaan Picon oletuspinnit I2C:lle ohjelman käyttöön
    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);

    // i2c-viesteille lähetys- ja vastaanottopuskurit
    uint8_t txBuffer[1]; // Nyt lähetetään yksi tavu
    uint8_t rxBuffer[2]; // Nyt vastaanotetaan kaksi tavua

    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) {
                
                // Muunnetaan 2-tavuinen data rxBuffer:ssa
                // lämpötilaksi (kaava harjoitustehtävissä)
                //PART OF THE LAB SESSION
                temperature = ... ;
                // Temperature value to console window
                printf("%f", temperature);
            }
            else {
                printf("I2C Bus fault\n");
            }
        }
        else {
            printf("I2C Bus fault\n");
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
    // i2c-yhteyden sulkeminen, tosin ikuinen silmukka ei koskaan päädy tänne
    i2c_deinit(i2c_default);
}

int main() {
    ...
    stdio_init_all();
    ...
    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)  // valinnainen

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

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

    while (!stdio_usb_connected()) {  // valinnainen: odota terminaalia
        sleep_ms(10);
    }

    puts("USB valmis.");

    while(1) {
        int ch = getchar_timeout_us(1000);   // ei-estävä kysely
        if (ch >= 0) {
            putchar_raw((char)ch);           // kaiku: lähetä takaisin tismalleen mitä saatiin
        }
        // Esimerkki lohkotulostuksesta muualla:
        // 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


// ---- Tehtävä, joka tuottaa sensoridataa ----
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 = ....; // Haettu jostain muualta koodista
        int lux  = ....; // Haettu jostain muualta koodista
        
        if (tud_cdc_n_connected(CDC_ITF_TX)){
            // Lähetä tiedot käyttäen 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));
    }
}


// ---- Tehtävä, joka pyörittää USB-pinoa ----
static void usbTask(void *arg) {
    (void)arg;
    while (1) {
        tud_task();              // FreeRTOS:issa odottaa tapahtumia
                                 // Älä lisää vTaskDelay.
    }
}


int main (void) {


    // Luo tehtävät
    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
    // AlustaTinyUSB. Must go before vTaskStartScheduler();
    tusb_init();
    vTaskStartScheduler();
}

#include 

#include 
#include 
#include 

// callback, kun CDC-liittymään saapuu dataa
void tud_cdc_rx_cb(uint8_t itf){   
    // varaa puskuri datalle pinosta
    uint8_t buf[CFG_TUD_CDC_RX_BUFSIZE + 1];

    // lue saatavilla oleva data
    // | TÄRKEÄÄ: tee tämä myös CDC0:lle, muuten
    // | tulostus CDC0:een voi pysähtyä (RX-puskuri täyttyy)
    // | ennen kuin tätä funktiota kutsutaan uudestaan
    uint32_t count = tud_cdc_n_read(itf, buf, sizeof(buf));

    // tarkista, tuliko data toisesta CDC-liittymästä
    if (itf == 1) {
        // Käsittele data täällä (esim. tallenna puskuriin tai lähetä toiselle tehtävälle).
        // ...

        // Vastataan kohteliaasti OK
        tud_cdc_n_write(itf, (uint8_t const *) "OK\n", 3);
        tud_cdc_n_write_flush(itf);
    }

    // Valinnaisesti: jos tarvitset C-merkkijonon, voit päättää sen:
    // 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  ...  // määrittele sopiva koko, jos ei muualla määritelty

// ---- Tehtävä, joka tuottaa sensoridataa ----
static void sensorTask(void *arg) {
    char buf[BUFFER_SIZE];

    // Odota, kunnes USB on liitetty ja CDC1 yhdistetty (dataportti)
    while (!tud_mounted() || !tud_cdc_n_connected(CDC_ITF_TX)) {
        vTaskDelay(pdMS_TO_TICKS(50));
    }

    while (1) {
        int temp = ....; // Haettu jostain muualta koodista
        int lux  = ....; // Haettu jostain muualta koodista

        // Lähetä sensoridata CDC1:n kautta (tietokone lukee /dev/ttyACM1 Unixissa)
        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);
        }

        // Lähetä debug-teksti CDC0:n kautta käyttäen apukirjastoa (tietokone lukee /dev/ttyACM0 Unixissa)
        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));
    }
}

// ---- Tehtävä, joka pyörittää USB-pinoa ----
static void usbTask(void *arg) {
    (void)arg;
    while (1) {
        tud_task();              // FreeRTOS:issa odottaa tapahtumia
                                 // Älä lisää vTaskDelay.
    }
}

int main(void) {


    // Luo tehtävät
    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
    // Following two functions just before vTaskStartScheduler();
    // Alusta TinyUSB
    tusb_init();

    // Alusta apukirjasto kirjoittamiseen CDC0:n kautta
    usb_serial_init();
    vTaskStartScheduler();
}