Willkommen auf meiner neuen Website. Hier wird in Kürze eine neue Plattform entstehen, auf der ich mich selbst sowie Teile meiner Arbeit und Interessengebiete präsentieren werde!
#weihnachtenzuhause
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.
Übersicht 3D-Druck-Filament
Die Materialien für den 3D-Druck sind vielseitig und haben unterschiedliche Eigenschaften. In der folgenden Tabelle ist eine Übersicht der verschiedenen Filamente:
| Material | Spezielle Eigenschaften | Verwendungszweck | Preis | Drucktemperatur | Druckbett notwendig | Schwierigkeit Verarbeitung |
|---|---|---|---|---|---|---|
| ABS (Acrylnitril-Butadien-Styrol) | • Stark • Günstig | • Spielzeug • Nutzobjekte | € | 220 – 260 °C | Ja |  |
| ASA (Acrylester-Styrol-Acrylnitril) | • Outdoorgeeignet • UV-resistent | • Außenbereich | € | 230 – 260 °C | Ja | |
| Green-TEC | • Ökologisch abbaubar • Stark | • Prototypen • Modelle | €€ | 170 – 230 °C | optional |  |
| HIPS (High Impact Polystyrene) | • Schlagzäh • Löslich in Limonen | • Nutzobjekte • Stützmaterial | €€ | 220 – 230 °C | ja | |
| Nylon | • Extrem widerstandsfähig | • Abriebfeste Werkzeuge • Funktionsmodelle | €€€ | 230 – 270 °C | ja |  |
| PC (Policarbonat) | • Extrem steif | • Mechanische Bauteile mit hoher Steifigkeit | €€€ | 250 – 310 °C | ja | |
| PETG (Polyethylenterephthalat) | • Standard-Filament • Lebensmittelecht | • Mechanische Bauteile | € | 190 – 230 °C | ja | |
| PMMA (Polymethylmethacrylat) | • Glasalternative | • Acrylglas • Spielzeug • Prototypen | €€ | 230 – 260 °C | ja | |
| PLA (Polyactide) | • Standard-Filament | • Prototypen • Modelle | € | 190 – 210 °C | optional | |
| PP (Polypropylen) | • Leicht • Lebensmittelecht | • Haushaltsgeräte | €€ | 200 – 240 °C | ja | |
| PVA (Polyvinylalkohol) | • Wasserlöslich | • Stützmaterial | €€€ | 180 – 210 °C | ja | |
| TPU/TPE (Thermoplastisches Polyurethan/ Thermoplastische Elastomere) | • Elastisch | • Flexibles Spielzeug • Flexibles Gehäuse | €€ | 190 – 245 °C | optional | |
C auf einen Blick
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
- Theis, T.: Einstieg in C. Für Programmiereinsteiger geeignet. Rheinwerk Computing. 2020
- Wolf, J.: Grundkurs C. Rheinwerk Computing. 2016
- Wolf, J.; Krooß, R.: C von A bis Z. Das umfassende Handbuch. Rheinwerk Computing. 2009
#wirhaltenzusammen
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 Network 4.0 Alpha Update 01
Was ist Stargate Network?
Stargate Network ist ein Computerspiel, das auf dem Science-Fiction Film Stargate und den darauf aufbauenden Serien basiert. Das Spiel ermöglicht das Erforschen von vielen Welten aus dem Stargate Universum, welche mit einem hohen Detailgrad und einem Fokus auf Realität reproduziert werden. Stargate Network bietet die Möglichkeit Planeten und Raumschiffen aus den Stargate-Filmen und -Serien zu entdecken und ein Teil der „Stargate-Welt“ zu werden. Das Spiel ist kostenlos für Windows und Mac erhältlich.
Besonders die Serie Stargate – Kommando SG-1 gehört zu meinen Lieblings-Serien, sodass ich als „Stargate-Fan“ regelrecht verpflichtet bin dieses tolle Spiel, das von einer französischen Non-Profit-Organisation entwickelt wird, weiterzuempfehlen und bekannt zu machen.
Version 4.0 Alpha Update 01
Version 4.0 Alpha Update 01 (4.0.0-a1) ist die aktuelle Version (Stand: Januar 2019), die am 1. Dezember 2018 veröffentlicht wurde. In dieser Version ist es, nach der Umstellung auf die neue Entwicklungsplattform Unreal Engine 4, nun wieder möglich andere Planeten zu besuchen und zu erkunden.
Hinweis:
Das Video wird von YouTube eingebettet. Es gelten die Datenschutzbestimmungen von Google.
Planeten
Um einen anderen Planeten mit dem Stargate anzuwählen, muss man die Toradresse des Planeten wissen. Planeten werden über sechs Koordinaten lokalisiert. Dabei entspricht jeder Punkt des Koordinatensystems einem Planeten. Jedem Planeten ist ein Symbol zugeordnet. Weiterhin ist der Ausgangspunkt (engl. point of origin), also der Planet, von dem aus die Verbindung aufgebaut werden soll, notwendig zu wissen. Eine Toradresse besteht also aus insgesamt sieben Symbolen.
Stargate-Adressen
In dieser Version können neben der Erde noch drei weitere Planeten besucht werden. Hier sind die Stargate-Adressen und die Ausgangssymbole (letztes Symbol) der Planeten aufgelistet:
| 1 | 2 | 3 | 4 | 5 | 6 | | | 7 | |
| Erde: | | | |||||||
| Abydos: | | | |||||||
| Schneewelt: | | | |||||||
| Graswelt: | | |
Bugfix zur Steuerung des Puddel Jumpers
In dieser Version gibt es einen Fehler bei der Steuerung des Puddel Jumpers. Die Tasten für Vorwärts (Leertaste) und Rückwärts (Alt-Taste links) funktionieren nicht. Um diesen Fehler zu beheben habe ich eine Batchdatei geschrieben, die hier heruntergeladen werden kann:
Nach dem entpacken des Zip-Archivs muss die Batch-Datei nur ausgeführt werden. Der Patch ändert dabei die Datei „Input.ini“, die sich im Verzeichnis „%localappdata%\SGN\Saved\Config\WindowsNoEditor“ befindet, sodass diese folgenden Inhalt enthält:
[/Script/Engine.InputSettings])
AxisMappings=(AxisName="Jumper_FlyOFF_Land",Scale=-1.000000,Key=Gamepad_DPad_Down)
AxisMappings=(AxisName="Jumper_FlyOFF_Land",Scale=1.000000,Key=Gamepad_DPad_Up)
AxisMappings=(AxisName="Jumper_FlyOFF_Land",Scale=-1.000000,Key=LeftControl)
AxisMappings=(AxisName="Jumper_FlyOFF_Land",Scale=1.000000,Key=LeftShift)
AxisMappings=(AxisName="Jumper_Forward",Scale=-1.000000,Key=Gamepad_LeftTrigger)
AxisMappings=(AxisName="Jumper_Forward",Scale=1.000000,Key=Gamepad_RightTrigger)
AxisMappings=(AxisName="Jumper_Forward",Scale=-1.000000,Key=LeftAlt)
AxisMappings=(AxisName="Jumper_Forward",Scale=1.000000,Key=SpaceBar)
AxisMappings=(AxisName="Jumper_Sides_Azerty",Scale=-1.000000,Key=A)
AxisMappings=(AxisName="Jumper_Sides_Azerty",Scale=1.000000,Key=E)
AxisMappings=(AxisName="Jumper_Sides_Azerty",Scale=-1.000000,Key=Gamepad_LeftShoulder)
AxisMappings=(AxisName="Jumper_Sides_Azerty",Scale=1.000000,Key=Gamepad_RightShoulder)
AxisMappings=(AxisName="Jumper_Sides_Qwerty",Scale=1.000000,Key=E)
AxisMappings=(AxisName="Jumper_Sides_Qwerty",Scale=-1.000000,Key=Gamepad_LeftShoulder)
AxisMappings=(AxisName="Jumper_Sides_Qwerty",Scale=1.000000,Key=Gamepad_RightShoulder)
AxisMappings=(AxisName="Jumper_Sides_Qwerty",Scale=-1.000000,Key=Q)
AxisMappings=(AxisName="LookUp",Scale=1.000000,Key=Gamepad_RightY)
AxisMappings=(AxisName="LookUp",Scale=-1.000000,Key=MouseY)
AxisMappings=(AxisName="MoveForward",Scale=-1.000000,Key=Down)
AxisMappings=(AxisName="MoveForward",Scale=1.000000,Key=Gamepad_LeftY)
AxisMappings=(AxisName="MoveForward",Scale=-1.000000,Key=S)
AxisMappings=(AxisName="MoveForward",Scale=1.000000,Key=Up)
AxisMappings=(AxisName="MoveForward",Scale=1.000000,Key=W)
AxisMappings=(AxisName="MoveRight",Scale=-1.000000,Key=A)
AxisMappings=(AxisName="MoveRight",Scale=1.000000,Key=D)
AxisMappings=(AxisName="MoveRight",Scale=1.000000,Key=Gamepad_LeftX)
AxisMappings=(AxisName="MoveRight",Scale=-1.000000,Key=Left)
AxisMappings=(AxisName="MoveRight",Scale=1.000000,Key=Right)
AxisMappings=(AxisName="Turn",Scale=1.000000,Key=Gamepad_RightX)
AxisMappings=(AxisName="Turn",Scale=-1.000000,Key=Left)
AxisMappings=(AxisName="Turn",Scale=1.000000,Key=MouseX)
AxisMappings=(AxisName="Turn",Scale=1.000000,Key=Right)Stargate: The Last Stand
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.
A²C-Protokoll
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.
Einführung in das Arduino Entwicklungsboard
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.