{"id":3356,"date":"2018-06-22T23:21:30","date_gmt":"2018-06-22T22:21:30","guid":{"rendered":"http:\/\/blog.fh-kaernten.at\/ingmarsretro\/?p=3356"},"modified":"2021-02-18T09:02:29","modified_gmt":"2021-02-18T08:02:29","slug":"datenknoten-mit-arduino","status":"publish","type":"post","link":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/2018\/06\/22\/datenknoten-mit-arduino\/","title":{"rendered":"Datenknoten mit Arduino"},"content":{"rendered":"
<\/div>\n

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

<\/div>\n

Leider sind die Abst\u00e4nde, in denen ich ein wenig Zeit finde, einen neuen Beitrag f\u00fcr den Blog zu schreiben, nicht k\u00fcrzer geworden. Aber einen Beitrag pro Monat zu posten, halte ich ein… \ud83d\ude42<\/p>\n

\"\"<\/a>Dieses Mal ist es kein Retro Bastelprojekt aus den heimischen Gefilden oder eine Restauration eines alten Ger\u00e4tes, sondern wieder etwas zum Thema Arduino. Die Idee – es soll ein Sensor gebaut werden, der wie immer, eine physikalische Gr\u00f6\u00dfe in ein elektrisches Signal umwandelt. Das ist jetzt nichts Besonderes und um welche Art von Sensor es sich handeln wird, werde ich vorerst noch nicht beschreiben. Aber es soll nicht ein Sensorboard geben, sondern viele. Und diese Sensorboard kurz „Sensoren“ sollen in einer zweidimensionalen Matrix miteinander vernetzt werden. Man kann sich das in etwa vorstellen wie ein Schachbrett, wobei jedes der Schachbrettfelder einen Sensor darstellt. Dieses Netzwerk an Sensoren – also Sensorknoten – soll dann \u00fcber eine \u00dcbergabestelle mit einem Rechner verbunden sein und die Sensordaten des jeweiligen Feldes ausgeben. Es soll dann auch m\u00f6glich sein, einzelne Felder aus dem Netzwerk zu entfernen ohne dass das verbleibende Netzwerk seine Funktion verliert.<\/p>\n

Das ganze System soll m\u00f6glichst einfach und g\u00fcnstig aufgebaut werden. Und so ist schnell ein Systemkonzept entstanden, in dem die Knoten \u00fcber den I\u00b2C Bus kommunizieren und ihre Daten zu einem Master senden. Das folgende Diagramm soll das verdeutlichen.<\/p>\n

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

Dieses Konzept, so dachte ich mir, l\u00e4sst sich am einfachsten mit einem Atmega Microcontroller realisieren. Der hat gen\u00fcgend IO\u00b4s, einen I\u00b2C Bus und UART onboard, ebenso auch analoge Eing\u00e4nge und ben\u00f6tigt wenig Bauteilperipherie, um ihn in einem eigenen Layout zum Leben zu erwecken. Und es gibt nichts schnelleres, so einen Testaufbau eines solchen Knotennetzwerks zu realisieren, als die gut bekannten Arduino Development Boards zu benutzen. Ich habe die g\u00fcnstigste Variante f\u00fcr einen Testaufbau gew\u00e4hlt -> den Chinanachbau vom Arduino Uno (Joy-IT UNO) mit dem Atmga328 im gesockelten DIL Geh\u00e4use.<\/p>\n

\"\"<\/a>

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

Im Bild sind zehn St\u00fcck dieser Microcontrollerboards zu sehen. Von denen soll einer als Bus-Master und neun St\u00fcck als Slaves eingesetzt werden. Jeder dieser Slaves hat nat\u00fcrlich eine eindeutige Bus-Adresse, die im System nur einmal vorkommt. Im Testaufbau wird diese Busadresse \u00fcber den Programmcode fest vergeben, da ohnehin jeder Arduino einmal mit dem Rechner verbunden werden muss, um den Programm-Upload durchzuf\u00fchren. Das soll nat\u00fcrlich sp\u00e4ter anders aussehen. Denn der Arduino wird auf den Atmega328 Chip, seinen Quarz und die paar Widerst\u00e4nde reduziert auf dem Sensorboard mit gelayoutet. Programmiert soll der Chip dann \u00fcber die ISP Pins werden. Da bei vielen Boards nat\u00fcrlich nicht jedes Mal der Programmcode individuell angepasst wird und alle das gleiche Flashfile erhalten sollen, will ich die Sensoradresse mit einem 7Bit Dipschalter einstellen. Ein 4021 Cmos Static Shift Register soll die Bits nach dem Einschalten des Controllers auslesen und seriell in den Controller schieben. Der daraus resultierende Wert steht dann in einer Variablen als Busadresse zu Verf\u00fcgung.<\/p>\n

Jeder dieser Slaves mit seiner individuellen Busadresse wird nun vom Masterknoten der Reihe nach abgefragt, welchen Zustand er hat und ob er einen Ausgang schalten soll, oder nicht. Das bedeutet, der Knoten hat lediglich einen DO (Digitalen Ausgang) mit dem er beispielsweise eine LED aus- und einschalten kann und einen oder mehrere DI (Digitalen Eingang) der einen Zustand, zum Beispiel eines einfachen Schalters abfragt. Diese Funktionen werden in 2 Bits eines Bytes gespeichert. Ein weiteres Byte dient zur \u00dcbertragung der Busadresse. Es werden also zwei Bytes \u00fcber den Bus geschickt. Das untenstehende Bild zeigt den Testaufbau mit den „UNO-Boards“<\/p>\n

\"\"<\/a>

Alle Arduinos sind mit I\u00b2C Datenbus und Spannungsversorgung verbunden<\/p><\/div>\n

Der Ablauf l\u00e4uft wie folgt:<\/p>\n

MASTER:
\n<\/strong>Der Masterknoten sendet nach der Reihe an alle Slave-Adressen eine Anfrage und einen Schaltbefehl (der kommt f\u00fcr alle Knoten von einem TEST-Taster Eingang am Master) f\u00fcr den LED-Ausgang des Knotens und sieht ob eine Antwort zur\u00fcckkommt oder nicht. Wenn keine Antwort kommt, ist der Knoten nicht im Netz oder defekt. Kommt eine Antwort, so besteht diese aus der Adresse des Knotens und seinem Statusbyte. Diese Informationen werden \u00fcber ein RS232 Terminal an den, am Master angeschlossenen Rechner \u00fcbertragen. So kann dort beispielsweise \u00fcber eine Visualisierung mittels (NI LabVIEW, oder Matlab o.\u00e4.) der Schaltzustand jedes einzelnen Knotens am Bildschirm angezeigt werden. Mit einer Anpassung des Master Programmes ist es auch m\u00f6glich, die LED-Ausg\u00e4nge der Slaves \u00fcber den Rechner zu schalten.<\/p>\n

SLAVE:<\/strong>
\nWenn der Masterknoten vom Slave Daten anfordert, so sendet der Slave zwei Bytes zur\u00fcck. Wobei Byte0 wieder die Slave ID (also Busadresse ist) und Byte1 die Daten. Byte1 besteht eigentlich aus nur zwei Bit, die wie folgt kodiert sind (in dezimaler Darstellung):
\n 0 = LED aus | Sensor nicht ausgel\u00f6st
\n 1 = LED ein | Sensor nicht ausgel\u00f6st
\n 2 = LED aus | Sensor ausgel\u00f6st
\n 3 = LED ein | Sensor ausgel\u00f6st<\/p>\n

Der Programmcode als Beispiel:<\/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
Die Busadresse ist in diesem Slave-Code noch individuell einzugeben. In der n\u00e4chsten Version ist dann der vorherbeschriebene „Serializer“ der parallelen Dip-Schaltervariante implementiert. Das folgende Codebeispiel ist von Masterknoten, der die Slaves ausliest und mittel Pr\u00fcftaster ein LED Muster an die Sensor Slaves sendet:<\/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\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
Mit dieser Anordnung ist es jetzt m\u00f6glich alle Arduinos und deren Eingang auszulesen bzw. die LED \u00fcber den Bus zu steuern. Im n\u00e4chsten Schritt wird ein „Sensor“ gebaut, eine Platine gelayoutet und der Arduino Uno auf seinen Microcontroller reduziert. Dar\u00fcber werde ich in einem der n\u00e4chsten Posts berichten…<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
<\/div>\n
<\/path><\/svg><\/i> \"Loading\"<\/p>\n
<\/div>\n
Leider sind die Abst\u00e4nde, in denen ich ein wenig Zeit finde, einen neuen Beitrag f\u00fcr den Blog zu schreiben, nicht k\u00fcrzer geworden. Aber einen Beitrag pro Monat zu posten, halte ich ein… \ud83d\ude42 Dieses Mal ist es kein Retro Bastelprojekt aus den heimischen Gefilden oder eine Restauration eines alten Ger\u00e4tes, sondern wieder etwas zum Thema… 
 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":[1187,57],"tags":[430,289,1057,354,1050,1053,1056,1055,1060,1052,1059,1058,1051,321,964,1054,1047,1049,1048],"class_list":["post-3356","post","type-post","status-publish","format-standard","hentry","category-arduino","category-elektronikbastler","tag-arduino","tag-arduino-uno","tag-arduinoprojekte","tag-atmega","tag-atmel","tag-datenbus","tag-elektronikprojekte","tag-entwicklungsumgebung","tag-grid","tag-ic","tag-industrie5-0","tag-iot","tag-joy-it-uno","tag-labview","tag-matlab","tag-microcontroller","tag-sensoren","tag-sensorkonten","tag-sensornetzwerk"],"a3_pvc":{"activated":true,"total_views":115,"today_views":1},"_links":{"self":[{"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/posts\/3356","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=3356"}],"version-history":[{"count":0,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/posts\/3356\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/media?parent=3356"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/categories?post=3356"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.fh-kaernten.at\/ingmarsretro\/wp-json\/wp\/v2\/tags?post=3356"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}