Ignition SCADA + MKR WiFi 1010

If you're trying to learn Ignition and want a source of actual data, this tutorial demonstrates how to feed Ignition with Arduino.

Mar 27, 2020

•

12754 views

•

12 respects

mkr wifi 1010

modbus

ignition

Components and supplies

Temperature Sensor

Push Button

Rotary potentiometer (generic)

Arduino MKR 485 Shield

Arduino MKR WiFi 1010

Apps and platforms

Ignition SCADA

Project description

Code

MKR_WiFI_1010_Ignition_VFD

arduino

Used to connect MKR WiFi 1010 to Ignition SCADA via Modbus TCP connection

1// This sketch is for the following hardware:
2//      - Arduino MKR  WiFi 1010 + MKR RS-485 Shield
3//      - Automation Direct GS2 VFD drive, model  GS2-11P0
4// The manual for the VDF can be read at: 
5//      - https://cdn.automationdirect.com/static/manuals/gs2m/gs2m.html
6//  Written by: Nick Robinson, Last Updated 26-Mar-2020
7
8#include <SPI.h>
9#include  <WiFiNINA.h>          
10#include <utility/wifi_drv.h>
11#include <ArduinoRS485.h>       // ArduinoModbus depends on the ArduinoRS485 library
12#include <ArduinoModbus.h>
13
14//Wifi  network name and password
15char ssid[] = "Kaisoku";       
16char pass[] =  "Tsunagaru";
17
18//Modbus coil address mapping
19const int modAddButton =  0x00;
20const int modAddRedLED = 0x01;
21const int modAddGreenLED = 0x02;
22const  int modAddBlueLED = 0x03;
23const int modAddRunStop = 0x04;
24const int modAddFwdRev  = 0x05;
25
26//Modbus holding register address mapping
27const int modAddPotVal  = 0x00;
28const int modAddTempVal = 0x01;
29const int modAddDriveFreq = 0x02;
30const  int modAddAccelDecel = 0x03;
31const int modAddRpm = 0x04;
32const int modAddDriveStatus  = 0x05;
33
34//VFD parameters and modbus addresses
35const int vfd = 0x02;                   
36const  int driveRatio = 29;
37
38const int Add_accel = 0x0101;           // Acceleration  time
39const int Add_decel = 0x0102;           // Deceleration time
40const int  Add_rpm = 0x2107;             // motor rpm 
41const int Add_Status1 = 0x2100;         //  Status monitor 1
42const int Add_driveFreq = 0x091A;       // 0 to 60 Hz                 
43const  int Add_stopRun = 0x091B;         // 0 = stop, 1 = run
44const int Add_fwdRev =  0x091C;          // 0 = forward, 1 = reverse
45
46//VFD related input / output  variables
47int inputFreq;
48int inputStopGo;
49int inputDirection;
50int inputAccelDecelTime;
51int  outputRpm;
52int outputDriveStatus;
53
54//Arduino hardware input / output variables
55const  int buttonPin = 5;                //pushbutton on D5
56const int redLED = 26;                  //uses  on board RGB LED
57const int greenLED = 25;
58const int blueLED = 27;
59int buttonValue,  prevButtonValue, buttonSwitch;
60
61int status = WL_IDLE_STATUS;
62
63WiFiServer  wifiServer(502);             //TCP Modbus on port 502
64ModbusTCPServer modbusTCPServer;
65
66void  setup() {
67  Serial.begin(9600);
68  ModbusRTUClient.begin(19200, SERIAL_8O1);
69  while (status != WL_CONNECTED) {
70    Serial.print("Attempting to connect to  SSID: ");
71    Serial.println(ssid);
72    status = WiFi.begin(ssid, pass);
73    delay(1000);
74  }
75  Serial.println("Modbus TCP Server");
76  printWifiStatus();  //before start-up, open serial monitor in order to see the assigned IP address
77  wifiServer.begin();
78
79  if (!modbusTCPServer.begin()) {
80    Serial.println("Failed  to start Modbus TCP Server!");
81    while (1);
82  }
83  pinMode(buttonPin,  INPUT);
84  WiFiDrv::pinMode(redLED, OUTPUT); 
85  WiFiDrv::pinMode(greenLED,  OUTPUT); 
86  WiFiDrv::pinMode(blueLED, OUTPUT); 
87  WiFiDrv::digitalWrite(redLED,  LOW);
88  WiFiDrv::digitalWrite(greenLED, LOW);
89  WiFiDrv::digitalWrite(blueLED,  LOW);
90
91  modbusTCPServer.configureCoils(0x00, 10);
92  modbusTCPServer.configureHoldingRegisters(0x00,  10);
93}
94
95void loop() {
96  WiFiClient client = wifiServer.available();
97  
98  if (client) {
99    Serial.println("Ignition! Connected");
100    modbusTCPServer.accept(client);
101
102    while (client.connected()) {
103      modbusTCPServer.poll();
104      updateButton();
105      updateLED();
106      updatePot();
107      updateTemp();
108      updateVFD();
109    }
110    Serial.println("disconnected");
111  }
112}
113
114void updateButton()  {
115  buttonValue = digitalRead(buttonPin);
116  if(buttonValue != prevButtonValue){
117    if(buttonValue == HIGH){
118      buttonSwitch = !buttonSwitch;
119    }
120  prevButtonValue = buttonValue;
121  }
122  modbusTCPServer.coilWrite(modAddButton,  buttonSwitch);
123}
124
125void updateLED() {
126  int coilValue_red = modbusTCPServer.coilRead(modAddRedLED);
127  int coilValue_green = modbusTCPServer.coilRead(modAddGreenLED);
128  int coilValue_blue  = modbusTCPServer.coilRead(modAddBlueLED);
129
130  WiFiDrv::digitalWrite(redLED,  coilValue_red);
131  WiFiDrv::digitalWrite(greenLED, coilValue_green);
132  WiFiDrv::digitalWrite(blueLED,  coilValue_blue);
133}
134
135void updatePot() {
136  int potRawVal = analogRead(A4);
137  //raw value is sent, conversion to voltage is done in Ignition
138  modbusTCPServer.holdingRegisterWrite(modAddPotVal,  potRawVal);  
139}
140
141void updateTemp() {
142  int tempRawVal = analogRead(A3);
143  //raw value is sent, conversion to temperature is done in Ignition
144  modbusTCPServer.holdingRegisterWrite(modAddTempVal,  tempRawVal);
145}
146
147void updateVFD() {
148  inputStopGo = modbusTCPServer.coilRead(modAddRunStop);
149  inputDirection = modbusTCPServer.coilRead(modAddFwdRev);
150  inputFreq = (modbusTCPServer.holdingRegisterRead(modAddDriveFreq))  * 10;
151  inputAccelDecelTime = modbusTCPServer.holdingRegisterRead(modAddAccelDecel);  
152  
153  if(inputAccelDecelTime == 0) 
154    inputAccelDecelTime = 50;
155  
156  if(!ModbusRTUClient.holdingRegisterWrite(vfd, Add_driveFreq, inputFreq) ||
157     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_stopRun, inputStopGo) ||
158     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_fwdRev, inputDirection) ||
159     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_accel, inputAccelDecelTime)  ||
160     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_decel, inputAccelDecelTime))
161        errorFlash();
162        
163  outputRpm = ModbusRTUClient.holdingRegisterRead(vfd,  Add_rpm);
164  outputDriveStatus = ModbusRTUClient.holdingRegisterRead(vfd, Add_Status1);
165  if(outputRpm == -1 || outputDriveStatus == -1)
166    errorFlash();
167  else  outputRpm = outputRpm / driveRatio;
168  
169  modbusTCPServer.holdingRegisterWrite(modAddRpm,  outputRpm);
170  modbusTCPServer.holdingRegisterWrite(modAddDriveStatus, outputDriveStatus);
171}
172
173void  errorFlash(){                    
174  pinMode(LED_BUILTIN, OUTPUT);                 
175  digitalWrite(LED_BUILTIN, HIGH);
176  delay(100);
177  digitalWrite(LED_BUILTIN,  LOW);
178  delay(100);
179}
180
181void printWifiStatus() {
182  Serial.print("SSID:  ");
183  Serial.println(WiFi.SSID());
184
185  IPAddress ip = WiFi.localIP();
186  Serial.print("IP Address: ");
187  Serial.println(ip);
188
189  long rssi =  WiFi.RSSI();
190  Serial.print("signal strength (RSSI):");
191  Serial.print(rssi);
192  Serial.println(" dBm");
193}
194

// This sketch is for the following hardware:
//      - Arduino MKR  WiFi 1010 + MKR RS-485 Shield
//      - Automation Direct GS2 VFD drive, model  GS2-11P0
// The manual for the VDF can be read at: 
//      - https://cdn.automationdirect.com/static/manuals/gs2m/gs2m.html
//  Written by: Nick Robinson, Last Updated 26-Mar-2020

#include <SPI.h>
#include  <WiFiNINA.h>          
#include <utility/wifi_drv.h>
#include <ArduinoRS485.h>       // ArduinoModbus depends on the ArduinoRS485 library
#include <ArduinoModbus.h>

//Wifi  network name and password
char ssid[] = "Kaisoku";       
char pass[] =  "Tsunagaru";

//Modbus coil address mapping
const int modAddButton =  0x00;
const int modAddRedLED = 0x01;
const int modAddGreenLED = 0x02;
const  int modAddBlueLED = 0x03;
const int modAddRunStop = 0x04;
const int modAddFwdRev  = 0x05;

//Modbus holding register address mapping
const int modAddPotVal  = 0x00;
const int modAddTempVal = 0x01;
const int modAddDriveFreq = 0x02;
const  int modAddAccelDecel = 0x03;
const int modAddRpm = 0x04;
const int modAddDriveStatus  = 0x05;

//VFD parameters and modbus addresses
const int vfd = 0x02;                   
const  int driveRatio = 29;

const int Add_accel = 0x0101;           // Acceleration  time
const int Add_decel = 0x0102;           // Deceleration time
const int  Add_rpm = 0x2107;             // motor rpm 
const int Add_Status1 = 0x2100;         //  Status monitor 1
const int Add_driveFreq = 0x091A;       // 0 to 60 Hz                 
const  int Add_stopRun = 0x091B;         // 0 = stop, 1 = run
const int Add_fwdRev =  0x091C;          // 0 = forward, 1 = reverse

//VFD related input / output  variables
int inputFreq;
int inputStopGo;
int inputDirection;
int inputAccelDecelTime;
int  outputRpm;
int outputDriveStatus;

//Arduino hardware input / output variables
const  int buttonPin = 5;                //pushbutton on D5
const int redLED = 26;                  //uses  on board RGB LED
const int greenLED = 25;
const int blueLED = 27;
int buttonValue,  prevButtonValue, buttonSwitch;

int status = WL_IDLE_STATUS;

WiFiServer  wifiServer(502);             //TCP Modbus on port 502
ModbusTCPServer modbusTCPServer;

void  setup() {
  Serial.begin(9600);
  ModbusRTUClient.begin(19200, SERIAL_8O1);
  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to  SSID: ");
    Serial.println(ssid);
    status = WiFi.begin(ssid, pass);
    delay(1000);
  }
  Serial.println("Modbus TCP Server");
  printWifiStatus();  //before start-up, open serial monitor in order to see the assigned IP address
  wifiServer.begin();

  if (!modbusTCPServer.begin()) {
    Serial.println("Failed  to start Modbus TCP Server!");
    while (1);
  }
  pinMode(buttonPin,  INPUT);
  WiFiDrv::pinMode(redLED, OUTPUT); 
  WiFiDrv::pinMode(greenLED,  OUTPUT); 
  WiFiDrv::pinMode(blueLED, OUTPUT); 
  WiFiDrv::digitalWrite(redLED,  LOW);
  WiFiDrv::digitalWrite(greenLED, LOW);
  WiFiDrv::digitalWrite(blueLED,  LOW);

  modbusTCPServer.configureCoils(0x00, 10);
  modbusTCPServer.configureHoldingRegisters(0x00,  10);
}

void loop() {
  WiFiClient client = wifiServer.available();
  
  if (client) {
    Serial.println("Ignition! Connected");
    modbusTCPServer.accept(client);

    while (client.connected()) {
      modbusTCPServer.poll();
      updateButton();
      updateLED();
      updatePot();
      updateTemp();
      updateVFD();
    }
    Serial.println("disconnected");
  }
}

void updateButton()  {
  buttonValue = digitalRead(buttonPin);
  if(buttonValue != prevButtonValue){
    if(buttonValue == HIGH){
      buttonSwitch = !buttonSwitch;
    }
  prevButtonValue = buttonValue;
  }
  modbusTCPServer.coilWrite(modAddButton,  buttonSwitch);
}

void updateLED() {
  int coilValue_red = modbusTCPServer.coilRead(modAddRedLED);
  int coilValue_green = modbusTCPServer.coilRead(modAddGreenLED);
  int coilValue_blue  = modbusTCPServer.coilRead(modAddBlueLED);

  WiFiDrv::digitalWrite(redLED,  coilValue_red);
  WiFiDrv::digitalWrite(greenLED, coilValue_green);
  WiFiDrv::digitalWrite(blueLED,  coilValue_blue);
}

void updatePot() {
  int potRawVal = analogRead(A4);
  //raw value is sent, conversion to voltage is done in Ignition
  modbusTCPServer.holdingRegisterWrite(modAddPotVal,  potRawVal);  
}

void updateTemp() {
  int tempRawVal = analogRead(A3);
  //raw value is sent, conversion to temperature is done in Ignition
  modbusTCPServer.holdingRegisterWrite(modAddTempVal,  tempRawVal);
}

void updateVFD() {
  inputStopGo = modbusTCPServer.coilRead(modAddRunStop);
  inputDirection = modbusTCPServer.coilRead(modAddFwdRev);
  inputFreq = (modbusTCPServer.holdingRegisterRead(modAddDriveFreq))  * 10;
  inputAccelDecelTime = modbusTCPServer.holdingRegisterRead(modAddAccelDecel);  
  
  if(inputAccelDecelTime == 0) 
    inputAccelDecelTime = 50;
  
  if(!ModbusRTUClient.holdingRegisterWrite(vfd, Add_driveFreq, inputFreq) ||
     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_stopRun, inputStopGo) ||
     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_fwdRev, inputDirection) ||
     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_accel, inputAccelDecelTime)  ||
     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_decel, inputAccelDecelTime))
        errorFlash();
        
  outputRpm = ModbusRTUClient.holdingRegisterRead(vfd,  Add_rpm);
  outputDriveStatus = ModbusRTUClient.holdingRegisterRead(vfd, Add_Status1);
  if(outputRpm == -1 || outputDriveStatus == -1)
    errorFlash();
  else  outputRpm = outputRpm / driveRatio;
  
  modbusTCPServer.holdingRegisterWrite(modAddRpm,  outputRpm);
  modbusTCPServer.holdingRegisterWrite(modAddDriveStatus, outputDriveStatus);
}

void  errorFlash(){                    
  pinMode(LED_BUILTIN, OUTPUT);                 
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN,  LOW);
  delay(100);
}

void printWifiStatus() {
  Serial.print("SSID:  ");
  Serial.println(WiFi.SSID());

  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  long rssi =  WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

MKR_WiFI_1010_Ignition_VFD

arduino

Used to connect MKR WiFi 1010 to Ignition SCADA via Modbus TCP connection

1// This sketch is for the following hardware:
2//      - Arduino MKR
3  WiFi 1010 + MKR RS-485 Shield
4//      - Automation Direct GS2 VFD drive, model
5  GS2-11P0
6// The manual for the VDF can be read at: 
7//      - https://cdn.automationdirect.com/static/manuals/gs2m/gs2m.html
8//
9  Written by: Nick Robinson, Last Updated 26-Mar-2020
10
11#include <SPI.h>
12#include
13  <WiFiNINA.h>          
14#include <utility/wifi_drv.h>
15#include <ArduinoRS485.h>
16       // ArduinoModbus depends on the ArduinoRS485 library
17#include <ArduinoModbus.h>
18
19//Wifi
20  network name and password
21char ssid[] = "Kaisoku";       
22char pass[] =
23  "Tsunagaru";
24
25//Modbus coil address mapping
26const int modAddButton =
27  0x00;
28const int modAddRedLED = 0x01;
29const int modAddGreenLED = 0x02;
30const
31  int modAddBlueLED = 0x03;
32const int modAddRunStop = 0x04;
33const int modAddFwdRev
34  = 0x05;
35
36//Modbus holding register address mapping
37const int modAddPotVal
38  = 0x00;
39const int modAddTempVal = 0x01;
40const int modAddDriveFreq = 0x02;
41const
42  int modAddAccelDecel = 0x03;
43const int modAddRpm = 0x04;
44const int modAddDriveStatus
45  = 0x05;
46
47//VFD parameters and modbus addresses
48const int vfd = 0x02;                   
49const
50  int driveRatio = 29;
51
52const int Add_accel = 0x0101;           // Acceleration
53  time
54const int Add_decel = 0x0102;           // Deceleration time
55const int
56  Add_rpm = 0x2107;             // motor rpm 
57const int Add_Status1 = 0x2100;         //
58  Status monitor 1
59const int Add_driveFreq = 0x091A;       // 0 to 60 Hz                 
60const
61  int Add_stopRun = 0x091B;         // 0 = stop, 1 = run
62const int Add_fwdRev =
63  0x091C;          // 0 = forward, 1 = reverse
64
65//VFD related input / output
66  variables
67int inputFreq;
68int inputStopGo;
69int inputDirection;
70int inputAccelDecelTime;
71int
72  outputRpm;
73int outputDriveStatus;
74
75//Arduino hardware input / output variables
76const
77  int buttonPin = 5;                //pushbutton on D5
78const int redLED = 26;                  //uses
79  on board RGB LED
80const int greenLED = 25;
81const int blueLED = 27;
82int buttonValue,
83  prevButtonValue, buttonSwitch;
84
85int status = WL_IDLE_STATUS;
86
87WiFiServer
88  wifiServer(502);             //TCP Modbus on port 502
89ModbusTCPServer modbusTCPServer;
90
91void
92  setup() {
93  Serial.begin(9600);
94  ModbusRTUClient.begin(19200, SERIAL_8O1);
95
96  while (status != WL_CONNECTED) {
97    Serial.print("Attempting to connect to
98  SSID: ");
99    Serial.println(ssid);
100    status = WiFi.begin(ssid, pass);
101
102    delay(1000);
103  }
104  Serial.println("Modbus TCP Server");
105  printWifiStatus();
106  //before start-up, open serial monitor in order to see the assigned IP address
107
108  wifiServer.begin();
109
110  if (!modbusTCPServer.begin()) {
111    Serial.println("Failed
112  to start Modbus TCP Server!");
113    while (1);
114  }
115  pinMode(buttonPin,
116  INPUT);
117  WiFiDrv::pinMode(redLED, OUTPUT); 
118  WiFiDrv::pinMode(greenLED,
119  OUTPUT); 
120  WiFiDrv::pinMode(blueLED, OUTPUT); 
121  WiFiDrv::digitalWrite(redLED,
122  LOW);
123  WiFiDrv::digitalWrite(greenLED, LOW);
124  WiFiDrv::digitalWrite(blueLED,
125  LOW);
126
127  modbusTCPServer.configureCoils(0x00, 10);
128  modbusTCPServer.configureHoldingRegisters(0x00,
129  10);
130}
131
132void loop() {
133  WiFiClient client = wifiServer.available();
134
135  
136  if (client) {
137    Serial.println("Ignition! Connected");
138    modbusTCPServer.accept(client);
139
140
141    while (client.connected()) {
142      modbusTCPServer.poll();
143      updateButton();
144
145      updateLED();
146      updatePot();
147      updateTemp();
148      updateVFD();
149
150    }
151    Serial.println("disconnected");
152  }
153}
154
155void updateButton()
156  {
157  buttonValue = digitalRead(buttonPin);
158  if(buttonValue != prevButtonValue){
159
160    if(buttonValue == HIGH){
161      buttonSwitch = !buttonSwitch;
162    }
163
164  prevButtonValue = buttonValue;
165  }
166  modbusTCPServer.coilWrite(modAddButton,
167  buttonSwitch);
168}
169
170void updateLED() {
171  int coilValue_red = modbusTCPServer.coilRead(modAddRedLED);
172
173  int coilValue_green = modbusTCPServer.coilRead(modAddGreenLED);
174  int coilValue_blue
175  = modbusTCPServer.coilRead(modAddBlueLED);
176
177  WiFiDrv::digitalWrite(redLED,
178  coilValue_red);
179  WiFiDrv::digitalWrite(greenLED, coilValue_green);
180  WiFiDrv::digitalWrite(blueLED,
181  coilValue_blue);
182}
183
184void updatePot() {
185  int potRawVal = analogRead(A4);
186
187  //raw value is sent, conversion to voltage is done in Ignition
188  modbusTCPServer.holdingRegisterWrite(modAddPotVal,
189  potRawVal);  
190}
191
192void updateTemp() {
193  int tempRawVal = analogRead(A3);
194
195  //raw value is sent, conversion to temperature is done in Ignition
196  modbusTCPServer.holdingRegisterWrite(modAddTempVal,
197  tempRawVal);
198}
199
200void updateVFD() {
201  inputStopGo = modbusTCPServer.coilRead(modAddRunStop);
202
203  inputDirection = modbusTCPServer.coilRead(modAddFwdRev);
204  inputFreq = (modbusTCPServer.holdingRegisterRead(modAddDriveFreq))
205  * 10;
206  inputAccelDecelTime = modbusTCPServer.holdingRegisterRead(modAddAccelDecel);
207  
208  
209  if(inputAccelDecelTime == 0) 
210    inputAccelDecelTime = 50;
211  
212
213  if(!ModbusRTUClient.holdingRegisterWrite(vfd, Add_driveFreq, inputFreq) ||
214
215     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_stopRun, inputStopGo) ||
216
217     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_fwdRev, inputDirection) ||
218
219     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_accel, inputAccelDecelTime)
220  ||
221     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_decel, inputAccelDecelTime))
222
223        errorFlash();
224        
225  outputRpm = ModbusRTUClient.holdingRegisterRead(vfd,
226  Add_rpm);
227  outputDriveStatus = ModbusRTUClient.holdingRegisterRead(vfd, Add_Status1);
228
229  if(outputRpm == -1 || outputDriveStatus == -1)
230    errorFlash();
231  else
232  outputRpm = outputRpm / driveRatio;
233  
234  modbusTCPServer.holdingRegisterWrite(modAddRpm,
235  outputRpm);
236  modbusTCPServer.holdingRegisterWrite(modAddDriveStatus, outputDriveStatus);
237}
238
239void
240  errorFlash(){                    
241  pinMode(LED_BUILTIN, OUTPUT);                 
242
243  digitalWrite(LED_BUILTIN, HIGH);
244  delay(100);
245  digitalWrite(LED_BUILTIN,
246  LOW);
247  delay(100);
248}
249
250void printWifiStatus() {
251  Serial.print("SSID:
252  ");
253  Serial.println(WiFi.SSID());
254
255  IPAddress ip = WiFi.localIP();
256
257  Serial.print("IP Address: ");
258  Serial.println(ip);
259
260  long rssi =
261  WiFi.RSSI();
262  Serial.print("signal strength (RSSI):");
263  Serial.print(rssi);
264
265  Serial.println(" dBm");
266}
267

// This sketch is for the following hardware:
//      - Arduino MKR
  WiFi 1010 + MKR RS-485 Shield
//      - Automation Direct GS2 VFD drive, model
  GS2-11P0
// The manual for the VDF can be read at: 
//      - https://cdn.automationdirect.com/static/manuals/gs2m/gs2m.html
//
  Written by: Nick Robinson, Last Updated 26-Mar-2020

#include <SPI.h>
#include
  <WiFiNINA.h>          
#include <utility/wifi_drv.h>
#include <ArduinoRS485.h>
       // ArduinoModbus depends on the ArduinoRS485 library
#include <ArduinoModbus.h>

//Wifi
  network name and password
char ssid[] = "Kaisoku";       
char pass[] =
  "Tsunagaru";

//Modbus coil address mapping
const int modAddButton =
  0x00;
const int modAddRedLED = 0x01;
const int modAddGreenLED = 0x02;
const
  int modAddBlueLED = 0x03;
const int modAddRunStop = 0x04;
const int modAddFwdRev
  = 0x05;

//Modbus holding register address mapping
const int modAddPotVal
  = 0x00;
const int modAddTempVal = 0x01;
const int modAddDriveFreq = 0x02;
const
  int modAddAccelDecel = 0x03;
const int modAddRpm = 0x04;
const int modAddDriveStatus
  = 0x05;

//VFD parameters and modbus addresses
const int vfd = 0x02;                   
const
  int driveRatio = 29;

const int Add_accel = 0x0101;           // Acceleration
  time
const int Add_decel = 0x0102;           // Deceleration time
const int
  Add_rpm = 0x2107;             // motor rpm 
const int Add_Status1 = 0x2100;         //
  Status monitor 1
const int Add_driveFreq = 0x091A;       // 0 to 60 Hz                 
const
  int Add_stopRun = 0x091B;         // 0 = stop, 1 = run
const int Add_fwdRev =
  0x091C;          // 0 = forward, 1 = reverse

//VFD related input / output
  variables
int inputFreq;
int inputStopGo;
int inputDirection;
int inputAccelDecelTime;
int
  outputRpm;
int outputDriveStatus;

//Arduino hardware input / output variables
const
  int buttonPin = 5;                //pushbutton on D5
const int redLED = 26;                  //uses
  on board RGB LED
const int greenLED = 25;
const int blueLED = 27;
int buttonValue,
  prevButtonValue, buttonSwitch;

int status = WL_IDLE_STATUS;

WiFiServer
  wifiServer(502);             //TCP Modbus on port 502
ModbusTCPServer modbusTCPServer;

void
  setup() {
  Serial.begin(9600);
  ModbusRTUClient.begin(19200, SERIAL_8O1);

  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to
  SSID: ");
    Serial.println(ssid);
    status = WiFi.begin(ssid, pass);

    delay(1000);
  }
  Serial.println("Modbus TCP Server");
  printWifiStatus();
  //before start-up, open serial monitor in order to see the assigned IP address

  wifiServer.begin();

  if (!modbusTCPServer.begin()) {
    Serial.println("Failed
  to start Modbus TCP Server!");
    while (1);
  }
  pinMode(buttonPin,
  INPUT);
  WiFiDrv::pinMode(redLED, OUTPUT); 
  WiFiDrv::pinMode(greenLED,
  OUTPUT); 
  WiFiDrv::pinMode(blueLED, OUTPUT); 
  WiFiDrv::digitalWrite(redLED,
  LOW);
  WiFiDrv::digitalWrite(greenLED, LOW);
  WiFiDrv::digitalWrite(blueLED,
  LOW);

  modbusTCPServer.configureCoils(0x00, 10);
  modbusTCPServer.configureHoldingRegisters(0x00,
  10);
}

void loop() {
  WiFiClient client = wifiServer.available();

  
  if (client) {
    Serial.println("Ignition! Connected");
    modbusTCPServer.accept(client);


    while (client.connected()) {
      modbusTCPServer.poll();
      updateButton();

      updateLED();
      updatePot();
      updateTemp();
      updateVFD();

    }
    Serial.println("disconnected");
  }
}

void updateButton()
  {
  buttonValue = digitalRead(buttonPin);
  if(buttonValue != prevButtonValue){

    if(buttonValue == HIGH){
      buttonSwitch = !buttonSwitch;
    }

  prevButtonValue = buttonValue;
  }
  modbusTCPServer.coilWrite(modAddButton,
  buttonSwitch);
}

void updateLED() {
  int coilValue_red = modbusTCPServer.coilRead(modAddRedLED);

  int coilValue_green = modbusTCPServer.coilRead(modAddGreenLED);
  int coilValue_blue
  = modbusTCPServer.coilRead(modAddBlueLED);

  WiFiDrv::digitalWrite(redLED,
  coilValue_red);
  WiFiDrv::digitalWrite(greenLED, coilValue_green);
  WiFiDrv::digitalWrite(blueLED,
  coilValue_blue);
}

void updatePot() {
  int potRawVal = analogRead(A4);

  //raw value is sent, conversion to voltage is done in Ignition
  modbusTCPServer.holdingRegisterWrite(modAddPotVal,
  potRawVal);  
}

void updateTemp() {
  int tempRawVal = analogRead(A3);

  //raw value is sent, conversion to temperature is done in Ignition
  modbusTCPServer.holdingRegisterWrite(modAddTempVal,
  tempRawVal);
}

void updateVFD() {
  inputStopGo = modbusTCPServer.coilRead(modAddRunStop);

  inputDirection = modbusTCPServer.coilRead(modAddFwdRev);
  inputFreq = (modbusTCPServer.holdingRegisterRead(modAddDriveFreq))
  * 10;
  inputAccelDecelTime = modbusTCPServer.holdingRegisterRead(modAddAccelDecel);
  
  
  if(inputAccelDecelTime == 0) 
    inputAccelDecelTime = 50;
  

  if(!ModbusRTUClient.holdingRegisterWrite(vfd, Add_driveFreq, inputFreq) ||

     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_stopRun, inputStopGo) ||

     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_fwdRev, inputDirection) ||

     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_accel, inputAccelDecelTime)
  ||
     !ModbusRTUClient.holdingRegisterWrite(vfd, Add_decel, inputAccelDecelTime))

        errorFlash();
        
  outputRpm = ModbusRTUClient.holdingRegisterRead(vfd,
  Add_rpm);
  outputDriveStatus = ModbusRTUClient.holdingRegisterRead(vfd, Add_Status1);

  if(outputRpm == -1 || outputDriveStatus == -1)
    errorFlash();
  else
  outputRpm = outputRpm / driveRatio;
  
  modbusTCPServer.holdingRegisterWrite(modAddRpm,
  outputRpm);
  modbusTCPServer.holdingRegisterWrite(modAddDriveStatus, outputDriveStatus);
}

void
  errorFlash(){                    
  pinMode(LED_BUILTIN, OUTPUT);                 

  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN,
  LOW);
  delay(100);
}

void printWifiStatus() {
  Serial.print("SSID:
  ");
  Serial.println(WiFi.SSID());

  IPAddress ip = WiFi.localIP();

  Serial.print("IP Address: ");
  Serial.println(ip);

  long rssi =
  WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);

  Serial.println(" dBm");
}

Downloadable files

Modbus Address file

Import into Ignition Gateway

Modbus Address file

Import into Ignition Gateway

Modbus Address file

Wiring for potentiometer, push button, and LM34 temp sensor

These components give you a way to create channels which can be viewed in Ignition

Wiring for potentiometer, push button, and LM34 temp sensor

Comments

Only logged in users can leave comments

NRobinson2

0 Followers

•

0 Projects

Intro