Microcontroller projects

    mkdir py_env
    python -m venv ~/py_env/env_for_pymodbus
    source ~/py_env/env_for_pymodbus/bin/activate
    pip install pymodbus asyncio pygments click prompt_toolkit --upgrade

    pymodbus.console tcp --host 192.168.1.76 --port 502

    > client.read_holding_registers address=0
    > client.read_holding_registers address=11

    > client.read_holding_registers count=4 address=50000    

    /*modbus_master_RTU_485_lib_4-20mA
      weigu.lu
      We're using a MAX485-compatible RS485 Transceiver build with a Teensy 2.
      Rx/Tx is hooked up to the pins of the hardware serial port at Serial1.
      PD2 = RXD1 (GPIO 7), PD3 = TXD1 (GPIO 8)
      The data enable and receiver Enable pins connected together and 
      are hooked up on Teensy PD7 = GPIO 10
    */

    #include <ModbusMaster.h>               //Library for ModbusMaster (4-20mA)

    const byte MAX485_DE_RE = 10; // halfduplex pin
    const unsigned long MODBUS_BITRATE = 38400;
    const byte MODBUS_SLAVE_ADDRESS = 5;
    const unsigned int HOLD_REG_ADDRESS = 50000;
    const byte NUMBER_OF_REG_2_READ = 4;
    byte result;

    ModbusMaster node;                    //object node for class ModbusMaster

    void preTransmission() {            //Function for setting stste of Pins DE & RE of RS-485  
      digitalWrite(MAX485_DE_RE, 1);
    }

    void postTransmission() {  
      digitalWrite(MAX485_DE_RE, 0);
    }

    void setup() {
      Serial.begin(115200); // Serial monitor
      while (!Serial);      // Wait for Serial (Teensy Leonardo)
      Serial.println("Serial ok"); 
      pinMode(MAX485_DE_RE, OUTPUT);   
      digitalWrite(MAX485_DE_RE, 0); // receive mode  
      Serial1.begin(38400);          // Modbus communication runs at 38400 baud
      node.begin(MODBUS_SLAVE_ADDRESS, Serial1);            
      node.preTransmission(preTransmission);  // callback to config transreceiver
      node.postTransmission(postTransmission);// callback to config transreceiver  
    }

    void loop() {    
      uint16_t data[8];
      // Read NUMBER_OF_REG_2_READ registers starting at HOLDING_REG_ADDRESS)  
      result = node.readHoldingRegisters(HOLD_REG_ADDRESS, NUMBER_OF_REG_2_READ);
      if (result == node.ku8MBSuccess)  {
        for (byte j = 0; j < 4; j++)    {
          data[j] = node.getResponseBuffer(j);
          Serial.write(data[j]);          
        }
      }  
      Serial.println("\n---------------");    
      delay(1000);
    }

    /* ModbusTCP for W5x00 Ethernet library; Basic Server code example
    * (c)2020 Alexander Emelianov (a.m.emelianov@gmail.com)
    * https://github.com/emelianov/modbus-esp8266
    * This code is licensed under the BSD New License. See LICENSE.txt for more info.
    */

    #include <SPI.h>
    #include <Ethernet.h>       // Ethernet library v2 is required
    #include <ModbusEthernet.h>

    const byte PIN_SS = 0; // GPIO0 for SS Pin
    // Enter a MAC address and IP address for your controller below.
    IPAddress ip(192, 168, 1, 176); // The IP address will be dependent on your local network
    byte mac[] = {
      0xD2, 0xAD, 0xB3, 0xEF, 0xFE, 0x11
    };
    int value = 10;
    ModbusEthernet mb;              // Declare ModbusTCP instance

    void setup() {
      Serial.begin(115200);     // Open serial communications and wait for port to open  
      Ethernet.init(PIN_SS);    // SS pin
      Ethernet.begin(mac, ip);  // start the Ethernet connection
      delay(1000);              // give the Ethernet shield a second to initialize
      mb.server();              // Act as Modbus TCP server
      mb.addHreg(0,0,100);      // Add 100 holding register: addHreg(offset, value = 0, numregs = 1)
      for(byte i = 0; i<100; i++) { //write values to hreg
        mb.Hreg(i,value);
        value++;
      }  
      Serial.println("Modbus server started");
    }

    void loop() {
      mb.task();                // Server Modbus TCP queries
      delay(50);
    }