User Tools

Site Tools

한국어
You are here: index » logicpython » cubloc_api » setmodbus
logicpython:cubloc_api:setmodbus

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
logicpython:cubloc_api:setmodbus [2026/04/10 07:00] – [Example] mfranklinlogicpython:cubloc_api:setmodbus [2026/04/14 05:10] (current) – [Example] mfranklin
Line 1: Line 1:
 ====== SetModbus ====== ====== SetModbus ======
  
-Start the LogicPython Modbus RTU slave worker using a pre-opened UART ''channel''.+Configure UART settings and start the LogicPython Modbus RTU slave process.
  
 ===== Syntax ===== ===== Syntax =====
Line 8: Line 8:
 from cubloc import SetModbus from cubloc import SetModbus
  
-SetModbus(channel: int, +SetModbus(channel: int, 
 +    baudRate: int, 
 +    protocol: int, 
 +    recvSize: int, 
 +    sendSize: int,
     slaveAddress: int,     slaveAddress: int,
     coils: object,     coils: object,
Line 20: Line 24:
 ===== Parameters ===== ===== Parameters =====
  
-  * **channel**: RS-232 ''channel'' number. ''OpenCom'' must already be called for this ''channel''. +    * **channel**: Serial ''channel'' number. ''Channel'' 0 maps to UART0 (GP0/GP1) and ''channel'' 1 maps to UART1 (GP4/GP5). 
-  * **slaveAddress**: Modbus unit ID (1 to 247). +    * **baudRate**: Serial baud rate (2400 to 921600). 
-  * **coils**: Writable bit-packed coil buffer (8 ''coils'' per byte). +    * **protocol**: Encoded bit field for data bits, parity, and stop bits.  See the tables below. 
-  * **discreteInputs**: Writable bit-packed discrete-input buffer (8 inputs per byte). +    * **recvSize**: Receive buffer size in bytes (1 to 4096). 
-  * **inputRegisters**: Writable input-register byte buffer (2 bytes per register). +    * **sendSize**: Send buffer size in bytes (1 to 4096). 
-  * **holdingRegisters**: Writable holding-register byte buffer (2 bytes per register). +    * **slaveAddress**: Modbus unit ID (1 to 247). 
-  * **memoryLock**: User-created lock object passed through to logic_python.modbus.start_modbus. +    * **coils**: Writable bit-packed coil buffer (8 ''coils'' per byte). 
-  * **returnInterval**: Non-blocking delay in microseconds before sending a response (default 0).+    * **discreteInputs**: Writable bit-packed discrete-input buffer (8 inputs per byte). 
 +    * **inputRegisters**: Writable input-register byte buffer (2 bytes per register). 
 +    * **holdingRegisters**: Writable holding-register byte buffer (2 bytes per register). 
 +    * **memoryLock**: lock object to synchronize Modbus memory access between the user program and the Modbus RTU slave process. 
 +    * **returnInterval**: Delay in microseconds before replying to a Modbus query from the Modbus master (default 0). 
 + 
 +''protocol'' bit layout: 
 + 
 +^ Field ^ Bits ^ Meaning ^ 
 +| Data bits | 1..0 | 00=5 bits, 01=6 bits, 10=7 bits, 11=8 bits | 
 +| Stop bits | 2 | 0=1 stop bit, 1=2 stop bits | 
 +| Parity | 4..3 | 00=None, 10=Even, 11=Odd (01 is reserved and raises ''ValueError'') | 
 + 
 +Common ''protocol'' values: 
 + 
 +^ protocol ^ Frame format ^ 
 +| 3 | 8N1 | 
 +| 11 | 8E1 | 
 +| 19 | 8O1 | 
 +| 7 | 8N2 |
  
 ===== Exceptions ===== ===== Exceptions =====
  
-  * [[https://docs.micropython.org/en/latest/library/builtins.html#TypeError|TypeError]]: An argument has an invalid type. +    * [[https://docs.micropython.org/en/latest/library/builtins.html#TypeError|TypeError]]: An argument has an invalid type. 
-  * [[https://docs.micropython.org/en/latest/library/builtins.html#ValueError|ValueError]]: ''slaveAddress'' is outside the supported range. +    * [[https://docs.micropython.org/en/latest/library/builtins.html#ValueError|ValueError]]: ''baudRate'', ''protocol'', ''recvSize'', ''sendSize'', or ''slaveAddress'' is outside the supported range. 
-  * [[https://docs.micropython.org/en/latest/library/builtins.html#RuntimeError|RuntimeError]]: ''OpenCom'' has not been called for this ''channel'' or Modbus startup failed.+    * [[https://docs.micropython.org/en/latest/library/builtins.html#RuntimeError|RuntimeError]]: Modbus startup failed.
  
 ===== Example ===== ===== Example =====
Line 43: Line 66:
 from cubloc import * from cubloc import *
  
-# Coils 0-3           -> digital outputs on GP14, GP16, GP18, GP20 +OUTPUT_PINS = (25, 16, 18, 20)
-# Discrete inputs 0-2 <- digital inputs  on GP6, GP8, GP10 +
-# Input registers 0-2 <- ADC readings    on ADC0 (GP26), ADC1 (GP27), ADC2 (GP28) +
-# Holding register 0  -> setpoint value written by the Modbus master +
- +
-OUTPUT_PINS = (14, 16, 18, 20)+
 INPUT_PINS  = (6,  8,  10) INPUT_PINS  = (6,  8,  10)
 ADC_CHANS   = (0,  1,  2) ADC_CHANS   = (0,  1,  2)
  
-# Allocate Modbus memory regions 
-coils           = bytearray(1)   # 8 coils (1 byte, bits 0-3 used) 
-discrete_inputs = bytearray(1)   # 8 discrete inputs (1 byte, bits 0-2 used) 
-input_regs      = bytearray(6)   # 3 input registers x 2 bytes each 
-holding_regs    = bytearray(2)   # 1 holding register x 2 bytes 
-mem_lock        = _thread.allocate_lock() 
- 
-# Configure physical I/O 
 for pin in OUTPUT_PINS: for pin in OUTPUT_PINS:
     Output(pin)     Output(pin)
Line 66: Line 76:
     Input(pin)     Input(pin)
  
-# Open UART0 at 460800 baud, 8N1 +# Configure and start the Modbus RTU slave process 
-OpenCom(0, 460800, 3, 1024, 1024)+UART_CHANNEL = 0 
 +BAUD_RATE = 115200 
 +PROTOCOL = 3        # 8N1 
 +BUFFER_SIZE = 64 
 +SLAVE_ADDRESS = 1
  
-# Start Modbus RTU slave, address 1 +coils           = bytearray(1) 
-SetModbus(0, 1, coils, discrete_inputs, input_regs, holding_regs, mem_lock)+discrete_inputs = bytearray(1) 
 +input_regs      = bytearray(6) 
 +holding_regs    = bytearray(2) 
 +mem_lock        = _thread.allocate_lock() 
 + 
 +SetModbus(UART_CHANNEL, 
 +    BAUD_RATE, 
 +    PROTOCOL, 
 +    BUFFER_SIZE, 
 +    BUFFER_SIZE, 
 +    SLAVE_ADDRESS,  
 +    coils, discrete_inputs, input_regs, holding_regs, mem_lock)
  
-# Main loop: mirror Modbus memory to/from physical I/O every 10 ms 
 while True: while True:
-    with mem_lock: +    # Read coils snapshot under lock 
-        # Drive output pins from coil bits (master writes coils 0-3) +    mem_lock.acquire() 
-        for i, pin in enumerate(OUTPUT_PINS): +    try: 
-            if coils[0] & (1 << i): +        coils_byte = coils[0] 
-                High(pin) +    finally: 
-            else: +        mem_lock.release()
-                Low(pin)+
  
-        # Capture digital inputs and store as discrete-input bits (master reads) +    # Drive outputs from that snapshot 
-        din_byte = 0 +    for i, pin in enumerate(OUTPUT_PINS): 
-        for i, pin in enumerate(INPUT_PINS): +        if coils_byte & (1 << i): 
-            if In(pin): +            High(pin) 
-                din_byte |= (1 << i)+        else: 
 +            Low(pin) 
 + 
 +    # Sample physical inputs outside the lock 
 +    din_byte = 0 
 +    for i, pin in enumerate(INPUT_PINS): 
 +        if In(pin): 
 +            din_byte |= (1 << i) 
 + 
 +    adc_vals = [ADIn(ch) for ch in ADC_CHANS] 
 + 
 +    # Publish a coherent snapshot and read setpoint atomically 
 +    mem_lock.acquire() 
 +    try:
         discrete_inputs[0] = din_byte         discrete_inputs[0] = din_byte
  
-        # Capture ADC readings and store in input registers (big-endian, master reads) +        for i, val in enumerate(adc_vals): 
-        for i, ch in enumerate(ADC_CHANS): +            struct.pack_into('>H', input_regs, i * 2, val)
-            struct.pack_into('>H', input_regs, i * 2, ADIn(ch))+
  
-        # Read setpoint value from holding register 0 (master writes) 
         setpoint = struct.unpack_from('>H', holding_regs, 0)[0]         setpoint = struct.unpack_from('>H', holding_regs, 0)[0]
 +    finally:
 +        mem_lock.release()
  
     time.sleep(0.010)     time.sleep(0.010)
 </code> </code>
- 
-===== Related APIs ===== 
- 
-  * [[logicpython:cubloc_api:opencom|OpenCom]] 
  
  
logicpython/cubloc_api/setmodbus.1775804440.txt.gz · Last modified: by mfranklin

Page Tools