Try PLC controlled with WiFi and RS-485

Check the condition of your machine from anywhere.

Jul 3, 2020

•

3246 views

•

4 respects

environmental sensing

Components and supplies

Arduino MKR WiFi 1010

Arduino MKR 485 Shield

Tools and machines

TX4S-B4R

XBM DN32H (PLC)/ eXP20-TTA/DC (Touch Panel)

Apps and platforms

Blynk

Project description

Code

Bside_TR

arduino

1// THIS IS THE "B" SIDE
2
3#include <ArduinoModbus.h>
4#include   <ArduinoRS485.h>
5#include <SPI.h>
6#include <WiFiNINA.h>
7#define BLYNK_PRINT   SerialUSB
8#include <BlynkSimpleWifi.h>
9
10BlynkTimer timer;
11
12// YOUR   WIFI
13char ssid[] = "traumwelt";      
14char pass[] = "traumwelt!!"; 
15char   auth[] = "P7GH59GKqz90pdKrrEc4F5ki3BJLupe9";
16          
17int status = WL_IDLE_STATUS;
18char   server[] = "192.168.0.57";
19WiFiClient client;
20
21// VARIABLB IN THH B SIDE
22int16_t   Aside_TEMP4;
23int16_t Bside_TEMP4;
24int8_t HMIDATA4;
25
26/* 1. HoldingRegister   ADDRESS FROM THE PLC TO THE ARDUINO
27   2. PLEASE MAKE IT SAME WRITING ADDRESS   IN THE YOUR PLC */
28    
29const int HmiData4 = 0x0004;
30
31
32/* 1. InputRegister   ADDRESS FROM THE ARDUINO TO THE PLC
33   2. PLEASE MAKE IT SAME READING ADDRESS   IN THE YOUR PLC */
34   
35const int Plc_TEMP4 = 0x0003;
36
37// RECIEVED THE   DATA OF TEMPERATURE AT "A" SIDE FROM THE BLYNK SERVER.
38 
39BLYNK_WRITE(V8)
40   {
41     Aside_TEMP4 = param.asInt();         
42  } 
43
44void setup() 
45{   
46  Serial.begin(9600);                             
47  WiFi.begin(ssid, pass);                           
48  Blynk.begin(auth, ssid, pass);
49  
50  printWifiStatus();   
51  
52  timer.setInterval(1000L,Read_Write_Data );
53
54  while(Blynk.connect()==false){     
55  }
56 
57  if (WiFi.status() == WL_NO_MODULE) 
58  {
59    Serial.println("Communication   with WiFi module failed!");
60   
61    while (true);
62  }   
63 
64  while   (WiFi.status() != WL_CONNECTED) 
65  {
66    Serial.print(".");
67    delay(500);
68   }      
69     if(!ModbusRTUServer.begin(10,2400,SERIAL_8N2))
70     {
71    Serial.println("Failed   to start Modbus RTU Server!");
72    while (1);
73     }
74       
75   /*   1. I SET IT AT THE INPUT REGISTER ADDRESS IN ARDUINO 
76      2. I SET IT AT THE   HOLDING REGISTER ADDRESS IN ARDUINO */
77      
78     ModbusRTUServer.configureInputRegisters(0x0003,1);
79      ModbusRTUServer.configureHoldingRegisters(0x0004,1);        
80  }
81  
82void   loop () 
83{    
84   Blynk.run();
85   timer.run();
86} 
87    
88 void Read_Write_Data()   
89 {
90     Read_By_PLC();
91     Read_From_Plc();
92
93     /* 1. PUT THE   VARIABLE VALUE RECEIVED FROM BLYNK'S SERVER AT THE inputRegister ADDRESS
94        2.   THE ENTERED VALUE IS SENDED TO PLC */     
95        
96     ModbusRTUServer.inputRegisterWrite(Plc_TEMP4,   Aside_TEMP4);  
97     Bside_TEMP4 = ModbusRTUServer.inputRegisterRead(Plc_TEMP4);
98      Serial.println("Aside_TEMP4");
99     Serial.println(Aside_TEMP4);
100     Serial.println("Bside_TEMP4");
101      Serial.println(Bside_TEMP4); 
102     
103 }
104     
105void Read_From_Plc()
106     {
107      /* 1.SENDS THE VARIABLE TO "MKR WIFI 1010 SHIELD" OF DEVICE SIDE   BY WIFI
108    
109        2.SENDS DATA THROUHG THE BLYNK SERVER. */   
110     
111      if (client.connect(server,23)) 
112     {
113      client.print("HMIDATA4:");
114       client.println(HMIDATA4);           
115     }                   
116     Blynk.virtualWrite(V12,HMIDATA4);
117      
118         
119 }
120 
121 
122 void Read_By_PLC()
123 {    
124      /*   SENDS DATA AT CLIENT'S (YOUR PLC) REQUEST */
125      ModbusRTUServer.poll();            
126       ModbusRTUClient.inputRegisterRead(Plc_TEMP4); 
127      HMIDATA4 = ModbusRTUServer.holdingRegisterRead(HmiData4);       
128      Serial.print("HMIDATA4:");
129      Serial.println(HMIDATA4);      
130     
131  }
132
133 
134 void printWifiStatus() 
135 {
136  // print the   SSID of the network you're attached to:
137  Serial.print("SSID: ");
138  Serial.println(WiFi.SSID());
139
140   // print your WiFi shield's IP address:
141  IPAddress ip = WiFi.localIP();
142   Serial.print("IP Address: ");
143  Serial.println(ip);
144
145  // print the   received signal strength:
146  long rssi = WiFi.RSSI();
147  Serial.print("signal   strength (RSSI):");
148  Serial.print(rssi);
149  Serial.println(" dBm");
150}
151

// THIS IS THE "B" SIDE

#include <ArduinoModbus.h>
#include   <ArduinoRS485.h>
#include <SPI.h>
#include <WiFiNINA.h>
#define BLYNK_PRINT   SerialUSB
#include <BlynkSimpleWifi.h>

BlynkTimer timer;

// YOUR   WIFI
char ssid[] = "traumwelt";      
char pass[] = "traumwelt!!"; 
char   auth[] = "P7GH59GKqz90pdKrrEc4F5ki3BJLupe9";
          
int status = WL_IDLE_STATUS;
char   server[] = "192.168.0.57";
WiFiClient client;

// VARIABLB IN THH B SIDE
int16_t   Aside_TEMP4;
int16_t Bside_TEMP4;
int8_t HMIDATA4;

/* 1. HoldingRegister   ADDRESS FROM THE PLC TO THE ARDUINO
   2. PLEASE MAKE IT SAME WRITING ADDRESS   IN THE YOUR PLC */
    
const int HmiData4 = 0x0004;


/* 1. InputRegister   ADDRESS FROM THE ARDUINO TO THE PLC
   2. PLEASE MAKE IT SAME READING ADDRESS   IN THE YOUR PLC */
   
const int Plc_TEMP4 = 0x0003;

// RECIEVED THE   DATA OF TEMPERATURE AT "A" SIDE FROM THE BLYNK SERVER.
 
BLYNK_WRITE(V8)
   {
     Aside_TEMP4 = param.asInt();         
  } 

void setup() 
{   
  Serial.begin(9600);                             
  WiFi.begin(ssid, pass);                           
  Blynk.begin(auth, ssid, pass);
  
  printWifiStatus();   
  
  timer.setInterval(1000L,Read_Write_Data );

  while(Blynk.connect()==false){     
  }
 
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println("Communication   with WiFi module failed!");
   
    while (true);
  }   
 
  while   (WiFi.status() != WL_CONNECTED) 
  {
    Serial.print(".");
    delay(500);
   }      
     if(!ModbusRTUServer.begin(10,2400,SERIAL_8N2))
     {
    Serial.println("Failed   to start Modbus RTU Server!");
    while (1);
     }
       
   /*   1. I SET IT AT THE INPUT REGISTER ADDRESS IN ARDUINO 
      2. I SET IT AT THE   HOLDING REGISTER ADDRESS IN ARDUINO */
      
     ModbusRTUServer.configureInputRegisters(0x0003,1);
      ModbusRTUServer.configureHoldingRegisters(0x0004,1);        
  }
  
void   loop () 
{    
   Blynk.run();
   timer.run();
} 
    
 void Read_Write_Data()   
 {
     Read_By_PLC();
     Read_From_Plc();

     /* 1. PUT THE   VARIABLE VALUE RECEIVED FROM BLYNK'S SERVER AT THE inputRegister ADDRESS
        2.   THE ENTERED VALUE IS SENDED TO PLC */     
        
     ModbusRTUServer.inputRegisterWrite(Plc_TEMP4,   Aside_TEMP4);  
     Bside_TEMP4 = ModbusRTUServer.inputRegisterRead(Plc_TEMP4);
      Serial.println("Aside_TEMP4");
     Serial.println(Aside_TEMP4);
     Serial.println("Bside_TEMP4");
      Serial.println(Bside_TEMP4); 
     
 }
     
void Read_From_Plc()
     {
      /* 1.SENDS THE VARIABLE TO "MKR WIFI 1010 SHIELD" OF DEVICE SIDE   BY WIFI
    
        2.SENDS DATA THROUHG THE BLYNK SERVER. */   
     
      if (client.connect(server,23)) 
     {
      client.print("HMIDATA4:");
       client.println(HMIDATA4);           
     }                   
     Blynk.virtualWrite(V12,HMIDATA4);
      
         
 }
 
 
 void Read_By_PLC()
 {    
      /*   SENDS DATA AT CLIENT'S (YOUR PLC) REQUEST */
      ModbusRTUServer.poll();            
       ModbusRTUClient.inputRegisterRead(Plc_TEMP4); 
      HMIDATA4 = ModbusRTUServer.holdingRegisterRead(HmiData4);       
      Serial.print("HMIDATA4:");
      Serial.println(HMIDATA4);      
     
  }

 
 void printWifiStatus() 
 {
  // print the   SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

   // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
   Serial.print("IP Address: ");
  Serial.println(ip);

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

Aside_tr

arduino

1// THIS IS THE "A" SIDE
2
3#include <ArduinoModbus.h>
4#include   <ArduinoRS485.h>
5#include <SPI.h>
6#include <WiFiNINA.h>
7#define BLYNK_PRINT   SerialUSB
8#include <BlynkSimpleWifi.h>
9
10// YOUR WIFI
11char ssid[] = "traumwelt";         
12char pass[] = "traumwelt!!"; 
13
14// BLYNK'S TOKEN
15char auth[]   = "HQhd9md5NDpnZ9VOlBf7wIy1z7D6C9L7";
16WiFiServer server(23);
17
18float temp4;   
19int16_t TEMP4;
20uint8_t Device4;
21int16_t Dev_Valu4;
22
23WidgetBridge   bridge1(V0);
24BlynkTimer timer;
25
26BLYNK_CONNECTED() 
27    {
28       bridge1.setAuthToken("P7Gh59GKqz90pdKrrEc4F5ki3BJLupe9");        
29    }  
30       
31void setup() 
32{  
33  Serial.begin(9600);                             
34   WiFi.begin(ssid, pass);                          
35  Blynk.begin(auth, ssid,   pass);
36
37  
38  timer.setInterval(1000L,TempRead);
39   
40 while(Blynk.connect()==false){     
41  }
42  
43  if (WiFi.status() == WL_NO_MODULE) 
44  {
45    Serial.println("Communication   with WiFi module failed!");
46   
47    while (true);
48  }  
49 
50  while   (WiFi.status() != WL_CONNECTED) 
51  {
52    Serial.print("Attempting to start   AP ");
53    Serial.println(ssid);
54
55    delay(10);
56  }
57  
58   IPAddress   localIp(192, 168, 0, 57);
59   WiFi.config(localIp);  
60   
61   server.begin();   
62   
63   while (!Serial);
64    Serial.println("Modbus Temperature Read   By Wifi");    // start the Modbus RTU client
65    if (!ModbusRTUClient.begin(2400,SERIAL_8N2))   
66    {      
67        Serial.println("Failed to start Modbus RTU Client!");
68         while (1);
69    } 
70    printWifiStatus();    
71  }
72       
73void   loop () 
74{  
75   
76   Blynk.run();
77    timer.run(); 
78}
79
80void   wifiReadfromhmi()
81{
82    // RECEIVE DATA BY WIFI
83    WiFiClient client =   server.available(); 
84    while (client.available())
85       {            
86             char ch = client.read();                       
87            if(client.find("A4:")==true)              
88              {
89              Device4=client.parseInt();             
90               Serial.print("Device4:");
91              Serial.println(Device4);               
92              }               
93       }
94       comm();
95}
96void   Comm_Dev()
97{
98  // RECEIVED THE DATA OF TEMPERATURE DEVICE 
99  
100 if (!ModbusRTUClient.requestFrom(0x04,   COILS, 0x0000,1)) 
101           {
102             Serial.print("failed to read   registers! ");
103             
104             Serial.println(ModbusRTUClient.lastError());
105            } 
106             else 
107                {
108                 Dev_Valu4   = ModbusRTUClient.read();                                 
109                 Serial.print("Dev_Valu4   :  ");                 
110                 Serial.println(Dev_Valu4);                                                                       
111                 }
112 }
113 void comm()
114 {
115  if ( !Dev_Valu4==Device4)
116       {
117        ModbusRTUClient.coilWrite(0x04,0x0000,Device4);
118      }
119   }
120void TempRead()
121   {         
122     wifiReadfromhmi();                                
123     if (!ModbusRTUClient.requestFrom(0x04, INPUT_REGISTERS, 0x03E8, 1)) 
124           {
125              Serial.print("failed to read registers! ");
126             Blynk.virtualWrite(V4,"failed   to read registers!");
127             Serial.println(ModbusRTUClient.lastError());
128            } 
129             else 
130                {
131                 TEMP4   = ModbusRTUClient.read();
132                 temp4 = (TEMP4/10+TEMP4%10*0.1);                
133                  Serial.print("TEMP4 :  ");                 
134                 Serial.println(temp4);                                  
135                 bridge1.virtualWrite(V8, TEMP4);                       
136                 Blynk.virtualWrite(V4,TEMP4);                                                        
137                 } 
138                             
139        Comm_Dev();
140              
141          
142     }
143 
144 void printWifiStatus() 
145 {
146  // print the SSID   of the network you're attached to:
147  Serial.print("SSID: ");
148  Serial.println(WiFi.SSID());
149
150   // print your WiFi shield's IP address:
151  IPAddress ip = WiFi.localIP();
152   Serial.print("IP Address: ");
153  Serial.println(ip);
154
155  // print the   received signal strength:
156  long rssi = WiFi.RSSI();
157  Serial.print("signal   strength (RSSI):");
158  Serial.print(rssi);
159  Serial.println(" dBm");
160}
161

// THIS IS THE "A" SIDE

#include <ArduinoModbus.h>
#include   <ArduinoRS485.h>
#include <SPI.h>
#include <WiFiNINA.h>
#define BLYNK_PRINT   SerialUSB
#include <BlynkSimpleWifi.h>

// YOUR WIFI
char ssid[] = "traumwelt";         
char pass[] = "traumwelt!!"; 

// BLYNK'S TOKEN
char auth[]   = "HQhd9md5NDpnZ9VOlBf7wIy1z7D6C9L7";
WiFiServer server(23);

float temp4;   
int16_t TEMP4;
uint8_t Device4;
int16_t Dev_Valu4;

WidgetBridge   bridge1(V0);
BlynkTimer timer;

BLYNK_CONNECTED() 
    {
       bridge1.setAuthToken("P7Gh59GKqz90pdKrrEc4F5ki3BJLupe9");        
    }  
       
void setup() 
{  
  Serial.begin(9600);                             
   WiFi.begin(ssid, pass);                          
  Blynk.begin(auth, ssid,   pass);

  
  timer.setInterval(1000L,TempRead);
   
 while(Blynk.connect()==false){     
  }
  
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println("Communication   with WiFi module failed!");
   
    while (true);
  }  
 
  while   (WiFi.status() != WL_CONNECTED) 
  {
    Serial.print("Attempting to start   AP ");
    Serial.println(ssid);

    delay(10);
  }
  
   IPAddress   localIp(192, 168, 0, 57);
   WiFi.config(localIp);  
   
   server.begin();   
   
   while (!Serial);
    Serial.println("Modbus Temperature Read   By Wifi");    // start the Modbus RTU client
    if (!ModbusRTUClient.begin(2400,SERIAL_8N2))   
    {      
        Serial.println("Failed to start Modbus RTU Client!");
         while (1);
    } 
    printWifiStatus();    
  }
       
void   loop () 
{  
   
   Blynk.run();
    timer.run(); 
}

void   wifiReadfromhmi()
{
    // RECEIVE DATA BY WIFI
    WiFiClient client =   server.available(); 
    while (client.available())
       {            
             char ch = client.read();                       
            if(client.find("A4:")==true)              
              {
              Device4=client.parseInt();             
               Serial.print("Device4:");
              Serial.println(Device4);               
              }               
       }
       comm();
}
void   Comm_Dev()
{
  // RECEIVED THE DATA OF TEMPERATURE DEVICE 
  
 if (!ModbusRTUClient.requestFrom(0x04,   COILS, 0x0000,1)) 
           {
             Serial.print("failed to read   registers! ");
             
             Serial.println(ModbusRTUClient.lastError());
            } 
             else 
                {
                 Dev_Valu4   = ModbusRTUClient.read();                                 
                 Serial.print("Dev_Valu4   :  ");                 
                 Serial.println(Dev_Valu4);                                                                       
                 }
 }
 void comm()
 {
  if ( !Dev_Valu4==Device4)
       {
        ModbusRTUClient.coilWrite(0x04,0x0000,Device4);
      }
   }
void TempRead()
   {         
     wifiReadfromhmi();                                
     if (!ModbusRTUClient.requestFrom(0x04, INPUT_REGISTERS, 0x03E8, 1)) 
           {
              Serial.print("failed to read registers! ");
             Blynk.virtualWrite(V4,"failed   to read registers!");
             Serial.println(ModbusRTUClient.lastError());
            } 
             else 
                {
                 TEMP4   = ModbusRTUClient.read();
                 temp4 = (TEMP4/10+TEMP4%10*0.1);                
                  Serial.print("TEMP4 :  ");                 
                 Serial.println(temp4);                                  
                 bridge1.virtualWrite(V8, TEMP4);                       
                 Blynk.virtualWrite(V4,TEMP4);                                                        
                 } 
                             
        Comm_Dev();
              
          
     }
 
 void printWifiStatus() 
 {
  // print the SSID   of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

   // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
   Serial.print("IP Address: ");
  Serial.println(ip);

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

Aside_tr

arduino

1// THIS IS THE "A" SIDE
2
3#include <ArduinoModbus.h>
4#include
5  <ArduinoRS485.h>
6#include <SPI.h>
7#include <WiFiNINA.h>
8#define BLYNK_PRINT
9  SerialUSB
10#include <BlynkSimpleWifi.h>
11
12// YOUR WIFI
13char ssid[] = "traumwelt";
14        
15char pass[] = "traumwelt!!"; 
16
17// BLYNK'S TOKEN
18char auth[]
19  = "HQhd9md5NDpnZ9VOlBf7wIy1z7D6C9L7";
20WiFiServer server(23);
21
22float temp4;
23  
24int16_t TEMP4;
25uint8_t Device4;
26int16_t Dev_Valu4;
27
28WidgetBridge
29  bridge1(V0);
30BlynkTimer timer;
31
32BLYNK_CONNECTED() 
33    {
34       bridge1.setAuthToken("P7Gh59GKqz90pdKrrEc4F5ki3BJLupe9");
35       
36    }  
37       
38void setup() 
39{  
40  Serial.begin(9600);                             
41
42  WiFi.begin(ssid, pass);                          
43  Blynk.begin(auth, ssid,
44  pass);
45
46  
47  timer.setInterval(1000L,TempRead);
48   
49 while(Blynk.connect()==false){
50    
51  }
52  
53  if (WiFi.status() == WL_NO_MODULE) 
54  {
55    Serial.println("Communication
56  with WiFi module failed!");
57   
58    while (true);
59  }  
60 
61  while
62  (WiFi.status() != WL_CONNECTED) 
63  {
64    Serial.print("Attempting to start
65  AP ");
66    Serial.println(ssid);
67
68    delay(10);
69  }
70  
71   IPAddress
72  localIp(192, 168, 0, 57);
73   WiFi.config(localIp);  
74   
75   server.begin();
76  
77   
78   while (!Serial);
79    Serial.println("Modbus Temperature Read
80  By Wifi");    // start the Modbus RTU client
81    if (!ModbusRTUClient.begin(2400,SERIAL_8N2))
82  
83    {      
84        Serial.println("Failed to start Modbus RTU Client!");
85
86        while (1);
87    } 
88    printWifiStatus();    
89  }
90       
91void
92  loop () 
93{  
94   
95   Blynk.run();
96    timer.run(); 
97}
98
99void
100  wifiReadfromhmi()
101{
102    // RECEIVE DATA BY WIFI
103    WiFiClient client =
104  server.available(); 
105    while (client.available())
106       {            
107
108            char ch = client.read();                       
109            if(client.find("A4:")==true)
110             
111              {
112              Device4=client.parseInt();             
113
114              Serial.print("Device4:");
115              Serial.println(Device4);
116              
117              }               
118       }
119       comm();
120}
121void
122  Comm_Dev()
123{
124  // RECEIVED THE DATA OF TEMPERATURE DEVICE 
125  
126 if (!ModbusRTUClient.requestFrom(0x04,
127  COILS, 0x0000,1)) 
128           {
129             Serial.print("failed to read
130  registers! ");
131             
132             Serial.println(ModbusRTUClient.lastError());
133
134           } 
135             else 
136                {
137                 Dev_Valu4
138  = ModbusRTUClient.read();                                 
139                 Serial.print("Dev_Valu4
140  :  ");                 
141                 Serial.println(Dev_Valu4);                                                                       
142
143                }
144 }
145 void comm()
146 {
147  if ( !Dev_Valu4==Device4)
148
149      {
150        ModbusRTUClient.coilWrite(0x04,0x0000,Device4);
151      }
152
153  }
154void TempRead()
155   {         
156     wifiReadfromhmi();                                
157
158    if (!ModbusRTUClient.requestFrom(0x04, INPUT_REGISTERS, 0x03E8, 1)) 
159           {
160
161             Serial.print("failed to read registers! ");
162             Blynk.virtualWrite(V4,"failed
163  to read registers!");
164             Serial.println(ModbusRTUClient.lastError());
165
166           } 
167             else 
168                {
169                 TEMP4
170  = ModbusRTUClient.read();
171                 temp4 = (TEMP4/10+TEMP4%10*0.1);                
172
173                 Serial.print("TEMP4 :  ");                 
174                 Serial.println(temp4);
175                                 
176                 bridge1.virtualWrite(V8, TEMP4);
177                      
178                 Blynk.virtualWrite(V4,TEMP4);                                                        
179
180                } 
181                             
182        Comm_Dev();
183              
184
185         
186     }
187 
188 void printWifiStatus() 
189 {
190  // print the SSID
191  of the network you're attached to:
192  Serial.print("SSID: ");
193  Serial.println(WiFi.SSID());
194
195
196  // print your WiFi shield's IP address:
197  IPAddress ip = WiFi.localIP();
198
199  Serial.print("IP Address: ");
200  Serial.println(ip);
201
202  // print the
203  received signal strength:
204  long rssi = WiFi.RSSI();
205  Serial.print("signal
206  strength (RSSI):");
207  Serial.print(rssi);
208  Serial.println(" dBm");
209}
210

// THIS IS THE "A" SIDE

#include <ArduinoModbus.h>
#include
  <ArduinoRS485.h>
#include <SPI.h>
#include <WiFiNINA.h>
#define BLYNK_PRINT
  SerialUSB
#include <BlynkSimpleWifi.h>

// YOUR WIFI
char ssid[] = "traumwelt";
        
char pass[] = "traumwelt!!"; 

// BLYNK'S TOKEN
char auth[]
  = "HQhd9md5NDpnZ9VOlBf7wIy1z7D6C9L7";
WiFiServer server(23);

float temp4;
  
int16_t TEMP4;
uint8_t Device4;
int16_t Dev_Valu4;

WidgetBridge
  bridge1(V0);
BlynkTimer timer;

BLYNK_CONNECTED() 
    {
       bridge1.setAuthToken("P7Gh59GKqz90pdKrrEc4F5ki3BJLupe9");
       
    }  
       
void setup() 
{  
  Serial.begin(9600);                             

  WiFi.begin(ssid, pass);                          
  Blynk.begin(auth, ssid,
  pass);

  
  timer.setInterval(1000L,TempRead);
   
 while(Blynk.connect()==false){
    
  }
  
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println("Communication
  with WiFi module failed!");
   
    while (true);
  }  
 
  while
  (WiFi.status() != WL_CONNECTED) 
  {
    Serial.print("Attempting to start
  AP ");
    Serial.println(ssid);

    delay(10);
  }
  
   IPAddress
  localIp(192, 168, 0, 57);
   WiFi.config(localIp);  
   
   server.begin();
  
   
   while (!Serial);
    Serial.println("Modbus Temperature Read
  By Wifi");    // start the Modbus RTU client
    if (!ModbusRTUClient.begin(2400,SERIAL_8N2))
  
    {      
        Serial.println("Failed to start Modbus RTU Client!");

        while (1);
    } 
    printWifiStatus();    
  }
       
void
  loop () 
{  
   
   Blynk.run();
    timer.run(); 
}

void
  wifiReadfromhmi()
{
    // RECEIVE DATA BY WIFI
    WiFiClient client =
  server.available(); 
    while (client.available())
       {            

            char ch = client.read();                       
            if(client.find("A4:")==true)
             
              {
              Device4=client.parseInt();             

              Serial.print("Device4:");
              Serial.println(Device4);
              
              }               
       }
       comm();
}
void
  Comm_Dev()
{
  // RECEIVED THE DATA OF TEMPERATURE DEVICE 
  
 if (!ModbusRTUClient.requestFrom(0x04,
  COILS, 0x0000,1)) 
           {
             Serial.print("failed to read
  registers! ");
             
             Serial.println(ModbusRTUClient.lastError());

           } 
             else 
                {
                 Dev_Valu4
  = ModbusRTUClient.read();                                 
                 Serial.print("Dev_Valu4
  :  ");                 
                 Serial.println(Dev_Valu4);                                                                       

                }
 }
 void comm()
 {
  if ( !Dev_Valu4==Device4)

      {
        ModbusRTUClient.coilWrite(0x04,0x0000,Device4);
      }

  }
void TempRead()
   {         
     wifiReadfromhmi();                                

    if (!ModbusRTUClient.requestFrom(0x04, INPUT_REGISTERS, 0x03E8, 1)) 
           {

             Serial.print("failed to read registers! ");
             Blynk.virtualWrite(V4,"failed
  to read registers!");
             Serial.println(ModbusRTUClient.lastError());

           } 
             else 
                {
                 TEMP4
  = ModbusRTUClient.read();
                 temp4 = (TEMP4/10+TEMP4%10*0.1);                

                 Serial.print("TEMP4 :  ");                 
                 Serial.println(temp4);
                                 
                 bridge1.virtualWrite(V8, TEMP4);
                      
                 Blynk.virtualWrite(V4,TEMP4);                                                        

                } 
                             
        Comm_Dev();
              

         
     }
 
 void printWifiStatus() 
 {
  // print the SSID
  of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());


  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();

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

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

Bside_TR

arduino

1// THIS IS THE "B" SIDE
2
3#include <ArduinoModbus.h>
4#include
5  <ArduinoRS485.h>
6#include <SPI.h>
7#include <WiFiNINA.h>
8#define BLYNK_PRINT
9  SerialUSB
10#include <BlynkSimpleWifi.h>
11
12BlynkTimer timer;
13
14// YOUR
15  WIFI
16char ssid[] = "traumwelt";      
17char pass[] = "traumwelt!!"; 
18char
19  auth[] = "P7GH59GKqz90pdKrrEc4F5ki3BJLupe9";
20          
21int status = WL_IDLE_STATUS;
22char
23  server[] = "192.168.0.57";
24WiFiClient client;
25
26// VARIABLB IN THH B SIDE
27int16_t
28  Aside_TEMP4;
29int16_t Bside_TEMP4;
30int8_t HMIDATA4;
31
32/* 1. HoldingRegister
33  ADDRESS FROM THE PLC TO THE ARDUINO
34   2. PLEASE MAKE IT SAME WRITING ADDRESS
35  IN THE YOUR PLC */
36    
37const int HmiData4 = 0x0004;
38
39
40/* 1. InputRegister
41  ADDRESS FROM THE ARDUINO TO THE PLC
42   2. PLEASE MAKE IT SAME READING ADDRESS
43  IN THE YOUR PLC */
44   
45const int Plc_TEMP4 = 0x0003;
46
47// RECIEVED THE
48  DATA OF TEMPERATURE AT "A" SIDE FROM THE BLYNK SERVER.
49 
50BLYNK_WRITE(V8)
51
52  {
53     Aside_TEMP4 = param.asInt();         
54  } 
55
56void setup() 
57{
58  
59  Serial.begin(9600);                             
60  WiFi.begin(ssid, pass);
61                          
62  Blynk.begin(auth, ssid, pass);
63  
64  printWifiStatus();
65  
66  
67  timer.setInterval(1000L,Read_Write_Data );
68
69  while(Blynk.connect()==false){
70    
71  }
72 
73  if (WiFi.status() == WL_NO_MODULE) 
74  {
75    Serial.println("Communication
76  with WiFi module failed!");
77   
78    while (true);
79  }   
80 
81  while
82  (WiFi.status() != WL_CONNECTED) 
83  {
84    Serial.print(".");
85    delay(500);
86
87  }      
88     if(!ModbusRTUServer.begin(10,2400,SERIAL_8N2))
89     {
90    Serial.println("Failed
91  to start Modbus RTU Server!");
92    while (1);
93     }
94       
95   /*
96  1. I SET IT AT THE INPUT REGISTER ADDRESS IN ARDUINO 
97      2. I SET IT AT THE
98  HOLDING REGISTER ADDRESS IN ARDUINO */
99      
100     ModbusRTUServer.configureInputRegisters(0x0003,1);
101
102     ModbusRTUServer.configureHoldingRegisters(0x0004,1);        
103  }
104  
105void
106  loop () 
107{    
108   Blynk.run();
109   timer.run();
110} 
111    
112 void Read_Write_Data()
113  
114 {
115     Read_By_PLC();
116     Read_From_Plc();
117
118     /* 1. PUT THE
119  VARIABLE VALUE RECEIVED FROM BLYNK'S SERVER AT THE inputRegister ADDRESS
120        2.
121  THE ENTERED VALUE IS SENDED TO PLC */     
122        
123     ModbusRTUServer.inputRegisterWrite(Plc_TEMP4,
124  Aside_TEMP4);  
125     Bside_TEMP4 = ModbusRTUServer.inputRegisterRead(Plc_TEMP4);
126
127     Serial.println("Aside_TEMP4");
128     Serial.println(Aside_TEMP4);
129     Serial.println("Bside_TEMP4");
130
131     Serial.println(Bside_TEMP4); 
132     
133 }
134     
135void Read_From_Plc()
136
137    {
138      /* 1.SENDS THE VARIABLE TO "MKR WIFI 1010 SHIELD" OF DEVICE SIDE
139  BY WIFI
140    
141        2.SENDS DATA THROUHG THE BLYNK SERVER. */   
142     
143
144     if (client.connect(server,23)) 
145     {
146      client.print("HMIDATA4:");
147
148      client.println(HMIDATA4);           
149     }                   
150     Blynk.virtualWrite(V12,HMIDATA4);
151
152     
153         
154 }
155 
156 
157 void Read_By_PLC()
158 {    
159      /*
160  SENDS DATA AT CLIENT'S (YOUR PLC) REQUEST */
161      ModbusRTUServer.poll();            
162
163      ModbusRTUClient.inputRegisterRead(Plc_TEMP4); 
164      HMIDATA4 = ModbusRTUServer.holdingRegisterRead(HmiData4);
165      
166      Serial.print("HMIDATA4:");
167      Serial.println(HMIDATA4);
168     
169     
170  }
171
172 
173 void printWifiStatus() 
174 {
175  // print the
176  SSID of the network you're attached to:
177  Serial.print("SSID: ");
178  Serial.println(WiFi.SSID());
179
180
181  // print your WiFi shield's IP address:
182  IPAddress ip = WiFi.localIP();
183
184  Serial.print("IP Address: ");
185  Serial.println(ip);
186
187  // print the
188  received signal strength:
189  long rssi = WiFi.RSSI();
190  Serial.print("signal
191  strength (RSSI):");
192  Serial.print(rssi);
193  Serial.println(" dBm");
194}
195

// THIS IS THE "B" SIDE

#include <ArduinoModbus.h>
#include
  <ArduinoRS485.h>
#include <SPI.h>
#include <WiFiNINA.h>
#define BLYNK_PRINT
  SerialUSB
#include <BlynkSimpleWifi.h>

BlynkTimer timer;

// YOUR
  WIFI
char ssid[] = "traumwelt";      
char pass[] = "traumwelt!!"; 
char
  auth[] = "P7GH59GKqz90pdKrrEc4F5ki3BJLupe9";
          
int status = WL_IDLE_STATUS;
char
  server[] = "192.168.0.57";
WiFiClient client;

// VARIABLB IN THH B SIDE
int16_t
  Aside_TEMP4;
int16_t Bside_TEMP4;
int8_t HMIDATA4;

/* 1. HoldingRegister
  ADDRESS FROM THE PLC TO THE ARDUINO
   2. PLEASE MAKE IT SAME WRITING ADDRESS
  IN THE YOUR PLC */
    
const int HmiData4 = 0x0004;


/* 1. InputRegister
  ADDRESS FROM THE ARDUINO TO THE PLC
   2. PLEASE MAKE IT SAME READING ADDRESS
  IN THE YOUR PLC */
   
const int Plc_TEMP4 = 0x0003;

// RECIEVED THE
  DATA OF TEMPERATURE AT "A" SIDE FROM THE BLYNK SERVER.
 
BLYNK_WRITE(V8)

  {
     Aside_TEMP4 = param.asInt();         
  } 

void setup() 
{
  
  Serial.begin(9600);                             
  WiFi.begin(ssid, pass);
                          
  Blynk.begin(auth, ssid, pass);
  
  printWifiStatus();
  
  
  timer.setInterval(1000L,Read_Write_Data );

  while(Blynk.connect()==false){
    
  }
 
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println("Communication
  with WiFi module failed!");
   
    while (true);
  }   
 
  while
  (WiFi.status() != WL_CONNECTED) 
  {
    Serial.print(".");
    delay(500);

  }      
     if(!ModbusRTUServer.begin(10,2400,SERIAL_8N2))
     {
    Serial.println("Failed
  to start Modbus RTU Server!");
    while (1);
     }
       
   /*
  1. I SET IT AT THE INPUT REGISTER ADDRESS IN ARDUINO 
      2. I SET IT AT THE
  HOLDING REGISTER ADDRESS IN ARDUINO */
      
     ModbusRTUServer.configureInputRegisters(0x0003,1);

     ModbusRTUServer.configureHoldingRegisters(0x0004,1);        
  }
  
void
  loop () 
{    
   Blynk.run();
   timer.run();
} 
    
 void Read_Write_Data()
  
 {
     Read_By_PLC();
     Read_From_Plc();

     /* 1. PUT THE
  VARIABLE VALUE RECEIVED FROM BLYNK'S SERVER AT THE inputRegister ADDRESS
        2.
  THE ENTERED VALUE IS SENDED TO PLC */     
        
     ModbusRTUServer.inputRegisterWrite(Plc_TEMP4,
  Aside_TEMP4);  
     Bside_TEMP4 = ModbusRTUServer.inputRegisterRead(Plc_TEMP4);

     Serial.println("Aside_TEMP4");
     Serial.println(Aside_TEMP4);
     Serial.println("Bside_TEMP4");

     Serial.println(Bside_TEMP4); 
     
 }
     
void Read_From_Plc()

    {
      /* 1.SENDS THE VARIABLE TO "MKR WIFI 1010 SHIELD" OF DEVICE SIDE
  BY WIFI
    
        2.SENDS DATA THROUHG THE BLYNK SERVER. */   
     

     if (client.connect(server,23)) 
     {
      client.print("HMIDATA4:");

      client.println(HMIDATA4);           
     }                   
     Blynk.virtualWrite(V12,HMIDATA4);

     
         
 }
 
 
 void Read_By_PLC()
 {    
      /*
  SENDS DATA AT CLIENT'S (YOUR PLC) REQUEST */
      ModbusRTUServer.poll();            

      ModbusRTUClient.inputRegisterRead(Plc_TEMP4); 
      HMIDATA4 = ModbusRTUServer.holdingRegisterRead(HmiData4);
      
      Serial.print("HMIDATA4:");
      Serial.println(HMIDATA4);
     
     
  }

 
 void printWifiStatus() 
 {
  // print the
  SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());


  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();

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

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

Downloadable files

Temperature Controller Manual

PLC MANUAL

Temperature Controller Manual

PLC MANUAL

Comments

yoonidle

0 Followers

•

0 Projects

Intro