{"id":6390,"date":"2021-04-14T11:27:35","date_gmt":"2021-04-14T10:27:35","guid":{"rendered":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/2021\/04\/14\/data-node-with-arduino\/"},"modified":"2021-04-14T11:27:35","modified_gmt":"2021-04-14T10:27:35","slug":"data-node-with-arduino","status":"publish","type":"post","link":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/2021\/04\/14\/data-node-with-arduino\/?lang=en","title":{"rendered":"Data Node with Arduino"},"content":{"rendered":"
<\/div>\n

<\/path><\/svg><\/i> \"Loading\"<\/p>\n

<\/div>\n

Unfortunately, the intervals in which I find some time to write a new post for the blog have not gotten shorter. But post a post per month, I think … \ud83d\ude42<\/p>\n

\"\"<\/a>This time it’s not a retro craft project from the local Gefielden or a restoration of an old device, but again something about Arduino. The idea – to build a sensor that, as always, transforms a physical quantity into an electrical signal. This is nothing special and what kind of sensor it will be, I will not describe for the time being. But there should not be a sensor board, but many. And these sensor boards short „sensors“ are to be networked together in a two-dimensional matrix. You can imagine it as a chessboard, with each of the chessboard panels representing a sensor. This network of sensors – ie sensor nodes – should then be connected via a transfer point to a computer and output the sensor data of the respective field. It should then also be possible to remove individual fields from the network without the remaining network losing its function.<\/p>\n

The whole system should be as simple and cheap as possible. And so a system concept was quickly developed in which the nodes communicate via the I\u00b2C bus and send their data to a master. The following diagram is intended to illustrate this.<\/p>\n

\"\"<\/a><\/p>\n

This concept, I thought, is easiest to implement with an ATmega microcontroller. The has enough IO’s, an I\u00b2C bus and UART onboard, as well as analog inputs and requires little component peripherals to bring it to life in its own layout. And there is nothing faster to do such a test setup of such a node network than to use the well-known Arduino development boards. I have chosen the cheapest version for a test setup -> the Chinanachbau of the ArduinoUno (Joy-IT UNO) with the Atmga328 in the capped DIL housing.<\/p>\n

\"\"<\/a>

Joy-It Uno Boards<\/p><\/div>\n

The picture shows ten of these microcontroller boards. Of these, one should be used as a bus master and nine as slaves. Of course, each of these slaves has a unique bus address, which only occurs once in the system. In the test setup, this bus address is permanently assigned via the program code, since anyway each Arduino must be connected to the computer in order to carry out the program upload. Of course, that should look different later. Because the Arduino is on the Atmega328 chip, its quartz and the few resistors reduced on the sensor board with gelayoutet. The chip should then be programmed via the ISP pins. Of course, as many boards do not always customize the program code and they all have the same Flash file, I want to set the sensor address with a 7-bit DIP switch. A 4021 Cmos Static Shift Register is supposed to read the bits after the controller is powered on and push them serially into the controller. The resulting value is then available as a bus address in a variable.<\/p>\n

Each of these slaves with their individual bus address is now queried in sequence by the master node, which state it has and whether it should switch an output or not. That is, the node has only one DO (digital output) with which it can, for example, turn an LED off and on and interrogate one or more DIs (digital input) which polls a state, for example a simple switch. These functions are stored in 2 bits of a byte. Another byte is used to transfer the bus address. So two bytes are sent over the bus. The picture below shows the test setup with the „UNO boards“<\/p>\n

\"\"<\/a>

All Arduinos are connected to I\u00b2C data bus and power supply<\/p><\/div>\n

The process is as follows:<\/p>\n

MASTER:
\n<\/strong>The master node sends a request after the series to all slave addresses and a switch command (which comes from all nodes of a TEST push button input on the master) for the LED output of the node and sees if a response comes back or not. If no answer comes, the node is not in the network or is defective. If there is an answer, this consists of the address of the node and its status byte. This information is transmitted via an RS232 terminal to the computer connected to the master. Thus, for example, the switching status of each individual node can be displayed on the screen via a visualization using (NI LabView, or Matlab or similar). By adapting the master program, it is also possible to switch the LED outputs of the slaves via the computer.<\/p>\n

SLAVE:<\/strong>
\nWhen the master node requests data from the slave, the slave sends back two bytes. Where byte0 again is the slave ID (ie bus address) and byte1 is the data. Byte1 actually consists of only two bits encoded as follows (in decimal representation):
\n 0 = LED off| Sensor not triggered
\n 1 = LED on | Sensor not triggered
\n 2 = LED off | Sensor triggered
\n 3 = LED on | Sensor triggered<\/p>\n

The program code as an example:<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62\r\n63\r\n64\r\n65\r\n66\r\n67\r\n68\r\n69\r\n70\r\n71\r\n72\r\n73\r\n74\r\n75\r\n76\r\n77\r\n78<\/pre>\n<\/td>\n
\n
\/\/ I2C Slave Code<\/span>\r\n\/\/ 16.05.2018 <\/span>\r\n\/\/ ver 1.3<\/span>\r\n#include <Wire.h><\/span>\r\n#define ADDRESS 2     <\/span>\/\/ adresse des slave knotens<\/span>\r\n#define PAYLOAD_SIZE 2 <\/span>\/\/ anzahl der bytes  die vom masterknoten zu erwarten sind<\/span>\r\nint<\/span> LED=12<\/span>;            \/\/ indicator led an pin D12<\/span>\r\nint<\/span> SENSOR =<\/span> 8<\/span>;        \/\/ sensor input an pin D8<\/span>\r\nbool<\/span> actionState=0<\/span>;      \/\/ sensor zustand<\/span>\r\nint<\/span> busstatus;  \/\/ statusvariable <\/span>\r\n                       \/\/ 0 = LED aus | sensor nicht belegt<\/span>\r\n                       \/\/ 1 = LED ein | sensor nicht belegt<\/span>\r\n                       \/\/ 2 = LED aus | sensor belegt<\/span>\r\n                       \/\/ 3 = LED ein | sensor belegt<\/span>\r\n \r\nbool<\/span> sensled=0<\/span>;          \/\/ sensor LED<\/span>\r\nbyte nodePayload[PAYLOAD_SIZE];\r\n\r\nvoid<\/span> setup<\/span>()\r\n{\r\n  pinMode(LED, OUTPUT);         \/\/sensorLED<\/span>\r\n  pinMode(SENSOR, INPUT);       \/\/Sensor <\/span>\r\n  Wire.begin(ADDRESS);          \/\/ Activate I2C network<\/span>\r\n  Wire.onReceive(receiveEvent);\r\n  Wire.onRequest(requestEvent); \/\/ auf master anforderung warten<\/span>\r\n                      \/\/  \/\/ debug interface<\/span>\r\n                      \/\/  Serial.begin(9600); <\/span>\r\n}\r\n\r\n\/\/ *********************************mainloop****************************************************<\/span>\r\nvoid<\/span> loop<\/span>()\r\n{ \r\n  delay(5<\/span>);\r\n  \r\n   if<\/span>(sensled){digitalWrite(LED, HIGH);}\r\n         else<\/span>{digitalWrite(LED, LOW);}\r\n\r\n  actionState =<\/span> digitalRead(SENSOR);  \/\/Sensoreingang abfragen        <\/span>\r\n   if<\/span>((actionState==1<\/span>)&&<\/span>(sensled==1<\/span>)) {busstatus=3<\/span>;}\r\n   else<\/span> if<\/span> ((actionState==0<\/span>)&&<\/span>(sensled==1<\/span>)) {busstatus=1<\/span>;}\r\n   else<\/span> if<\/span> ((actionState==1<\/span>)&&<\/span>(sensled==0<\/span>)) {busstatus=2<\/span>;}\r\n   else<\/span> if<\/span> ((actionState==0<\/span>)&&<\/span>(sensled==0<\/span>)) {busstatus=0<\/span>;}\r\n\r\n                      \/\/  Serial.println(\"######################\");<\/span>\r\n                      \/\/  Serial.print(\"busstatus neu setzen \");<\/span>\r\n                      \/\/  Serial.println(busstatus);<\/span>\r\n                      \/\/  Serial.print(\"sensled LED            \");<\/span>\r\n                      \/\/  Serial.println(sensled);<\/span>\r\n                      \/\/  Serial.print(\"actionState           \");<\/span>\r\n                      \/\/  Serial.println(actionState);<\/span>\r\n                      \/\/  Serial.println(\"######################\");<\/span>\r\n  nodePayload[0<\/span>] =<\/span> ADDRESS;                  \/\/ Adresse in byte0 zur\u00fccksenden.  <\/span>\r\n  nodePayload[1<\/span>] =<\/span> busstatus;                \/\/byte 1 ist die statusinfo der LED<\/span>\r\n}\r\n\r\n\r\n\r\n\/\/ *********************************************************************************************<\/span>\r\nvoid<\/span> requestEvent<\/span>()\r\n{ Wire.write(nodePayload,PAYLOAD_SIZE);  \r\n  Serial.println(\"bytes status schreiben\"<\/span>);\r\n  Serial.println(nodePayload[0<\/span>]);\r\n  Serial.println(nodePayload[1<\/span>]);\r\n  delay(5<\/span>);\r\n}\r\n\r\n\/\/ *********************************************************************************************<\/span>\r\nvoid<\/span> receiveEvent<\/span>(int<\/span> bytes)  \/\/einen wert vom I2C lesen<\/span>\r\n      \r\n{\r\n  \r\n  busstatus =<\/span> Wire.read(); \/\/If the value received was true turn the led on, otherwise turn it off  <\/span>\r\n                              \/\/  Serial.println(\"status empfangen\");<\/span>\r\n                              \/\/  Serial.println(busstatus);<\/span>\r\n  if<\/span>((busstatus==1<\/span>)||<\/span>(busstatus==3<\/span>)){sensled =<\/span> 1<\/span>;}\r\n                                else<\/span>{sensled =<\/span> 0<\/span>;}\r\n                                              \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The bus address must still be entered individually in this slave code. In the next version, the previously described „serializer“ of the parallel dip-switch variant will be implemented. The following code example is from the master node, which reads out the slaves and sends a LED pattern to the sensor slaves using the test button:<\/p>\n
 
\n<\/p>\n
\n\n\n\n
\n
  1\r\n  2\r\n  3\r\n  4\r\n  5\r\n  6\r\n  7\r\n  8\r\n  9\r\n 10\r\n 11\r\n 12\r\n 13\r\n 14\r\n 15\r\n 16\r\n 17\r\n 18\r\n 19\r\n 20\r\n 21\r\n 22\r\n 23\r\n 24\r\n 25\r\n 26\r\n 27\r\n 28\r\n 29\r\n 30\r\n 31\r\n 32\r\n 33\r\n 34\r\n 35\r\n 36\r\n 37\r\n 38\r\n 39\r\n 40\r\n 41\r\n 42\r\n 43\r\n 44\r\n 45\r\n 46\r\n 47\r\n 48\r\n 49\r\n 50\r\n 51\r\n 52\r\n 53\r\n 54\r\n 55\r\n 56\r\n 57\r\n 58\r\n 59\r\n 60\r\n 61\r\n 62\r\n 63\r\n 64\r\n 65\r\n 66\r\n 67\r\n 68\r\n 69\r\n 70\r\n 71\r\n 72\r\n 73\r\n 74\r\n 75\r\n 76\r\n 77\r\n 78\r\n 79\r\n 80\r\n 81\r\n 82\r\n 83\r\n 84\r\n 85\r\n 86\r\n 87\r\n 88\r\n 89\r\n 90\r\n 91\r\n 92\r\n 93\r\n 94\r\n 95\r\n 96\r\n 97\r\n 98\r\n 99\r\n100\r\n101\r\n102\r\n103\r\n104\r\n105\r\n106\r\n107\r\n108\r\n109\r\n110\r\n111\r\n112\r\n113\r\n114\r\n115\r\n116\r\n117\r\n118\r\n119<\/pre>\n<\/td>\n
\n
\/\/ I2C masterknoten <\/span>\r\n\/\/ 16.05.2018 <\/span>\r\n\/\/ ver 1.2<\/span>\r\n\/\/ changes abfrage wenn kein knoten am bus dann 255 ausgeben<\/span>\r\n#include <Wire.h><\/span>\r\n\r\n#define busbytes 2          <\/span>\/\/ wievele byte vom I2C knoten zu erwarten sind<\/span>\r\n#define maxKNOTEN  10       <\/span>\/\/ anzahl der zu scannenden slaves<\/span>\r\n#define startKNOTEN 2       <\/span>\/\/ startadresse der slaves<\/span>\r\n#define DELAY 5             <\/span>\/\/ einfach ein delay ....<\/span>\r\n\r\nint<\/span> i; int<\/span> j=0<\/span>;\r\nint<\/span> buttonPin =<\/span> 12<\/span>;\r\nint<\/span> testbut =<\/span> 0<\/span>; int<\/span> anim =<\/span> 0<\/span>;\r\nint<\/span> buttonState =<\/span> 0<\/span>;\r\nint<\/span> DATEN[busbytes];\r\nint<\/span> adresse; int<\/span> busstatus;  \r\nbyte sensorbelegt; byte ledsensoron;\r\n\r\n                       \/\/ 0 = LED aus | Sensor nicht belegt<\/span>\r\n                       \/\/ 1 = LED ein | Sensor nicht belegt<\/span>\r\n                       \/\/ 2 = LED aus | Sensor belegt<\/span>\r\n                       \/\/ 3 = LED ein | Sensor belegt<\/span>\r\n\r\nint<\/span> leddat1[] =<\/span> {1<\/span>,1<\/span>,1<\/span>,1<\/span>,0<\/span>,1<\/span>,1<\/span>,1<\/span>,1<\/span>}; \/\/ -<\/span>\r\nint<\/span> leddat2[] =<\/span> {0<\/span>,0<\/span>,0<\/span>,0<\/span>,1<\/span>,0<\/span>,0<\/span>,0<\/span>,0<\/span>}; \/\/ |<\/span>\r\n\r\nvoid<\/span> setup<\/span>()\r\n{\r\n  Serial.begin(9600<\/span>);  \r\n  Serial.println(\"MASTER-KNOTEN\"<\/span>);\r\n  Serial.print(\"Maximum Slaveknoten: \"<\/span>);\r\n  Serial.println(maxKNOTEN);\r\n  Serial.print(\"Datengroesse in byte: \"<\/span>);\r\n  Serial.println(busbytes);\r\n  Serial.println(\"***********************\"<\/span>);\r\n  \r\n  Wire.begin();                 \/\/ Activate I2C link<\/span>\r\n  pinMode(buttonPin, INPUT);    \/\/ test-tastereingang festlegen<\/span>\r\n}\r\n\r\n\r\n\/\/#####################################################################################################<\/span>\r\nvoid<\/span> loop<\/span>()\r\n    \r\n{\r\n  for<\/span> (int<\/span> Knotenadresse =<\/span> startKNOTEN;         \/\/alle knoten scannen<\/span>\r\n           Knotenadresse <=<\/span> maxKNOTEN; \r\n           Knotenadresse++<\/span>) \r\n\r\n        \r\n    \/\/################################################################################################       <\/span>\r\n    { \r\n     \/\/ testbut = 0;  <\/span>\r\n     anim =<\/span> 0<\/span>;   \r\n    Wire.requestFrom(Knotenadresse, busbytes);        \/\/ daten vom jeweiligen knoten anfordern<\/span>\r\n                                                 \r\n           DATEN[0<\/span>]=255<\/span>; DATEN[1<\/span>]=255<\/span>;   \/\/ wenn kein knoten dann auf 255 setzen    <\/span>\r\n          if<\/span>(Wire.available() ==<\/span> busbytes) {                                    \/\/ wenn knoten und daten dann<\/span>\r\n            for<\/span> (i =<\/span> 0<\/span>; i <<\/span> busbytes; i++<\/span>) DATEN[i] =<\/span> Wire.read();          \/\/ daten holen (zuerst busID, dann daten)<\/span>\r\n           \/\/ for (j = 0; j < busbytes; j++) Serial.println(DATEN[j]);        \/\/ daten an rs232 ausgeben   <\/span>\r\n          }            \r\n\r\n\/\/            Serial.println(Knotenadresse);<\/span>\r\n\/\/            Serial.println(DATEN[0]);<\/span>\r\n\/\/            Serial.println(DATEN[1]);<\/span>\r\n\/\/            Serial.println(\" \");<\/span>\r\n           \r\n            adresse=<\/span>DATEN[0<\/span>]; \r\n            busstatus=<\/span>DATEN[1<\/span>];\r\n           \r\n            if<\/span>(busstatus ==<\/span> 0<\/span>)       {sensorbelegt=<\/span>false<\/span>;  ledsensoron=<\/span>false<\/span>;}\r\n            else<\/span> if<\/span> (busstatus ==<\/span> 1<\/span>) {sensorbelegt=<\/span>false<\/span>;  ledsensoron=<\/span>true<\/span>;}\r\n            else<\/span> if<\/span> (busstatus ==<\/span> 2<\/span>) {sensorbelegt=<\/span>true<\/span>;  ledsensoron=<\/span>false<\/span>;}\r\n            else<\/span> if<\/span> (busstatus ==<\/span> 3<\/span>) {sensorbelegt=<\/span>true<\/span>;  ledsensoron=<\/span>true<\/span>;}\r\n      \r\n         \/\/################################################################################################<\/span>\r\n         \/\/Testbutton Status lesen und variable testbut entsprechend setzen<\/span>\r\n       \r\n          buttonState =<\/span> digitalRead(buttonPin);               \/\/tastereingang einlesen<\/span>\r\n          if<\/span>(buttonState ==<\/span> HIGH){                            \/\/wenn taster aktiv dann variable anim setzen<\/span>\r\n          anim =<\/span> 1<\/span>;\r\n          \/\/delay(5); <\/span>\r\n          }\r\n            \r\n\/\/            \/\/debug debuginfo tasterstatus auf rs232 ausgeben<\/span>\r\n\/\/            Serial.println(\"#######################\");<\/span>\r\n\/\/            Serial.print(\"Knoten Adresse    :\");<\/span>\r\n\/\/            Serial.println(adresse);<\/span>\r\n\/\/            Serial.print(\"Busstatus         :\");<\/span>\r\n\/\/            Serial.println(busstatus);<\/span>\r\n\/\/            <\/span>\r\n\/\/            Serial.println(\"----------------\");<\/span>\r\n\/\/            Serial.print(\"Fliese belegt    :\");<\/span>\r\n\/\/            Serial.println(sensorbelegt);<\/span>\r\n\/\/            Serial.print(\"LED Fliese       :\");<\/span>\r\n\/\/            Serial.println(ledsensoron);<\/span>\r\n\/\/            Serial.print(\"#######################\");<\/span>\r\n\/\/            Serial.println(\" \");<\/span>\r\n      \r\n          \/\/################################################################################################<\/span>\r\n          \/\/Testbutton Status an jeweiligen knoten senden<\/span>\r\n      \r\n          Wire.beginTransmission(Knotenadresse);           \/\/ transmit to device actual in for loop<\/span>\r\n          \/\/anim schreiben<\/span>\r\n                    \r\n           if<\/span> (anim==0<\/span>) {testbut=<\/span>leddat1[j]; j++<\/span>;}\r\n                   else<\/span> {testbut=<\/span>leddat2[j]; j++<\/span>;}\r\n           if<\/span> (j>8<\/span>){j=0<\/span>;}\r\n          \r\n          Wire.write(testbut);                             \/\/ senden des tasterstatus<\/span>\r\n          Wire.endTransmission();                          \/\/ ende gel\u00e4nde mit uerbertragung<\/span>\r\n       \r\n          delay(DELAY);\r\n          \r\n\r\n    }\r\n   \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
With this arrangement, it is now possible to read all Arduinos and their input or to control the LED via the bus. In the next step, a „sensor“ is built, a board is laid out and the ArduinoUno reduced to its microcontroller. I’ll talk about that in one of the next posts …<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
<\/div>\n
<\/path><\/svg><\/i> \"Loading\"<\/p>\n
<\/div>\n
Unfortunately, the intervals in which I find some time to write a new post for the blog have not gotten shorter. But post a post per month, I think … \ud83d\ude42 This time it’s not a retro craft project from the local Gefielden or a restoration of an old device, but again something about Arduino.… 
 Weiterlesen<\/a><\/p>\n","protected":false},"author":86,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"ngg_post_thumbnail":0,"footnotes":""},"categories":[1592,1506],"tags":[1914,1925,1911,1913,1918,1921,1923,1924,1928,1920,1927,1926,1919,1912,1828,1922,1916,1917,1915],"class_list":["post-6390","post","type-post","status-publish","format-standard","hentry","category-arduino-en","category-electronics-hobbyist","tag-arduino-en","tag-arduino-projects","tag-arduino-uno-en","tag-atmega-en","tag-atmel-en","tag-databus","tag-development-environment","tag-electronicsprojects","tag-grid-en","tag-ic-en","tag-industry5-0","tag-iot-en","tag-joy-it-uno-en","tag-labview-en","tag-matlab-en","tag-microcontroller-en","tag-sensor-network","tag-sensor-node","tag-sensors"],"a3_pvc":{"activated":true,"total_views":64,"today_views":1},"_links":{"self":[{"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/posts\/6390","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/users\/86"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/comments?post=6390"}],"version-history":[{"count":0,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/posts\/6390\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/media?parent=6390"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/categories?post=6390"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/tags?post=6390"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}