Microcontroller projects

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
    ''' pico_hat_i2c.py  weigu.lu
        Raspberry Pi is Master, Pico is slave
        This test program sends the 3 bytes to the Pico, defining how often
        the onboard LED will blink and defining the delay time in ms between
        the toggling (command 0x0A).
        It reads 2x2 bytes from the Arduino (temperature (0x81) and humitity (0x82)
        More infos on weigu.lu '''

    import smbus

    PORT = 1 # (0 for rev.1, 1 for rev 2!)
    I2C = smbus.SMBus(PORT)
    PICO_I2C_ADDRESS = 0x20

    COMMAND_TEMP1 = 0x81  # MSB = 1 for read
    COMMAND_HUM1 = 0x82
    COMMAND_BLINK = 0x0A  # MSB = 0 for write
    BLINK_RATE = 10       # how many times to blink (1 byte)
    BLINK_DELAY = 50      # delay between toggling im ms (1 word)

    def get_sensor_data(command):
        ''' write command and read data (1 word)'''
        I2C.write_byte(PICO_I2C_ADDRESS, command)
        return I2C.read_word_data(PICO_I2C_ADDRESS, command)/100.0

    def set_blink(blink_command, blink_rate, blink_delay):
        ''' write to Pico: blink rate (1 byte) and delay (2 byte)'''
        blink = [] # list for 3 bytes
        blink.append(blink_rate)
        blink.append(blink_delay//256)
        blink.append(blink_delay%256)
        I2C.write_i2c_block_data(PICO_I2C_ADDRESS, blink_command, blink)

    # main: try the commands
    print("Temperature 1: ", get_sensor_data(COMMAND_TEMP1), "°C")
    print("Humidity 1:    ", get_sensor_data(COMMAND_HUM1), "%")
    set_blink(COMMAND_BLINK, BLINK_RATE, BLINK_DELAY)

    sudo apt install cutecom

  Serial1.setRX(17);
  Serial1.setTX(16);
  Serial1.begin(115200);

    /* pico_hat_i2c.ino   weigu.lu
     * Raspberry Pi is Master, Pico is slave
     * The Raspi program sends 3 bytes to the Pico, defining how often
     * the onboard LED will blink and defining the delay time in ms between
     * the toggling (command 0x0A).
     * The pico responds with 2x2 bytes (temperature and humidity) when receiving
     * the commands 0x81 and 0x82.
     * More infos on weigu.lu
     */

    #include <Wire.h>

    //#define DEBUG      // uncomment if more infos needed in serial monitor

    const byte PICO_I2C_ADDRESS = 0x20;
    const byte LED_PIN = LED_BUILTIN;   // LED_BUILTIN or other pin
    bool LED_LOGIC = 1;                 // positive logic: 1, negative logic: 0
    const unsigned long DELAY_MS = 3000;
    const unsigned long LED_BLINK_DELAY_MS = 100;

    struct {
      float volatile t1; // temperature
      float volatile h1; // humidity
    } tx_data;

    struct {
      byte volatile blink_nr = 3;
      word volatile blink_delay = 100;
    } rx_data;

    byte volatile command = 0;
    byte volatile rx_flag = 0;
    byte volatile tx_flag = 0;
    const byte tx_table_bytes = 20;
    byte volatile tx_table[tx_table_bytes]; // prepare data for sending over I2C

    void setup() {
      Serial.begin(115200);             // for debugging
      init_led();
      Wire.begin(PICO_I2C_ADDRESS);     // join i2c bus
      Wire.onReceive(i2c_receive);      // i2c interrupt receive
      Wire.onRequest(i2c_transmit);     // i2c interrupt send
      tx_data.t1 = 21.30;               // simulate a temperature
      tx_data.h1 = 60;                  // simulate humidity value
    }

    void loop() {
      blink_led_x_times(rx_data.blink_nr,rx_data.blink_delay);
      #ifdef DEBUG
        if (rx_flag) {
          Serial.println("RX with " + String(rx_flag) + "byte; command: " + String(command));
          rx_flag = 0;
        }
        if (tx_flag) {
          print_tx_table();
          tx_flag = 0;
        }
      #else
        delay(3000);
      #endif
    }

    void i2c_receive(int bytes_count) { // bytes_count gives number of bytes in rx buffer
      if (bytes_count == 0) {           //  master checked only for presence
        return;
      }
      command = Wire.read();
      switch (command) {   // parse commands
        case 0x0A:  // read three bytes (blink nr and delay time)
          rx_data.blink_nr = Wire.read();
          rx_data.blink_delay = Wire.read();
          rx_data.blink_delay = rx_data.blink_delay*256 + Wire.read();
          break;
        default:
          break;
      }
      rx_flag = bytes_count;
    }

    void i2c_transmit() {
      byte bytes_count = 1;
      int tmp1 = 0;                     // temporary variable
      switch (command) {
        case 0x81: // temperature
          tmp1 = int(round(tx_data.t1 * 100));
          tx_table[0] = (byte)(tmp1 & 0xFF);
          tx_table[1] = (byte)(tmp1 >> 8);
          bytes_count = 2;
          break;
        case 0x82: // humidity
          tmp1 = int(round(tx_data.h1 * 100));
          tx_table[0] = (byte)(tmp1 & 0xFF);
          tx_table[1] = (byte)(tmp1 >> 8);
          bytes_count = 2;
          break;
        default:
          break;
      }
      for (byte i = 0; i < bytes_count; i++) {
        Wire.write(tx_table[i]);
      }
      tx_flag = 1;
    }

    void print_tx_table() {
      Serial.println("Transmit Table");
      for (byte i = 0; i < tx_table_bytes; i++) {
        Serial.print("  " + String(i) + ": " + String(tx_table[i]));
      }
      Serial.println();
    }

    /****** LED HELPER functions *************************************************/

    // initialise the build in LED and switch it on
    void init_led() {
      pinMode(LED_PIN,OUTPUT);
      led_on();
    }

    // LED on
    void led_on() {
      LED_LOGIC ? digitalWrite(LED_PIN,HIGH) : digitalWrite(LED_PIN,LOW);
    }

    // LED off
    void led_off() {
      LED_LOGIC ? digitalWrite(LED_PIN,LOW) : digitalWrite(LED_PIN,HIGH);
    }

    // blink LED x times (LED was on) with delay_time_ms
    void blink_led_x_times(byte x, word delay_time_ms) {
      for(byte i = 0; i < x; i++) { // Blink x times
        led_off();
        delay(delay_time_ms);
        led_on();
        delay(delay_time_ms);
      }
    }

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    # pico_raspi_i2c_test.py  weigu.lu  Raspberry Pi is Master, Pico is slave

    import smbus
    import time

    PORT = 1 # (0 for rev.1, 1 for rev 2!)
    I2c = smbus.SMBus(PORT)
    PICO_I2C_ADDRESS = 0x20
    command = 0x64

    #I2c.write_byte(PICO_I2C_ADDRESS,command)
    time.sleep(0.001)
    print(hex(I2c.read_byte_data(PICO_I2C_ADDRESS,command)))

   ...
    I2c.write_byte(PICO_I2C_ADDRESS,command)
    time.sleep(0.001)
    print(hex(I2c.read_byte_data(PICO_I2C_ADDRESS,command)))
    ...

    // pico_raspi_i2c_test.ino    weigu.lu 

    #include <Wire.h>

    const byte PICO_I2C_ADDRESS = 0x20;
    byte volatile rx_flag = 0;
    byte volatile tx_flag = 0;
    byte volatile rx_buffer[] = {0,0,0,0,0,0,0,0,0,0};
    byte volatile tx_buffer[] = {0,0,0,0,0,0,0,0,0,0};

    void setup() {
      Serial.begin(115200);  // for debugging
      Wire.begin(PICO_I2C_ADDRESS);    // join i2c bus
      Wire.onReceive(i2c_receive);     // i2c interrupt receive
      Wire.onRequest(i2c_transmit);    // i2c interrupt send 
    }

    void loop() {
      if (rx_flag) {
        for (byte i=0; i<rx_flag; i++) {
          Serial.print("RX: ");
          Serial.print(rx_buffer[i]);
          Serial.print('\t');
        }
        Serial.print('\n');
        rx_flag = 0;
      }

      if (tx_flag) {
        Serial.println("TX");
        Serial.println(rx_buffer[0]);
        tx_flag = 0;
      }  
      delay(1); 
    }

    void i2c_receive(int bytes_count) {  // bytes_count gives number of bytes in rx buffer    
      for (byte i=0; i<bytes_count;i++) {
        rx_buffer[i] = Wire.read(); 
      }  
      rx_flag = bytes_count;
    }


    void i2c_transmit() { 
      tx_flag = 1;
      Wire.write("0");
    }