Der Wireless-Tag WT32-ETH01 ist ein Mikrocontroller-Board mit einem Espressif Systems ESP32-WROOM-32 SoC und Microchip LAN8720A Ethernet-PHY. Zusammen mit WLAN, Bluetooth und weiteren I/O-Schnittstellen des ESP32 ergibts sich ein sehr kostengünstiges und flexibles Board für Netzwerkanwendungen.

Der WT32-ETH01 lässt sich mit dem Arduino Framework frei programmieren, um individuelle Funktionsweisen je nach Anforderung umsetzen zu können. Auf dieser Seite finden Sie alle notwendigen Informationen zur Programmierung des Boards mit Ethernet.

Wireless-Tag WT32-ETH01 Mikrocontroller-Board

Hardware

Das ESP32-WROOM-32 SoC-Modul (der Eigenbau von Wireless-Tag heißt WT32-S1) beinhaltet den Espressif ESP32-D0WDQ6 Mikrocontroller. Der Mikrocontroller enthält neben vielen weiteren Peripherie-Schnittstellen auch einen 10/100 MBit/s Ethernet Media Access Controller (oft als EMAC bezeichnet), der konform mit dem Standard IEEE-802.3 von 2008 ist.

Funktionales Blockdiagram ESP32 Mikrocontroller

An den EMAC kann über das Reduced media-independent interface (RMII) und das Serial Management Interface (SMI) ein Ethernet-PHY (physical layer) angebunden werden, der dann den Anschluss eines Ethernet LAN-Ports mit RJ45 ermöglicht. Beim WT32-ETH01 wird der Microchip LAN8720A als Ethernet-PHY verwendet. MAC und PHY erhalten beide über einen externen 50 MHz Quarzoszillator ihr Referenz-Taktsignal.

WT32-ETH01 Ethernet Blockschaltbild

Software

Entwicklungsumgebung

Um den WT32-ETH01 mit dem Arduino Framework programmieren können, muss zunächst die Entwicklungsumgebung eingerichtet werden.

Als erstes wird die Arduino IDE (integrated development environment) installiert. Sie beinhaltet einen Texteditor, Bibliothek-Manager und Compiler.

Als nächstes muss der ESP32 Arduino Core in der IDE heruntergeladen werden. Dazu unter „Datei“ ➔ „Einstellungen…“ ➔ „Zusätzliche Boardverwalter-URLs“ den Eintrag

 https://espressif.github.io/arduino-esp32/package_esp32_index.json

hinzufügen (ein Eintrag pro Zeile). Anschließend in der linken Menüleiste die „Board-Verwaltung“ öffnen und nach „ESP32“ suchen. Installieren Sie „esp32 von Espressif Systems“.

Schlussendlich muss der WT32-ETH01 unter „Werkzeuge“ ➔ „Board“ ➔ „esp32“ ➔ „WT32-ETH01 Ethernet Module“ ausgewählt werden.

Beispielcode Ethernet

Der ESP32 Arduino Core enthält bereits eine Bibliothek zur Ansteuerung von Ethernet (ETH.h). Wichtig ist der Bibliothek die korrekte Hardwaredefinition des Ethernet-PHYs mitzuteilen wenn ETH.begin() aufgerufen wird.

Soll eine statische IP-Adresse verwendet werden, wird dies mit der Funktion ETH.config() eingestellt. Soll DHCP verwendet werden, kann die Funktion ohne Parameter aufgerufen werden oder komplett gelöscht werden. Die Funktion darf erst aufgerufen werden, wenn Ethernet gestartet wurde.

Eine Besonderheit bei Ethernet ist die Funktion ETH.setHostname()um den Hostname festzulegen. Diese darf ebenfalls erst aufgerufen werden, wenn Ethernet gestartet wurde, muss aber ausgeführt werden, bevor Ethernet verbunden ist! Daher werden Events in einer Callback-Funktion der Klasse „Network“ verwendet, um den korrekten Ablauf beizubehalten.

Eine Reihe von Funktionen ermöglicht das Auslesen von Ethernet-Informationen und Reagieren auf verschiedene Zustände. Im folgenden Beispielcode werden diese vorgeführt.

/* Libraries */
#include <ETH.h> //https://github.com/espressif/arduino-esp32

/* Ethernet hardware configuration */
#define ETH_PHY_TYPE    ETH_PHY_LAN8720
#define ETH_PHY_ADDR    1
#define ETH_PHY_POWER   16
#define ETH_PHY_MDC     23
#define ETH_PHY_MDIO    18
#define ETH_CLK_MODE    ETH_CLOCK_GPIO0_IN
#define ETH_RMII_TX_EN  21
#define ETH_RMII_TX0    19
#define ETH_RMII_TX1    22
#define ETH_RMII_RX_ER  13
#define ETH_RMII_RX0    25
#define ETH_RMII_RX1    26
#define ETH_RMII_CRS_DV 27

/* Ethernet settings */
const char* ethernetHostname = "WT32-ETH01";
IPAddress ethernetStaticLocalIp(192, 168, 178, 10);
IPAddress ethernetStaticGateway(192, 168, 178, 1);
IPAddress ethernetStaticSubnet(255, 255, 0, 0);
IPAddress ethernetStaticPrimaryDns(8, 8, 8, 8);   //DNS 1 optional
IPAddress ethernetStaticSecondaryDns(8, 8, 4, 4); //DNS 2 optional

/* Variables */
static bool ethernetConnected = false;

void setup() {
  /* Initialize UART */
  Serial.begin(115200);

  /* Initialize Ethernet */
  Network.onEvent(onNetworkEvent);
  ETH.begin(ETH_PHY_TYPE,\
            ETH_PHY_ADDR,\
            ETH_PHY_MDC,\
            ETH_PHY_MDIO,\
            ETH_PHY_POWER,\
            ETH_CLK_MODE);
  //ETH.config(); //use DHCP
  ETH.config(ethernetStaticLocalIp,\
             ethernetStaticGateway,\
             ethernetStaticSubnet,\
             ethernetStaticPrimaryDns,\
             ethernetStaticSecondaryDns); //use static IP
}

void loop() {
  /* Print Ethernet information */
  Serial.println("- - -");

  Serial.print("Ethernet MAC: ");
  Serial.println(ETH.macAddress());

  Serial.print("Ethernet ");
  Serial.println(ETH.connected() ? "connected" : "not connected");

  Serial.print("Ethernet ");
  Serial.println(ETH.linkUp() ? "link up" : "no link");

  Serial.print("Ethernet ");
  Serial.println(ETH.fullDuplex() ? "full duplex" : "half duplex");
  
  Serial.print("Speed: ");
  Serial.print(ETH.linkSpeed());
  Serial.println(" MBit/s");

  if (ETH.hasIP()) {
    Serial.print("Ethernet local IP: ");
    Serial.println(ETH.localIP());
  }
  else {
    Serial.println("No Ethernet IP");
  }

  if (ethernetConnected) {
    Serial.println(ETH);
  }

  delay(10000); //delay 10 s
}

// WARNING: function is called from another FreeRTOS task (thread)!
void onNetworkEvent(arduino_event_id_t event) {
  switch (event) {
    case ARDUINO_EVENT_ETH_START:
      Serial.println("Event: Ethernet started");
      ETH.setHostname(ethernetHostname);
      break;
    case ARDUINO_EVENT_ETH_CONNECTED:
      Serial.println("Event: Ethernet connected");
      break;
    case ARDUINO_EVENT_ETH_GOT_IP:
      Serial.println("Event: Ethernet got IP");
      ethernetConnected = true;
      break;
    case ARDUINO_EVENT_ETH_LOST_IP:
      Serial.println("Event: Ethernet lost IP");
      ethernetConnected = false;
      break;
    case ARDUINO_EVENT_ETH_DISCONNECTED:
      Serial.println("Event: Ethernet disconnected");
      ethernetConnected = false;
      break;
    case ARDUINO_EVENT_ETH_STOP:
      Serial.println("Event: Ethernet stopped");
      ethernetConnected = false;
      break;
    default: break;
  }
}

Programmer

Um den Programmcode auf den WT32-ETH01 zu übertragen ist ein USB-Seriell-Wandler notwendig, der die Versorgungsspannung und das Logiksignal mit 3,3 V ausgibt. Häufig verwendete Wandler mit 5 V-Signal können den ESP32 irreparabel beschädigen.

Die Wandler haben typischerweise einen FT232R oder CH340 Chip und benötigen den jeweils passenden USB-Treiber. Empfehlen kann ich den „USB to TTL V0825“ Wandler mit FTDI-Chip und Jumpern für 1,8/2,5/3,3/5 V TTL-Pegel.

Die Signale RTS und DTR werden verwendet um den ESP32 automatisch in den Programmiermodus zu setzen und neu zu starten.

API documentation

Response example

{
    "version": "2024.03.18",
    "date": "2024-03-18 20:34:02",
    "vendors": [
        {
            "id": "1209",
            "name": "Generic",
            "devices": [
                {
                    "id": "0001",
                    "name": "pid.codes Test PID"
                },
                ...
            ]
        },
        ...
    ]
}

Filters

To get a specific device or list of devices you can add VID and PID filters to the request.
The request can be:

  • a single VID or PID
  • a list of multiple VIDs or PIDs
  • a specific pair of VID and PID

as well as each combination of them.

If the request contains a list of multiple VIDs all PIDs will be filtered independently like a request without VID.

All VIDs and PIDs need to be in HEX format with 4 digits!

GET request

GET request filters are part of the URL. They are specified as query string/parameter.

// single VID/PID
vid=(VID)
pid=(PID)

// list of VIDs/PIDs
vid[]=(VID 1)&vid[]=(VID 2)&...
pid[]=(PID 1)&pid[]=(PID 2)&...

Examples for GET request filters:

// all devices with vendor ID 0x1209
apps.sebastianlang.net/usb-ids?vid=1209

// all devices with product ID 0x0001
apps.sebastianlang.net/usb-ids?pid=0001

// a specific device with VID 0x1209 and PID 0x0001
apps.sebastianlang.net/usb-ids?vid=1209&pid=0001

// two devices (0x0001, 0x0002) from the same vendor 0x1209
apps.sebastianlang.net/usb-ids?vid=1209&pid[]=0001&pid[]=0002

POST request

POST request filters are part of the body data. They need to be in JSON format as single object or list of objects.

// single object
{
    "vid": "(VID)",
    "pid": "(PID)"
}

// list of objects
[
    {
        "vid": "(VID)",
        "pid": "(PID)"
    },
    {
        "vid": "(VID)",
        "pid": [
            "(PID 1)",
            "(PID 2)",
            ...
        ]
    },
    {
        "vid": [
            "(VID 1)",
            "(VID 2)",
            ...
        ]
    },
    ...
]

Examples for POST request filters:

// all devices with vendor ID 0x1209
{
    "vid": "1209"
}

// all devices with product ID 0x0001
{
    "pid": "0001"
}

// a specific device with VID 0x1209 and PID 0x0001
{
    "vid": "1209",
    "pid": "0001"
}

// two devices (0x0001, 0x0002) from the same vendor 0x1209
{
    "vid": "1209",
    "pid": [
        "0001",
        "0002"
    ]
}

// all devices with vendor ID 0x1209 or 0x1234
{
    "vid": [
        "1209",
        "1234"
    ]
}

// multiple filters in one requests
[
    {
        "vid": "1209",
        "pid": "0001"
    },
    {
        "vid": "1234",
        "pid": "0000"
    },
    {
        "vid": [
            "2341",
            "0403"
        ]
    }
]

Dieses tolle Video von Tzu-Hsuan Chuang ist ein Ortsporträt über meine Heimatstadt Trossingen und das umfangreiche Musikleben das hier geboten wird.
Auch mich hat die musikalische Vielfalt der Stadt schon von klein auf begleitet. Durch die musikalische Früherziehung, das Erlernen des Trossinger Heimatinstruments, der Mundharmonika, während der Grundschule, sowie den Musikunterricht auf dem Schlagzeug und der Zugposaune an der Musikschule habe ich Leidenschaften entwickelt, die ich bis heute in vielen musikalischen Projekten, besonders in Orchestern und Bands zum Ausdruck bringen kann.
Durch das gemeinsame Musizieren hat sich mein Weg mit unzähligen wundervollen Menschen gekreuzt und nicht zuletzt hat das musikalische Vereinsleben mir das Gefühl von Heimat gegeben.
So spiegelt dieses Video nicht nur die musikalische Vielfalt in Trossingen wieder, sondern auch meine persönliche Entwicklung und Lebensgeschichte.
Musik ist Heimat – Trossingen ist meine Heimat.

Das Orchester Hohnerklang sagt mit seinem Videoprojekt #weihnachtenzuhause DANKE, an alle Freunde, Gönner, Fans und Sponsoren, die den Verein in diesem herausfordernden Jahr unterstützt haben!
Frohe Weihnachten, einen guten Rutsch ins Neue Jahr 2021 und viel Spaß mit unserer Fassung von „Es ist ein Ros‘ entsprungen„!
Eure Spieler vom Orchester Hohnerklang – Trossingen

Hinweis:
Das Video wird von YouTube eingebettet. Es gelten die Datenschutzbestimmungen von Google.

Die Materialien für den 3D-Druck sind vielseitig und haben unterschiedliche Eigenschaften. In der folgenden Tabelle ist eine Übersicht der verschiedenen Filamente:

MaterialSpezielle EigenschaftenVerwendungszweckPreisDrucktemperaturDruckbett notwendigSchwierigkeit Verarbeitung
ABS
(Acrylnitril-Butadien-Styrol)
Stark
Günstig
Spielzeug
Nutzobjekte
220 – 260 °CJa
ASA
(Acrylester-Styrol-Acrylnitril)
Outdoorgeeignet
UV-resistent
Außenbereich230 – 260 °CJa
Green-TEC Ökologisch abbaubar
Stark
Prototypen
Modelle
170 – 230 °Coptional
HIPS
(High Impact Polystyrene)
Schlagzäh
Löslich in Limonen
Nutzobjekte
Stützmaterial
€€220 – 230 °Cja
Nylon Extrem widerstandsfähig Abriebfeste Werkzeuge
Funktionsmodelle
€€€230 – 270 °Cja
PC
(Policarbonat)
Extrem steif Mechanische Bauteile mit hoher Steifigkeit€€€250 – 310 °Cja
PETG
(Polyethylenterephthalat)
Standard-Filament
Lebensmittelecht
Mechanische Bauteile190 – 230 °Cja
PMMA
(Polymethylmethacrylat)
Glasalternative Acrylglas
Spielzeug
Prototypen
€€230 – 260 °Cja
PLA
(Polyactide)
Standard-Filament Prototypen
Modelle
190 – 210 °Coptional
PP
(Polypropylen)
Leicht
Lebensmittelecht
Haushaltsgeräte€€200 – 240 °Cja
PVA
(Polyvinylalkohol)
Wasserlöslich Stützmaterial€€€180 – 210 °Cja
TPU/TPE
(Thermoplastisches Polyurethan/ Thermoplastische Elastomere)
Elastisch Flexibles Spielzeug
Flexibles Gehäuse
€€190 – 245 °Coptional

Die Programmiersprache C wurde Anfang der 70er Jahre von Dennis Ritchie entwickelt. Sie ist sehr leistungsstark und effizient. Daher stellt sie auch die Basis vieler neuer moderner Programmiersprachen dar.

Dieser Artikel ist eine kurze Zusammenfassung der wichtigsten Eigenschaften der Programmiersprache und ihrer Syntax.

Eigenschaften

  • Ermöglicht schnelle und direkte Speicherzugriffe
  • Case-sensitiv
  • Null-basierter Index
  • Keine objektorientierte Programmiersprache (vgl. C++)
  • Nicht typsicher

Syntax

In C folgt jedem Befehl ein Semikolon, außer nach Präprozessoranweisungen.

Kommentare

// Einzeiliger Kommentar
/*
   Mehrzeiliger
   Kommentar
*/

Datentypen

Für für die Größenordnung der Datentypen in C gilt:
char ≤ short int ≤ int ≤ long int ≤ long long int.

Anmerkung: Empfohlen wird die Verwendung der neuen Integer-Datentypen, die im C99-Standard definiert wurden, da hier gewährleistet ist, dass die Größe der Datentypen bei allen Compilern gleich groß ist. Bei den alten Integer-Datentypen kann die Größe je nach Compiler unterschiedlich sein. Auch die Genauigkeit (signifikante Nachkommastellen) von Gleitkommazahlen ist abhängig vom Compiler.

Neuer Datentyp Alter Datentyp Größe Wertebereich
 int8_t char  1 Byte -128
bis
127
uint8_t unsigned char  1 Byte 0
bis
255
 int16_t int 2 Byte -32.768
bis
32.767
uint16_t unsigned int 2 Byte 0
bis
65.535
 int32_t long 4 Byte -2.147.483.648
bis
2.147.483.647
uint32_t unsigned long 4 Byte 0
bis
4.294.967.295
 int64_t long long 8 Byte -9.223.372.036.854.775.808
bis
9.223.372.036.854.775.807
uint64_t unsigned long long 8 Byte 0
bis
18.446.744.073.709.551.615
Datentyp Größe Wertebereich
Kein bzw. beliebiger Typ
void
Boolsche Zahl
bool 1 Byte 0 (false)
oder
1 (true)
Zeichen (natürliche Zahlen)

signed
char
char
1 Byte -128
bis
127
unsigned char 1 Byte 0
bis
255
Natürliche Zahlen


signed
signed
short
short int
short
short int
2 Byte -32.768
bis
32.767
unsigned
unsigned
short
short int
2 Byte 0
bis
65.535

signed
int
int
2 Byte -32.768
bis
32.767
unsigned int 2 Byte 0
bis
65.535


signed
signed
long
long int
long
long int
4 Byte -2.147.483.648
bis
2.147.483.647
unsigned
unsigned
long
long int
4 Byte 0
bis
4.294.967.295


signed
signed
long long
long long int
long long
long long int
8 Byte -9.223.372.036.854.775.808
bis
9.223.372.036.854.775.807
unsigned
unsigned
long long
long long int
8 Byte 0
bis
18.446.744.073.709.551.615
size_t Maximales unsigned int (Prozessorabhängig)
Gleitkommazahlen
float 4 Byte 1,175494351E-38
bis
3,402823466E+38
double 8 Byte 2,2250738585072014E-308
bis
1,7976931348623158E+308
long double 16 Byte 3.4E-4932
bis
1.1E+4932

Variablen & Arrays

bool  bZustand = true;

int   iZahl = 3;
int   iZahl1, iZahl2 = 7;

float fKommazahl = 42.69;
int   iVektor[4] = {1,2,3,4};
int   iMatrix[2][3] = {{1,2,3},{4,5,6}};

char  cZeichen = 'S';
char  cZeichenkette[] = "Hallo Welt!";

Schlüsselwörter für Variablen

  • const: Konstante
  • static: Variable wird nach einem Anweisungsblock nicht verworfen, sondern speichert ihren Wert bis zum nächsten Aufrufen des Anweisungsblocks
  • register: Variable wird optimiert für schnelle und häufige Zugriffe als Registervariable im Prozessor gespeichert (wird bei modernen Compilern nicht empfohlen, da diese selbstständig Optimierungsaufgaben übernehmen)
  • volatile: Variable kann sich jederzeit ändern (z.B. durch eine Interrupt-Routine) und wird daher nicht optimiert und immer direkt aus dem Hardwarespeicher gelesen
  • extern: Variable ist in einem anderen C-File/H-File deklariert und verweist auf diese

Definition eines Datentyps

typedef unsigned long ulong; //ulong = unsigned long
ulong iZahl = 24;

Strukturierte Datentypen

typedef struct _Person {
    char  Name[30];
    int   Alter;
    float Groesse;
} Person;

Person sPersonen[10];

Union-Datenstruktur

Eine Union-Datenstruktur ähnelt einem strukturierten Datentyp, jedoch mit dem Unterschied, dass alle Untervariablen die selbe Speichergröße belegen. Der Speicherbedarf wird durch das größte Element bestimmt.

typedef union _Fahrzeug {
    typedef struct _Auto {
        int  Typ;       // 2 Byte
        int  Farbcode;  // 2 Byte
    } Auto;
    typedef struct _Fahrrad {
        bool Einrad;    // 1 Byte
        int  Modell;    // 2 Byte
        int  Farbcode;  // 2 Byte
    } Fahrrad;
} Fahrzeug;
typedef struct _Mobil {
    int Datentyp;       // Typ der Union-Datenstruktur
    Fahrzeug sFahrzeug; // 5 Byte
} Mobil;

Enumeration

enum Farbe {rot, gruen, blau};
/* rot   = 0
   gruen = 1
   blau  = 2
*/

enum Groesse {
    xs,
    s = 2,
    m,
    l = 2,
    xl
};
/* xs = 0
   s = 2
   m = 2
   l = 2
   xl = 4
*/

Zeiger

Zeiger (engl. pointer) halten die Speicheradresse des ersten Bytes einer Variablen.
int iZahl;        // Variable vom Typ Integer
int *pZeiger;     // Zeiger mit Sprungweite Integer (2 Byte)
pZeiger = &iZahl; // Adresse von iZahl in pZeiger speichern
*pZeiger = 180;   // An der Adresse von pZeiger den Wert 180 zuweisen (iZahl ist jetzt also 180)

char str[20]; // Zeichenkette mit 20 Zeichen
char *pStr;   // Zeiger mit Sprungweite Character (1 Byte)
pStr = str;   // Anfangsadresse der Zeichenkette in pStr speichern (Arrays sind bereits Zeiger)

Person sMensch;      // Variable vom Strukturtyp Person
Person *pMensch;     // Pointer mit Sprungweite des Strukturtyps Person
pMensch = &sMensch;  // Adresse von sMensch in pMensch speichern
pMensch->Alter = 18; // An der Adresse des Unterelements Alter von pMensch den Wert 18 zuweisen (sMensch.Alter ist jetzt also 18)

Standard-Bibliotheken

  • <stdlib.h> // Standard-Bibliothek
  • <stdio.h> // Input Output Bibliothek
  • <stdbool.h> // Boolsche Zahl
  • <limit.h> // Natürliche Zahlen
  • <float.h> // Gleitkommazahlen
  • <stdint.h> // Neue Integer-Datentypen nach C99-Standard

Beispiel-Programmcode: Hello World

//Bibliotheken
#include <stdlib.h>
#include <stdio.h>

int main() {
    printf("Hello World!\n"); //Ausgabe auf der Konsole

    system("pause"); //Programm anhalten
    return EXIT_SUCCESS; //Programm beenden
}

Literatur

Nun ist es fertig – das Orchester Hohnerklang präsentiert das von Hans-Günther Kölz neu komponierte Stück: #wirhaltenzusammen.
Das Orchester aus Trossingen hat das aktive Musizieren in der Zeit der Corona-Krise weiter betrieben und dadurch den Kontakt zueinander nicht verloren. Nur halt einmal auf andere Weise, nämlich im Over-Dub-Verfahren. Jeder Spieler und jede Spielerin, darunter auch ich, hat sich mit einem Timecode zuhause gefilmt und aufgenommen. Daraus haben wir ein Gesamtwerk produziert.
Viel Spaß damit!

Hinweis:
Das Video wird von YouTube eingebettet. Es gelten die Datenschutzbestimmungen von Google.

Stargate: The Last Stand ist eine kostenlose Modification für Half-Life2 von InterWave Studios. Die Modifikation ist ein Online Multiplayer-Game, das auf den Fernsehserien: Stargate – Kommando SG-1, Stargate Atlantis und Stargate Universe basiert. Der Spieler wählt zwischen den beiden Teams: Goa’uld und Tau’ri und muss seine Missionen erfüllen oder das andere Team im Deathmatch bekämpfen.

Hinweis:
Das Video wird von YouTube eingebettet. Es gelten die Datenschutzbestimmungen von Google.

Das A²C-Protokoll (advanced Arduino communication protocol) wurde 2016 von mir entwickelt und wurde ursprünglich zur einheitlichen Kommunikation zwischen einem Arduino und einem Computer über die serielle USB-Schnittstelle entworfen. Es lässt sich jedoch ebenso auf eine Kommunikation zwischen anderen Gerätekombinationen (z. Bsp. Arduino zu Arduino oder Arduino zu Smartphone über Bluetooth) anwenden.

Der Name des Protokolls ist eine Anspielung auf den seriellen Datenbus I²C und auf die englische Sprechweise „a to c protocol“ für „Arduino to computer protocol“.

Das Grundkonzept des A²C-Protokolls basiert auf der Extensible Markup Language (XML), hat aber keinen Start- und Endtag, sondern nur einen umschließenden Tag, der den Befehl und alle Daten enthält.

Das Protokoll muss für eine eindeutig definierte Kommunikation unter Umständen mit weiteren Kommunikationsrichtlinien erweitert werden. Zum Beispiel müssen für eine Kommunikation über die UART-Schnittstelle, für die das Protokoll ursprünglich vorgesehen war, die Baudrate, die Anzahl der Datenbits, die Paritätskontrolle und die Anzahl der Stopp-Bits zwischen beiden Geräten identisch konfiguriert sein.

Das Protokoll findet bereits Anwendung in den Arduino-basierenden Produkten:

  • SunTracker (SIA 2016/2017 der Staatlichen Feintechnikschule mit Technischem Gymnasium Schwenningen )
  • Digitale Dual-Lötstation (Berufsausbildung Continental Automotive GmbH Villingen)
  • Line-Follower „Herbie“ (WS 2018/2019 Hochschule Furtwangen)
  • WG-Konsole (WS 2018/2019 Hochschule Furtwangen)

Die größte Verbreitung hat das A²C-Protokoll im Zusammenhang mit der PC-Software Arduino-Communication™ gefunden. Dieses ermöglicht es Arduino-Programmierern eine schnelle und einfache Kommunikation für eine Steuerung oder Debugging-Zwecke aufzubauen. Des Weiteren können ein Interface eingerichtet und beliebige Tastenkombinationen hinterlegt werden, die sich als Projektdatei speichern und somit auch für andere Nutzer zur Steuerung veröffentlichen lassen.

Das A²C-Protokoll ist unter der MIT-Lizenz lizenziert.

In 15 Minuten zum ersten Programm

Finde einen einfachen und schnellen Einstieg ohne Vorkenntnisse in die Welt der Mikrocontroller. Lerne die Entwicklungsplattform Arduino kennen und schreibe in 15 Minuten dein erstes Programm, um eine LED zum Blinken zu bringen.
Los geht’s!

Vorwort

Arduino ist eine aus Soft- und Hardware bestehende Physical-Computing-Plattform. Beide Komponenten sind im Sinne von Open Source quelloffen. Die Hardware besteht aus einem einfachen E/A-Board mit einem Mikrocontroller, der über analoge und digitalen Ein- und Ausgängen verfügt. Die Entwicklungsumgebung basiert auf Processing und soll auch technisch weniger Versierten den Zugang zur Programmierung und zu Mikrocontrollern erleichtern. Die Programmierung selbst erfolgt in einer C bzw. C++-ähnlichen Programmiersprache, wobei technische Details wie Header-Dateien vor den Anwendern weitgehend verborgen werden und umfangreiche Bibliotheken und Beispiele die Programmierung vereinfachen. Arduino kann verwendet werden, um eigenständige interaktive Objekte zu steuern oder um mit Softwareanwendungen auf Computern zu interagieren.

Wikipedia

Software-Installation

Arduino IDE

Zunächst wird die Programmier-Entwicklungsumgebung (Arduino IDE) installiert. Das Programm kann von der offiziellen Webseite unter https://www.arduino.cc/en/main/software als Windows Installer heruntergeladen werden.

USB-Treiber

Zur Kommunikation mit der Hardware eines Arduino-Clones ist ein weiterer USB-Treiber notwendig. Dieser kann unter https://cloud.sebastianlang.net/index.php/s/qXMKkbAWgLfzw69
als Zip-Archiv heruntergeladen werden. Nach dem Entpacken des Archivs wird die Datei setup.exe ausgeführt.

Hardware verbinden

Nach der Installation der Software wird das Arduino-Board kinderleicht über ein USB-Kabel mit dem Computer verbunden.

Eigenes Programm

Mit dem ersten eigenen Programm wird eine LED auf dem Arduino-Board zum Blinken gebracht. Dazu wird zunächst die Arduino IDE auf dem Computer gestartet und ein neuer Sketch (Mikrocontroller-Programm) über das Menü unter Datei → Neu geöffnet. Anschließend wird folgender Code in den Editor geschrieben:

//Methode "setup" wird ein Mal beim Programmstart ausgeführt
void setup() {
  //Anschluss des LED-Pins wird als Ausgang initialisiert
  pinMode(LED_BUILTIN, OUTPUT);
}

//Methode "loop" wird nach "setup" in einer Dauerschleife ausgeführt
void loop() {
  //High-Pegel (5 V) am Anschluss des LED-Pins anlegen (LED anschalten)
  digitalWrite(LED_BUILTIN, HIGH);
  //Eine Sekunde (1000 Millisekunden) warten
  delay(1000);
  //Low-Pegel (0 V) am Anschluss des LED-Pins anlegen (LED ausschalten)
  digitalWrite(LED_BUILTIN, LOW);
  //Eine Sekunde (1000 Millisekunden) warten
  delay(1000);
}

Anschließend wird über das Menü unter Werkzeuge → Board das Arduino-Board ausgewählt, sowie der COM-Port, an den das Entwicklungsboard angeschlossen ist.

Das Programm wird nun mit einem Kompiler in Maschinencode übersetzt und anschließend auf den Microkontroller des Arduinos übertragen. Dazu wird auf der linken Seite in der Werkzeugleiste auf die Schaltfläche Hochladen geklickt.

Nach dem Übertragen des Programms blinkt die LED auf dem Arduino UNO Board im Sekundentakt.

Weitere Informationen

Technische Details zum Arduino UNO Board sind unter https://store.arduino.cc/arduino-uno-rev3 zu finden.
Eine Übersicht aller Funktionen, Variablen und Strukturen ist unter https://www.arduino.cc/reference/de zu finden.
Viele hilfreiche Beispiele lassen sich in der Arduino IDE unter Datei → Beispiele finden.