Added DN23E08 arduino code and added chaser.py

DN23E08/DN23E08.ino

@@ -0,0 +1,30 @@
+#include <ModbusSerial.h>
+#include "coils.h"
+#include "discrete_inputs.h"
+#include "input_registers.h"
+
+#define BAUD_RATE 57600
+#define SLAVE_ID 1
+
+ModbusSerial mb (Serial, SLAVE_ID);
+uint8_t led;
+
+void setup() {
+  Serial.begin (BAUD_RATE);
+  while (! Serial);
+  mb.config(BAUD_RATE);
+  setupCoils(mb);
+  setupDiscreteInputs(mb);
+  setupInputRegisters(mb);
+  pinMode(LED_BUILTIN, OUTPUT);
+}
+
+void loop() {
+  digitalWrite(LED_BUILTIN, led > 128);
+  led++;
+
+  discreteInputsTask(mb);
+  inputRegistersTask(mb);
+  mb.task();
+  coilsTask(mb);
+}

DN23E08/coils.cpp

@@ -0,0 +1,125 @@
+#include "coils.h"
+
+void mbToCoils(ModbusSerial& mb);
+void coilsToShiftOutRegisters(size_t i);
+void outputShiftOutRegisters();
+
+Coils coils;
+ShiftOutRegistersUnion shiftOutRegisters;
+size_t digitIndex;
+
+void setupCoils(ModbusSerial& mb) {
+  pinMode(DATA_PIN_595, OUTPUT);
+  pinMode(OE_PIN_595, OUTPUT);
+  pinMode(LATCH_PIN_595, OUTPUT);
+  pinMode(CLOCK_PIN_595, OUTPUT);
+
+  digitalWrite(OE_PIN_595, LOW);
+
+  for (size_t i = 0; i < COIL_COUNT; i++)
+    mb.addCoil (i);
+}
+
+void coilsTask(ModbusSerial& mb) {
+  mbToCoils(mb);
+  coilsToShiftOutRegisters(digitIndex);
+  digitIndex = (digitIndex + 1) % 4;
+  outputShiftOutRegisters();
+}
+
+void mbToCoils(ModbusSerial& mb) {
+  coils.relays.J1 = mb.coil(0);
+  coils.relays.J2 = mb.coil(1);
+  coils.relays.J3 = mb.coil(2);
+  coils.relays.J4 = mb.coil(3);
+  coils.relays.J5 = mb.coil(4);
+  coils.relays.J6 = mb.coil(5);
+  coils.relays.J7 = mb.coil(6);
+  coils.relays.J8 = mb.coil(7);
+
+  coils.digit0.A = mb.coil(8);
+  coils.digit0.B = mb.coil(9);
+  coils.digit0.C = mb.coil(10);
+  coils.digit0.D = mb.coil(11);
+  coils.digit0.E = mb.coil(12);
+  coils.digit0.F = mb.coil(13);
+  coils.digit0.G = mb.coil(14);
+  coils.digit0.H = mb.coil(15);
+
+  coils.digit1.A = mb.coil(16);
+  coils.digit1.B = mb.coil(17);
+  coils.digit1.C = mb.coil(18);
+  coils.digit1.D = mb.coil(19);
+  coils.digit1.E = mb.coil(20);
+  coils.digit1.F = mb.coil(21);
+  coils.digit1.G = mb.coil(22);
+  coils.digit1.H = mb.coil(23);
+
+  coils.digit2.A = mb.coil(24);
+  coils.digit2.B = mb.coil(25);
+  coils.digit2.C = mb.coil(26);
+  coils.digit2.D = mb.coil(27);
+  coils.digit2.E = mb.coil(28);
+  coils.digit2.F = mb.coil(29);
+  coils.digit2.G = mb.coil(30);
+  coils.digit2.H = mb.coil(31);
+
+  coils.digit3.A = mb.coil(32);
+  coils.digit3.B = mb.coil(33);
+  coils.digit3.C = mb.coil(34);
+  coils.digit3.D = mb.coil(35);
+  coils.digit3.E = mb.coil(36);
+  coils.digit3.F = mb.coil(37);
+  coils.digit3.G = mb.coil(38);
+  coils.digit3.H = mb.coil(39);
+}
+
+void coilsToShiftOutRegisters(size_t i) {
+  switch(i) {
+    case 0:
+      shiftOutRegisters.shiftOutRegisters.u6 = coils.digit0;
+      shiftOutRegisters.shiftOutRegisters.u8.G1 = 0;
+      shiftOutRegisters.shiftOutRegisters.u8.G2 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G3 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G4 = 1;
+      shiftOutRegisters.shiftOutRegisters.u5 = coils.relays;
+      break;
+    case 1:
+      shiftOutRegisters.shiftOutRegisters.u6 = coils.digit1;
+      shiftOutRegisters.shiftOutRegisters.u8.G1 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G2 = 0;
+      shiftOutRegisters.shiftOutRegisters.u8.G3 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G4 = 1;
+      shiftOutRegisters.shiftOutRegisters.u5 = coils.relays;
+      break;
+    case 2:
+      shiftOutRegisters.shiftOutRegisters.u6 = coils.digit2;
+      shiftOutRegisters.shiftOutRegisters.u8.G1 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G2 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G3 = 0;
+      shiftOutRegisters.shiftOutRegisters.u8.G4 = 1;
+      shiftOutRegisters.shiftOutRegisters.u5 = coils.relays;
+      break;
+    default:
+      shiftOutRegisters.shiftOutRegisters.u6 = coils.digit3;
+      shiftOutRegisters.shiftOutRegisters.u8.G1 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G2 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G3 = 1;
+      shiftOutRegisters.shiftOutRegisters.u8.G4 = 0;
+      shiftOutRegisters.shiftOutRegisters.u5 = coils.relays;
+      break;
+  }
+}
+
+void outputShiftOutRegisters() {
+  digitalWrite(LATCH_PIN_595, LOW);
+  shiftOut(DATA_PIN_595, CLOCK_PIN_595, MSBFIRST, shiftOutRegisters.bytes[2]);
+  shiftOut(DATA_PIN_595, CLOCK_PIN_595, MSBFIRST, shiftOutRegisters.bytes[1]);
+  shiftOut(DATA_PIN_595, CLOCK_PIN_595, MSBFIRST, shiftOutRegisters.bytes[0]);
+  digitalWrite(LATCH_PIN_595, HIGH);
+}
+
+
+
+
+

DN23E08/coils.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <Arduino.h>
+#include <ModbusSerial.h>
+
+#define COIL_COUNT 40
+
+#define DATA_PIN_595 9
+#define OE_PIN_595 10
+#define LATCH_PIN_595 11
+#define CLOCK_PIN_595 12
+
+struct U6 {
+  bool A: 1;
+  bool B: 1;
+  bool C: 1;
+  bool D: 1;
+  bool E: 1;
+  bool F: 1;
+  bool G: 1;
+  bool H: 1;
+};
+
+struct U8 {
+  bool G1: 1;
+  bool G2: 1;
+  bool G3: 1;
+  bool G4: 1;
+  unsigned NC: 4;
+};
+
+struct U5 {
+  bool J1: 1;
+  bool J2: 1;
+  bool J3: 1;
+  bool J4: 1;
+  bool J5: 1;
+  bool J6: 1;
+  bool J7: 1;
+  bool J8: 1;
+};
+
+struct ShiftOutRegisters {
+  U6 u6;
+  U8 u8;
+  U5 u5;
+};
+
+union ShiftOutRegistersUnion {
+  ShiftOutRegisters shiftOutRegisters;
+  uint8_t bytes[3];
+};
+
+struct Coils {
+  U5 relays;
+  U6 digit0;
+  U6 digit1;
+  U6 digit2;
+  U6 digit3;
+};
+
+void setupCoils(ModbusSerial& mb);
+void coilsTask(ModbusSerial& mb);

DN23E08/discrete_inputs.cpp

@@ -0,0 +1,61 @@
+#include "discrete_inputs.h"
+
+ShiftInRegisterUnion shiftInRegister;
+Keys keys;
+DiscreteInputs discreteInputs;
+
+void setupDiscreteInputs(ModbusSerial& mb) {
+  pinMode(KEY_1_PIN, INPUT_PULLUP);
+  pinMode(KEY_2_PIN, INPUT_PULLUP);
+  pinMode(KEY_3_PIN, INPUT_PULLUP);
+  pinMode(KEY_4_PIN, INPUT_PULLUP);
+
+  pinMode(LOAD_PIN_165, OUTPUT);
+  pinMode(CLOCK_PIN_165, OUTPUT);
+  pinMode(DATA_PIN_165, INPUT);
+
+  for (size_t i = 0; i < DISCRETE_INPUT_COUNT; i++)
+    mb.addIsts(i);
+}
+
+void discreteInputsTask(ModbusSerial& mb) {
+  keys.KEY_1 = !digitalRead(KEY_1_PIN);
+  keys.KEY_2 = !digitalRead(KEY_2_PIN);
+  keys.KEY_3 = !digitalRead(KEY_3_PIN);
+  keys.KEY_4 = !digitalRead(KEY_4_PIN);
+
+  digitalWrite(CLOCK_PIN_165, HIGH);
+  digitalWrite(LOAD_PIN_165, LOW);
+  digitalWrite(LOAD_PIN_165, HIGH);
+  shiftInRegister.byte = shiftIn(DATA_PIN_165, CLOCK_PIN_165, MSBFIRST) ^ 0XFF;
+
+  discreteInputs.digitalInputs = shiftInRegister.shiftInRegister;
+  discreteInputs.keys = keys;
+
+  mb.setIsts(0, discreteInputs.digitalInputs.INPUT1);
+  mb.setIsts(1, discreteInputs.digitalInputs.INPUT2);
+  mb.setIsts(2, discreteInputs.digitalInputs.INPUT3);
+  mb.setIsts(3, discreteInputs.digitalInputs.INPUT4);
+  mb.setIsts(4, discreteInputs.digitalInputs.INPUT5);
+  mb.setIsts(5, discreteInputs.digitalInputs.INPUT6);
+  mb.setIsts(6, discreteInputs.digitalInputs.INPUT7);
+  mb.setIsts(7, discreteInputs.digitalInputs.INPUT8);
+
+  mb.setIsts(8, discreteInputs.keys.KEY_1);
+  mb.setIsts(9, discreteInputs.keys.KEY_2);
+  mb.setIsts(10, discreteInputs.keys.KEY_3);
+  mb.setIsts(11, discreteInputs.keys.KEY_4);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

DN23E08/discrete_inputs.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <Arduino.h>
+#include <ModbusSerial.h>
+
+#define DISCRETE_INPUT_COUNT 12
+
+#define DATA_PIN_165 2
+#define CLOCK_PIN_165 3
+#define LOAD_PIN_165 4
+
+#define KEY_1_PIN 5
+#define KEY_2_PIN 6
+#define KEY_3_PIN 7
+#define KEY_4_PIN 8
+
+struct U11 {
+  bool INPUT1: 1;
+  bool INPUT2: 1;
+  bool INPUT3: 1;
+  bool INPUT4: 1;
+  bool INPUT5: 1;
+  bool INPUT6: 1;
+  bool INPUT7: 1;
+  bool INPUT8: 1;
+};
+
+union ShiftInRegisterUnion {
+  U11 shiftInRegister;
+  uint8_t byte;
+};
+
+struct Keys {
+  bool KEY_1;
+  bool KEY_2;
+  bool KEY_3;
+  bool KEY_4;
+};
+
+struct DiscreteInputs {
+  U11 digitalInputs;
+  Keys keys;
+};
+
+void setupDiscreteInputs(ModbusSerial& mb);
+void discreteInputsTask(ModbusSerial& mb);

DN23E08/input_registers.cpp

@@ -0,0 +1,50 @@
+#include "input_registers.h"
+
+AnalogInputs analogInputs;
+
+void setupInputRegisters(ModbusSerial& mb) {
+  pinMode(ADC_0_PIN, INPUT);
+  pinMode(ADC_1_PIN, INPUT);
+  pinMode(ADC_2_PIN, INPUT);
+  pinMode(ADC_3_PIN, INPUT);
+  pinMode(ADC_4_PIN, INPUT);
+  pinMode(ADC_5_PIN, INPUT);
+  pinMode(ADC_6_PIN, INPUT);
+  pinMode(ADC_7_PIN, INPUT);
+
+  for (size_t i = 0; i < INPUT_REGISTERS_COUNT; i++)
+    mb.addIreg(i);
+}
+
+void inputRegistersTask(ModbusSerial& mb) {
+  analogInputs.ADC_0 = analogRead(ADC_0_PIN);
+  analogInputs.ADC_1 = analogRead(ADC_1_PIN);
+  analogInputs.ADC_2 = analogRead(ADC_2_PIN);
+  analogInputs.ADC_3 = analogRead(ADC_3_PIN);
+  analogInputs.ADC_4 = analogRead(ADC_4_PIN);
+  analogInputs.ADC_5 = analogRead(ADC_5_PIN);
+  analogInputs.ADC_6 = analogRead(ADC_6_PIN);
+  analogInputs.ADC_7 = analogRead(ADC_7_PIN);
+
+  mb.setIreg(0, analogInputs.ADC_0);
+  mb.setIreg(1, analogInputs.ADC_1);
+  mb.setIreg(2, analogInputs.ADC_2);
+  mb.setIreg(3, analogInputs.ADC_3);
+  mb.setIreg(4, analogInputs.ADC_4);
+  mb.setIreg(5, analogInputs.ADC_5);
+  mb.setIreg(6, analogInputs.ADC_6);
+  mb.setIreg(7, analogInputs.ADC_7);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

DN23E08/input_registers.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <Arduino.h>
+#include <ModbusSerial.h>
+
+#define INPUT_REGISTERS_COUNT 8
+
+#define ADC_0_PIN A0
+#define ADC_1_PIN A1
+#define ADC_2_PIN A2
+#define ADC_3_PIN A3
+#define ADC_4_PIN A4
+#define ADC_5_PIN A5
+#define ADC_6_PIN A6
+#define ADC_7_PIN A7
+
+struct AnalogInputs {
+  uint16_t ADC_0;
+  uint16_t ADC_1;
+  uint16_t ADC_2;
+  uint16_t ADC_3;
+  uint16_t ADC_4;
+  uint16_t ADC_5;
+  uint16_t ADC_6;
+  uint16_t ADC_7;
+};
+
+void setupInputRegisters(ModbusSerial& mb);
+void inputRegistersTask(ModbusSerial& mb);