Kursmaterial: ArduBlock Referenz

Aus letsgoing
Wechseln zu: Navigation, Suche

Oe Tit CoverBlockreverenz.png


Verfasser: Bühler, Herrmann Stand 30.9.2014 kursmaterial

Inhaltsverzeichnis

Lizenz Blockreferenz

Dieses Werk von letsgoING ist lizenziert unter einer Creative Commons Namensnennung - Nicht kommerziell - Keine Bearbeitungen 4.0 International Lizenz.


Namensnennung Sie müssen die Urheberschaft ausreichend deutlich benennen, einen Link zur Lizenz beifügen und angeben, ob Änderungen vorgenommen wurden. Diese Angaben dürfen in jeder angemessenen Art und Weise gemacht werden, allerdings nicht so, dass der Eindruck entsteht, der Lizenzgeber unterstütze gerade Sie oder Ihre Nutzung des Werks besonders.

Nicht kommerziell Sie dürfen das Material nicht für kommerzielle Zwecke nutzen.

Keine Bearbeitungen Wenn Sie das Material remixen, verändern oder darauf anderweitig direkt aufbauen dürfen Sie die bearbeitete Fassung der Materials nicht verbreiten.




Oe Log LizenzKlein.png

Kurzbeschreibung: http://creativecommons.org/licenses/by-nc-nd/4.0/deed.de

Ausführliche Lizenz: http://creativecommons.org/licenses/by-nc-nd/4.0/legalcode

Lizenz ArduBlock

ArduBlock is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ArduBlock is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ArduBlock.
If not, see http://www.gnu.org/licenses/.

Oe Log GNUGPLv3.png

Einleitung

ArduBlock ist eine grafische Entwicklungsumgebung. Sie kann direkt aus der Arduino-Oberfläche aufgerufen werden. Die Programmbefehle liegen als grafische Blöcke vor.
Verschiedene Farben kennzeichnen, um welche Art von Befehlen es sich handelt: So sind z.B. alle Befehle, die mit der Steuerung des Programms zu tun haben, gelb hinterlegt. Befehle, die einen Output erzeugen sind dunkelblau. Befehle, die Werte einlesen (Input) sind hellblau. In weiteren Menüs findest du mathematische oder logische Vergleichsoperatoren. Blöcke für Variablen oder Kommunikation sind ebenfalls in eigenen Menüs zusammengefasst.
Nicht alle Befehle passen aneinander. ArduBlock sorgt dafür, dass nur Programmcode erzeugt wird, der syntaktisch “’richtig”’ ist. Dadurch werden viele Anfängerfehler automatisch vermieden. ArduBlock kümmert sich auch um das sogenannte “’Setup”’. Das heißt, du musst dir erst mal keine Gedanken um die Variablendeklaration oder die Festlegung der einzelnen Pins als Input- oder Outputpins machen. Wenn du ein Skript (ein Programm) aus verschiedenen Blöcken zusammengebaut hast, kannst du es mit dem Button “’Hochladen auf den Arduino”’ übertragen. Aus deinen Blöcken wird Arduino-Code erzeugt, den du im Arduinofenster betrachten und verändern** kannst. Gleichzeitig wird das Programm, in für Menschen völlig unleserliche, Maschinensprache übersetzt. Das nennt man “’kompilieren”’. Beim Kompilieren wird überprüft, ob in deinem Programm grammatikalische Fehler sind. Da sich ArduBlock um die ganze Zeichensetzung kümmert, sollte der Code in der Regel ohne Fehler auf den Arduino übertragen werden.

Diese Blockreferenz dient als Nachschlagewerk und enthält die Beschreibung aller Blöcke die in der letsgoING - Edition des ArduBlock - Programms verwendet werden können.

Anmerkung: Wenn du den Code im Arduinofenster veränderst, dann kannst du ihn über den Button “’Upload”’ auf den Arduino übertragen - die Veränderungen werden allerdings nicht in dein ArduBlock-Programm übernommen!

Oe Tit BeispielfensterArdublock.png

Steuerung

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt Steuerung findet.

Programm

ArduBlock:
Br St Setup AB.png

Arduino:
void setup()
{
//Anweisungen
}
void loop()
{
//Anweisungen
}
void setup() void loop()
Jedes Arduino Programm besteht aus einem Setup-Programmteil und einem Loop-Teil. Der Loop-Teil wird wiederholt, sobald das Ende erreicht wurde.
Die Setup-Funktion wird nur einmal nach dem Start ausgeführt. ArduBlock nimmt einem viel Arbeit ab, indem es die Grundeinstellungen,
Variablendeklarationen und die Konfiguration der seriellen Schnittstelle eigenständig erledigt. Meist reicht der “’Wiederhole Fortlaufend Block”’.
Wenn man selbst Eintragungen im Setup vornehmen möchte, kann dies mit dem “’Programm”’-Block erreicht werden.

wiederhole fortlaufend

ArduBlock:
Br St wiederholeFortlaufend AB.png Arduino:
void loop()
{
//Anweisungen
}
void loop()
Jedes Programm braucht einen loop-Teil. Der Block “’wiederhole fortlaufend”’ stellt den Grundbestandteil jedes Arduino-Programms dar und
ermöglicht das endlose Abarbeiten und Wiederholen der Anweisungen innerhalb des Befehls.

falls

ArduBlock:
Br St falls AB.png
Arduino:
if (a<10) {//Anweisungen}
if()
Mit dem falls-Block kann man eine Bedingung formulieren, die man eindeutig mit ja oder nein beantworten kann. Ist die Falls Bedingung erfüllt,
dann mache das, was im falls-Block steht. Wenn Bedingung nicht erfüllt, dann überspringe diesen Teil. Mit den Operatoren kann man festlegen,
wie die Bedingung ausformuliert wird: Ist etwas gleich, kleiner, größer etc. als etwas anderes. Bei digitalen Variablen kann man die digitale
Variable auch direkt an den falls-Block anhängen: “’falls Linienfolger”’ bedeutet also: falls der Wert des digitalen Linienfolgersensors HIGH ist,
dann mache folgendes, falls der Wert jedoch LOW ist, dann überspringe den Block.

falls / sonst

ArduBlock:
Br St fallsSonst AB.png
Arduino:
if (a<10) {//Anweisungen}
else {//Anweisungen}
if() else
Beim Befehl „falls – sonst“, wird der „Sonst“-Strang ausgeführt, wenn die Bedingung nicht erfüllt ist (entweder – oder – Entscheidung).
Man kann diesen Befehl auch schachteln, also mehrmals ineinander hängen.

solange

ArduBlock:
Br St solange AB.png
Arduino:
while(wert<200)
{//Anweisungen}
while()
Die While-Schleife wird solange durchlaufen, bis der Soll-Wert erreicht ist. Ist das Programm in der Schleife, so werden nur die Befehle in dieser
ausgeführt. Wenn Werte eingelesen werden sollen, muss dies in der While-Schleife passieren. (einzige Ausnahme sind Interrupts!)

wiederhole x-mal

ArduBlock:
Br St wiederholeXmal AB.png
Arduino:
for (int i=0; i<10;i++)
{//Anweisungen}
for()
Mit dem wiederhole x-mal Befehl kann man festlegen, wie oft etwas wiederholt werden soll. Ist das Programm in der Schleife, so werden nur
die Befehle in dieser ausgeführt.

wiederhole variable x-mal

ArduBlock:
Br St wiederholeVarXmal AB.png
Arduino:
for (int i=0; i<10;i++)
{//Anweisungen}
for()
Mit dem wiederhole x-mal Befehl kann man festlegen, wie oft etwas wiederholt werden soll. Im Unterschied zum obigen Block, kann man hier
den Namen der Variablen frei bestimmen.

warte Millisekunden

ArduBlock:
Br St warteMillisekunden AB.png
Arduino:
delay(1000);
delay()
Mit dem Block “’Warte Millisekunden”’ kann man festlegen, wie viele Millisekunden das Programm pausieren soll. Während dieser Zeit können
keine anderen Befehle
ausgeführt werden (Ausnahme: Interrupts)

warte Mikrosekunden

ArduBlock:
Br St warteMikrosekunden AB.png
Arduino:
delayMicroseconds(1000);
delayMicroseconds()
Mit dem Block “’Warte Mikrosekunden”’ kann man festlegen, wie viele Mikrosekunden das Programm pausieren soll. Während dieser Zeit können
keine anderen Befehle ausgeführt werden (Ausnahme: Interrupts)

warte Millis

ArduBlock:
Br St warteMillis AB.png
Arduino:
Variablendeklaration:
unsigned long current;
int time;
Aufruf im loop:
current=millis();
while(current+1000>millis());
{Pausenprogamm}
warte Millis
Die Funktion millis() ermittelt die Anzahl der Millisekunden, die seit dem Start des Arduinos verstrichen ist. Der Block “’warte Millis”’ sollte
verwendet werden, wenn parallel zur Wartezeit andere Aufgaben erledigt werden sollen. Beispiel: Eine LED blinkt im Sekundentakt. Währenddessen
soll ein Sensor abgefragt werden.
Wenn die normale Warte-Funktion verwendet würde, würde der Sensor nur einmal pro Sekunde abgefragt. Mit “’Zeit”’ wird die Wartezeit des
Hauptprogramms festgelegt. In der Millis-Schleife (mache) schreibt man das Pausenprogramm (z.B. die Abfrage des Sensors und was passieren soll,
wenn der Sensor einen Sollwert überschreitet.)

Unterprogramm

ArduBlock:
Br St aufrufUnterprogramm AB.png

Br St unterprogramm AB.png
Arduino:
Aufruf des Unterprogramms im loop:
Unterprogramm();

Unterprogramm
void Unterprogramm(){Anweisungen}

void subroutine()
Mit ArduBlock kann man Unterprogramme aufrufen. Wichtig ist, dass das Unterprogramm den gleichen Namen hat, wie sein Aufruf (auch Groß- und
Kleinschreibung sind zu beachten). Das Unterprogramm ist ein eigenständiges Programm und wird als eigener Block dargestellt.

Unterprogramm

ArduBlock:

Br St aufrufUnterprogrammReturn AB.png

Br St UnterprogrammReturn AB.png
Arduino:
Aufruf des Unterprogramms im loop:
Variable = UnterprogrammReturn();
Unterprogramm
int UnterprogrammReturn()
{
Anweisungen
return lokale Variable;
}

void subroutine()
Mit dem Block UnterprogrammReturn kann man ein Unterprogramm ausführen, das einen Wert an das Hauptprogramm zurückgibt: Das Unterprogramm kann
z.B. etwas berechnen und das Ergebnis dann in eine lokale Variable speichern. Das Hauptprogramm “’sieht”’ diese lokale Variable nicht. Damit das
Hauptprogramm den Wert dieser Variablen in eine eigene Variable schreiben kann, muss sie über den Konnektor “’Rueckgabewert”’ an das Hauptprogramm
zurückgegeben werden.
Da der Wert im Hauptprogramm von einer Variablen übernommen werden muss, kann man die Unterfunktion jetzt nicht mehr einfach aufrufen, sondern
man muss den Aufruf über eine Variablenzuweisung tätigen. Der Rueckgabewert (also das, was in der Unterfunktion berechnet und in eine lokale
Variable abgelegt wurde) wird dann in die aufrufende Variable geschrieben.

interrupt

ArduBlock:

Br St interruptPin2 AB.png

Br St unterprogramm AB.png

Br St interruptSRPin2 AB.png
Arduino:
im setup:
attachInterrupt(0,interruptPin2,CHANGE);
kein Aufruf im loop:
Ereignis wird nicht von loop ausgelöst, sondern durch Änderung an Pin2
Unterprogramm ISR:
void interruptPin2()
{z.B. Hochzählen einer Variablen}
attachInterruptPin2(); 
Ein Interrupt bewirkt eine Unterbrechung des laufenden Programms. Überprüft wird, ob sich an Pin2 oder Pin3 der Wert ändert. Bei jeder Änderung
(CHANGE) wird das Hauptprogramm unterbrochen und das Unterprogramm aufgerufen und ausgeführt. Erst nach dem Abarbeiten des Unterprogramms geht es
im Hauptprogramm weiter. Beim Uno und Leonardo gibt es nur zwei Interrupts. Sie sind fest mit den Pins D2 und D3 gekoppelt. Wenn ein
Inkrementalgeber an Pin2 angeschlossen ist, führt jede Änderung (also sehe Lücke UND sehe keine Lücke) zu einem Aufruf des
Unterprogramms InterruptPin2. Man muss den Block “’Unterprogramm”’ auf die Arbeitsfläche ziehen und in InterruptPin2 umbenennen. In diesem
Unterprogramm kann man z.B. die Interrupts hochzählen.

Hinweis: Ardublock reagiert auf alle Änderungen. Im Arduinoprogramm kann man statt CHANGE auch LOW, RISING oder FALLING als Änderungsparameter
wählen.

Output

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt “’Output”’ findet.

digitalWrite

ArduBlock:
Br Op digitalWrite AB.png

Arduino:
digitalWrite(1,HIGH);
digtalWrite()
Mit dem Befehl digitalWrite wird ein Ausgang gesetzt. Man muss die Nummer des Ports festlegen. Die Konfiguration des Ports als Ausgang übernimmt
ArduBlock. HIGH bedeutet 5V Spannung – LOW bedeutet 0V Spannung. Bei der Motorsteuerung wird mit digitalWrite die Richtung festgelegt.

analogWrite

ArduBlock:
Br Op analogWrite AB.png
Arduino:
analogWrite(1,255);
analogWrite()
Der Arduino kann keine echte analoge Spannung ausgeben. Er taktet, das heißt er schaltet den Ausgang ständig ein- und aus. Man nennt dies
Pulsweitenmodulation (PWM). Der Wert liegt im Bereich zwischen 0 und 255. Der Wert Null entspricht 0 Volt. 255 entspricht 5 Volt. Nur die
Pins 3, 5, 6, 9, 10 und 11 können als analoge Ausgänge geschaltet werden. Bei den Motoren wird mit analogWrite die Geschwindigkeit eingestellt.

LED Bar

ArduBlock:
Br Op ledBar AB.png
Arduino:
Einbinden der Bibliothek:
#include <letsgoING_LEDBar.h>
Funktionsprototyp:
LEDBar LEDBar(6, 7);
Aufruf der Funktionen im loop:
LEDBar.setMapLow(30);
LEDBar.setMapHigh(300);
LEDBar.analogToStack(50, 0);
ledBar
Für die LED bar gibt es eine eigene Bibliothek, die beim Verwenden dieses Blocks automatisch eingebunden wird. Die Datenleitungen der LED Bar
werden in Pin6 und Pin7 eingesteckt: Das weiße Kabel an Pin6 und das gelbe Kabel an Pin 7. In die mittlere Buchse des Blocks wird der einzulesende
Wert angedockt, z.B. analogRead1. Mit “’untere Grenze”’ kann der Wert definiert werden, bei dem der erste Balken leuchten soll.
Mit “’obere Grenze”’ wird der Wert
festgelegt bei dem der rote Balken angezeigt wird.

RGB pin 4/5

ArduBlock:
Br Op rgb AB.png
Arduino:
Einbinden der Bibliothek:
#include <RGBdriver.h>
Definitionsanweisung:
#define CLK 4
#define DIO 5
Funktionsprototyp:
RGBdriver Driver(CLK,DIO);
Aufruf der Funktionen im loop:
Driver.begin();
Driver.SetColor(0,0,0);
Driver.end();
RGB pin4/5
Der Block dient ausschließlich zur Ansteuerung des Seeed Studio Grove - LED Strip Drivers. Die LED-Kette wird durch eine eigene Bibliothek
eingebunden. Die Pins können nicht frei gewählt werden. Man muss die LED-Kette mit den Pins 4/5 verbinden. Für rot, grün und blau können
Werte von 0 bis 255 gewählt werden.

Servo

ArduBlock:
Br Op servo AB.png
Arduino:
Einbinden der Bibliothek:
#include <Servo.h>
Funktionsprototyp:
Servo servo_pin_5;
Aufruf im Setup Block:
servo_pin_5.attach(5);
Aufruf der Funktion im loop:
servo_pin_5.write( 0 );
attach(pin) write(winkel)
Bei Verwendung des Servo-Blocks wird die Servo-Bibliothek eingebunden. Man kann den Pin wählen und die Gradzahl auf die der Servo drehen soll
(0 bis 180 Grad). Bei Verwendung dieses Blocks wird im Setup-Code mit dem Befehl servo.attach(pin) ein Servo-Objekt erzeugt. Im Loop-Teil wird der
Winkel eingestellt. Achtung: Bei Verwendung der Servo-Bibliothek wird unabhängig davon welcher Pin gewählt wurde, die
analogWrite-(PWM)-Funktionalität von Pin9 und Pin10 deaktiviert.

Servo trennen

ArduBlock:
Br Op servoTrennen AB.png
Arduino:
Einbinden der Bibliothek:
#include <Servo.h>
Funktionsprototyp:
Servo servo_pin_5;
Aufruf der Funktion im loop:
servo_pin_5.detach();
servo.detach()
Mit diesem Block wird der Servo vom gewählten Pin getrennt und wird nicht mehr auf Position gehalten. Der Servo braucht jetzt keinen Strom mehr.
Nach dem Trennen kann die analogWrite (PWM)-Funktionalität von Pin9 und Pin10 wieder genutzt werden.

Servo verbinden

ArduBlock:
Br Op ServoVerbinden AB.png
Arduino:
Einbinden der Bibliothek:
#include <Servo.h>
Funktionsprototyp:
Servo servo_pin_5;
Aufruf der Funktion im loop:
servo_pin_5.attach(5);
servo.attach(pin)
Wenn man mit dem detach-Befehl den Servo getrennt hat, muss man ihn mit dem attach(pin)-Befehl neu verbinden.

Input

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt Input findet.

digitalRead

ArduBlock:
Br Ip digitalRead AB.png

Arduino:
digitalRead(1);
digtalRead()
Mit dem Befehl digitalRead wird der Wert eines Ports eingelesen. Man muss die Nummer des Ports festlegen. Die Konfiguration des Ports als Eingang
übernimmt ArduBlock. Mit dem Block “’falls”’ kann man überprüfen, ob an diesem Pin HIGH oder LOW anliegt. Wenn man den Wert wiederverwenden will,
sollte man ihn an eine digitale Variable übergeben.

analogRead

ArduBlock:
Br Ip analogRead AB.png
Arduino:
analogRead(1)
analogRead()
Analoge Eingänge werden vom Arduino mit 10 bit aufgelöst, das entspricht einem Bereich von 0 bis 1023. Das Eingangssignal liegt zwischen 0 Volt
(das entspricht dem Wert 0) und 5 Volt (das entspricht dem Wert 1023). Man muss angeben, an welchem Port die Spannung eingelesen werden soll.
Wenn ich mit dem “’falls-Block”’ den Wahrheitsgehalt abfragen möchte, muss ich “’analogRead”’ in einen “’logischen Operator Block”’ einbauen
und mit einem anderen Wert vergleichen. Wenn man den Wert wiederverwenden will, sollte man ihn an eine analoge Variable übergeben. Beim Uno
werden die Ports 0 bis 5 als analoge Eingänge verwendet. (sie werden als A0 bis A5 bezeichnet)

Zustand von LGI-Button

ArduBlock:
Br Ip ZustandLGIButto1 AB.png
Arduino:
Einbindung der library und Aufruf der AnalogButton-Instanz
#include <LGI_AnalogButton.h>
AnalogButton Button1(1);
variable = Button1.getButton() ;
Wert von LGI-Button
Auf dem LGI-Shield befinden sich neben dem Reset-Button zwei Buttons, die beide über Spannungsteiler mit AnalogPin3 verbunden sind. Liegt der
eingelesene Wert bei ca. 511, dann ist Button1 gedrückt. Liegt der Wert bei ca. 341 dann ist Button2 gedrückt. Bei einem Wert um 614 sind beide
Buttons gleichzeitig gedrückt. Der Block rechnet den Analogwert in einen Digitalwert um.

Zustand von LGI-Button entprellt

ArduBlock:
Br Ip ZustandLGIButton1Entprellt AB.png
Arduino:
Einbindung der library und Aufruf der AnalogButton-Instanz
#include <LGI_AnalogButton.h>
AnalogButton Button1(1);
var = Button1.getButtonDebounced() ;
Zustand von LGI-Button entprellt
Vgl. Erläuterungen bei “’Wert von LGI-Button”’. Bei diesem Block sind die Taster entprellt (debounced). Mechanische Kontakte neigen dazu, sich
nach dem Schließen noch mehrmals zu öffnen und wieder zu schließen. Sie federn. Man weiß dann nach einem Tastendruck nicht, ob die Taste 1 Mal,
2 Mal oder x-Mal gedrückt wurde. Um diese Störungen zu beseitigen, wird der Taster entprellt. Das bedeutet, dass nach dem Drücken das Programm
kurz wartet und erst nach dieser Pause erneut testet, ob der Taster gedrückt wurde.

LGI-Schalter

ArduBlock:
Br Ip ZustandLGISchalter1 AB.png
Arduino:
Einbindung der library und Aufruf der AnalogButton-Instanz
#include <LGI_AnalogButton.h>
AnalogButton Button1(1);
var = Button1.getSwitchDebounced() ;
LGI-Schalter
Ein Taster kann auch als Schalter verwendet werden. Mit Hilfe der LGI_AnalogButton-library wird der Zustand des Schalters bei jedem Tastendruck
geändert: Einmal gedrückt bedeutet “’eingeschaltet”’, beim zweiten Druck wechselt der Zustand in “’ausgeschaltet”’.

Q-touch Button

ArduBlock:
Br Ip setupQtouchButton AB.png

Br Ip QtouchButtonOffset AB.png

Br Ip QtouchButtonGedrueckt AB.png

Arduino:
#include <LGI_QTouch.h>
QTouchButton Button1(1,2);
void setup()
{
Button1.init();
}
void loop()
{
offsetButton1 = Button1.getOffset() ;
var = Button1.isTouched() ;
}
Q-touch Button
Mit dem LGI-Touchsensor können auf einfache und sehr günstige Art bis zu 6 Touchsensoren über die 6 analogen Pins gewonnen werden (mit Ardublock
nur 3). Die Touchsensoren sind kapazitive Sensoren. Durch Berührung verändert sich die Kapazität des Sensors. Die Touch-Fläche kannst
du als eine Platte eines Plattenkondensators ansehen. Die Library arbeitet mit Lade- bzw. Entladespannung dieses Kondensators.
Wenn du mit dem Cursor über die Blöcke fährst, verwandelt sich der Pfeil in eine Hand. In der Mitte des Blocks erscheint ein kleiner
“’Drop-Down-Pfeil”’. Mit dem kannst du aussuchen, ob du Button1, Button2 oder Button3 programmierst.


Mit dem Block “’Setup für Q-Touch-Button”’ werden zwei analoge Pins bestimmt. Bevor du die Q-Toch-Buttons verwenden kannst, musst du im Setup festlegen,
an welchen Pin dein Q-Touch Button hängt. Du brauchst einen weiteren Pin für die Entladung des eingebauten Kondensators. Du kannst mehrere Q-Touch-Sensoren jedoch miteinander koppeln: Q-Touchsensor1 hängt an A0 und verwendet A1 als Partner-Pin. Q-Touchsensor2 hängt an A1 und nimmt A2 als Partner-Pin und Q-Touchsensor3 nimmt A2 und verwendet A0 als Partner-Pin. So kann ich mit nur 3 Pins 3 Q-Touch-Sensoren einsetzen.

Mit dem Block “’Offset von Q-Touch-Button”’ kannst du dir den Offset eines Buttons anzeigen lassen.

Mit dem Block “’Q-Touch-Button1 gedrueckt?”’ kannst du dir anzeigen lassen, ob der Button gedrückt wurde oder nicht: 1 bedeutet berührt, 0 bedeutet nicht berührt.

Q-touch Slider

ArduBlock:
Br Ip QtouchSliderSetup AB.png

Br Ip OffsetQtouchSlider AB.png

Br Ip WertQtouchSlider AB.png

Arduino:
#include <LGI_QTouch.h>
QTouchSlider Slider(2,3,4);
void setup()
{
Slider.init();
}
void loop()
{
varOffset = Slider.getOffset(1);
var = Slider.getTouchPosition();
}
Q-touch Slider
Der Q-Touch-Slider liefert Ergebnisse vergleichbar eines Schiebepotentiometers. Der Q-Touch-Slider arbeitet aber nicht wie ein Widerstand, sondern
ebenfalls kapazitiv.

Er arbeitet nach dem gleichen Prinzip wie der Q-Touch-Sensor. Der Slider gibt jedoch keine boolschen Werte [0,1] zurück, sondern Werte zwischen
0 und 100. Für den Q-Touch-Slider brauchst du 3 Pins, die du über den Q-Touch-Slider Setup Block bekannt machen musst. Die drei Offset-Werte
kannst du dir über die Blöcke “’Offset1 (bis3) von Q-Touch-Slider”’ ausgeben lassen. Damit der Slider den gesamten Bereich zwischen Null und 100
zurückgeben kann, musst du ihn zu Beginn “’eichen”’, das bedeutet nach dem Start einmal über den gesamten Sensor streichen.

input pullup

ArduBlock:
Br Ip input pullup AB.png
Arduino:
pinMode( 1 , INPUT);
digitalWrite(1, HIGH);
input pullup
Wenn man einen Pin als Eingang festlegt, dann sollte man ihn mit einem hochohmigen Widerstand entweder an Ground oder an 5V binden. Damit hat der
Eingang einen definierten Zustand und flattert nicht herum. Wenn du einen Taster ohne einen externen Widerstand einsetzen möchtest, kannst du mit
dem Block “’input pullup”’ den Pin über einen internen Widerstand an den HIGH-Pegel binden.

Linienfolger-Sensor

ArduBlock:
Br Ip linienfolger AB.png
Arduino:
digitalRead(1)
Linienfolge-Sensor
Der Linienfolge-Sensor ist ein digitaler Sensor: das bedeutet er zeigt entweder HIGH oder LOW an. HIGH bedeutet “’schwarz”’. Man kann stattdessen
einen digitalRead Block verwenden.

Distanzsensor

ArduBlock:
Br Ip Distanzsensor AB.png
Arduino:
analogRead(1)
Distanzsensor
Der Distanzsensor ist ein analoger Sensor: das bedeutet er zeigt Werte von Null bis 1023. Er arbeitet nach dem Triangulationsprinzip. Die
eingelesenen Werte sind nicht linear. Im Nahbereich unter 5 cm ist er blind, d.h. dort werden keine korrekten Werte angezeigt. Man kann
zum Einlesen alternativ auch den Block analogRead verwenden.

PIR

ArduBlock:
Br Ip pirSensor AB.png
Arduino:
digitalRead(1)
Digit. Infrarot Bewegungsmelder
Ein Bewegungsmelder ist ein elektronischer Sensor, der Bewegungen in seiner näheren Umgebung erkennt und dadurch als elektrischer Schalter
arbeiten kann. Der PIR-Sensor (englisch passive infrared) ist der am häufigsten eingesetzte Typ von Bewegungsmeldern. Der Sensor erkennt dabei
die abgestrahlte Wärme der vorbeigehenden Menschen. Bewegt sich die Wärmequelle, so löst der Sensor aus. Der Sensor hat zwei Stellschrauben:
Mit der linken wird die Haltezeit (max 25s, min 1s) eingestellt. Mit der rechten der Abstand auf den der Sensor reagiert: (max 6m, min 5cm)

Schiebepotentionmeter

ArduBlock:
Br Ip schiebepoti AB.png
Arduino:
var=analogRead(1);
Schiebepotentionmeter
Ein Potentiometer (kurz Poti, nach neuer deutscher Rechtschreibung auch Potenziometer) ist ein elektrischer Widerstand, dessen Widerstandswerte
mechanisch (durch Drehen oder Verschieben) veränderbar sind. Es hat mindestens zwei Anschlüsse und wird hauptsächlich zum veränderlichen Teilen von
Spannungen eingesetzt.

Touchsensor

ArduBlock:
Br Ip Touchsensor AB.png
Arduino:
digitalRead(1)
Touchsensor
Der Touch-Sensor reagiert auf die Änderung seiner Umgebung (Kapazität der Umgebung). Er erkennt ob sich z.B. ein Finger oder nur Luft um ihn herum
befindet. Berührt man die Touch-Fläche so löst der Sensor aus.

Taster / Schalter

ArduBlock:
Br Ip Taster AB.png
Arduino:
digitalRead(1)
Taster / Schalter
Ein Taster ist ein digitaler Sensor. Beim Einlesen eines Tasters werden häufig mehrere Signale mit HIGH und LOW eingelesen. Dieses Verhalten wird
auch als Prellen oder Bouncing bezeichnet. Um für jeden Tastendruck genau ein Signal zu erhalten, muss man den Taster entweder hardwareseitig oder
durch ein kleines Zusatzprogramm entprellen.

Lautstärkesensor

ArduBlock:
Br Ip Lautstaerkesensor AB.png
Arduino:
analogRead(1)
Lautstärkesensor
Der Grove Loudness-Sensor misst die Lautstärke der Umgebungsgeräusche. Der Sensor besteht aus einem eingebauten Mikrophon und einem Verstärker.
Um unnötige Signalstörungen zu vermeiden, wird das Eingangssignal gefiltert. Durch Drehen der kleinen Potentiometer-Schraube kann man die
Ausgangsverstärkung eingestellen.

LDR

ArduBlock:
Br Ip LdrSensor AB.png
Arduino:
analogRead(1)
LDR
Ein Fotowiderstand (englisch Light Dependent Resistor, LDR) ist ein lichtabhängiger Widerstand aus einer amorphen Halbleiter-Schicht. Je höher der
Lichteinfall, desto kleiner wird - aufgrund des inneren fotoelektrischen Effekts - sein elektrischer Widerstand. Fotowiderstände eignen sich,
aufgrund ihrer hohen Empfindlichkeit, sehr gut um die Helligkeit zu messen. Sie reagieren jedoch sehr langsam (Bereich 1 ms bis einige Sekunden).

Ultraschallsensor

ArduBlock:
Br Ip Ultraschallsensor AB.png
Arduino:
Unterprogr. Ultraschall_Sensor:
Puls aussenden
Puls empfangen
Abstand berechnen
cm-Wert zurückgeben
im loop-Teil:
Abstandswert in cm
Ultraschallsensor
Weil der Ultraschallsensor ein getaktetes Signal ausgibt, muss er an einen digitalen Pin eingesteckt werden. Der Ultraschallsensor pulst Signale
und misst die Zeit, bis die ausgesendeten Ultraschallsignale zurückkommen. Aus der gemessenen Zeit wird der Abstand berechnet. Das Pulsen,
Empfangen und Berechnen wird in die Unterfunktion “’Ultraschall_Sensor”’ ausgelagert. Mit einem normalen analogRead-Befehl kann der
Ultraschall-Sensor nicht ausgelesen werden.

Bluetooth

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt “’Bluetooth”’ findet. Die braunen Blöcke sind eigentlich Blöcke für die serielle Kommunikation. Statt dem Serial Monitor wird hier das Smartphone oder das Tablet als Monitor eingesetzt. Die roten Blöcke sind Werte oder Zustände, die über das Tablet an den Arduino via Bluetooth gesendet werden.

Setup BluetoothBee beim Cherokey-Fahrzeug

ArduBlock:
BluetoothBee.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote;
void serialEvent(){
while(Serial.available())
{Remote.readBluetooth();}
Remote.getData();}
void setup()
{Remote.BTbee_begin(9600);}
Setup BluetoothBee
Da es zwei unterschiedliche Bluetooth-Module gibt, muss man im ArduBlock-Programm angeben, mit welchem Bluetooth-Modul man arbeitet. Das passiert
im Setup-Block. Die Bluetooth-Befehle für den Cherokey brauchen den Block “’Setup BluetoothBee”’. (HINWEIS: beim Bluetooth-Modul der letsgoING-
Fahrzeuge und bei der LED-Lampe heißt der Block “’Setup BluetoothSerial”’)

Setup BluetoothBee Monitor beim Cherokey-Fahrzeug

ArduBlock:
BTBeeMonitor.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote;
void setup()
{Remote.BTbee_begin(9600);}
Setup BluetoothBee 
In der App gibt es im Auswahlmenü das Fahrzeug, die Lampe und den Monitor. Wenn du Befehle über den Monitor deines Smartphones oder Tablets an
das Cherokeyfahrzeug senden möchtest, verwendest du diesen Block.

Setup BluetoothSerial beim letsgoING-Fahrzeug und bei der LED-Lampe

ArduBlock:
BluetoothSerial.png Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote;
String btName = “’BTSeralLGI”’;
String btCode=“’1234”’;
void serialEvent(){
while(Serial.available())
{Remote.readBluetooth();}
Remote.getData();}
void setup()
{
Remote.BTserial_setup(btName,btCode);
}
Setup BluetoothSerial
Da es zwei unterschiedliche Bluetooth-Module gibt, muss man im ArduBlock-Programm angeben, mit welchem Bluetooth-Modul man arbeitet. Das passiert
im Setup-Block. Die Bluetooth-Befehle für das letsgoING-Fahrzeug und für die LED-Lampe benötigen den Block “’Setup BluetoothSerial”’.
(HINWEIS: beim Bluetooth-Modul für den Cherokey heißt der Block “’Setup BluetoothBee”’) In der Variablen “’btName”’ steht der Name der
Bluetooth-Verbindung

Setup BluetoothSerial Monitor beim letsgoING-Fahrzeug und bei der LED-Lampe

ArduBlock:
BTSerialMonitor.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote;
void setup()
{Remote.BTserial_begin(9600);}
Setup BluetoothBee
Man kann nicht nur über den Serial Monitor mit dem Arduino Daten austauschen, sondern auch über einen Bildschirm vom Smartphone bzw. Tablet.
In der LetsgoING-App gibt es drei Bilder: das Fahrzeug, die Lampe und den Monitor. Wenn du Befehle über den Monitor deines Smartphones / Tablets
an das letsgoING-Fahrzeug oder an die LED-Lampe senden möchtest, verwendest du diesen Block. Achtung: Zum Hochladen deines Programms muss das
Kabel zwischen BT-Modul und Arduino ausgesteckt sein. Nach dem Hochladen muss das Bluetooth-Modul einen Reset ausführen! (Strom komplett weg -
also auch das USB-Kabel entfernen)

Setup Bluetooth Hardware Serial

ArduBlock:
Br Bt SetupBluetoothHWSerial AB.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote;
void setup()
{Remote.BTserial_begin(9600);}


Setup Bluetooth HWSerial
Jedes Bluetooth-Modul braucht einen Setup-Block. Mikrocontroller-Boards wie der Arudino-UNO haben eine eingebaute serielle Hardware-Schnittstelle
am Pin0 und Pin1. Wenn du dein Bluetooth-Modul über diese Schnittstelle betreibst, musst du diesen Block ins Setup einbauen. Beim ArduRover
und beim Cherokey wird standardmäßig diese Schnittstelle verwendet.

Setup Bluetooth Software Serial

ArduBlock:
Br Bt SetupBluetoothSoftSerial AB.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote(2,3);
void setup()
{Remote.BTsoftSerial_begin(9600);}
Setup Bluetooth SoftSerial 
Wenn du dein Bluetooth-Modul nicht über die Hardware-Serial-Schnittstelle anschließt, dann musst du diesen Setup-Block im Programm-Setup verwenden.
Der Attiny hat keine Hardware-Serial-Schnittstelle. Beim Einsatz vom Attiny brauchst du immer diesen Setup-Block.

Grove-Modul: Starten und Warten bis verbunden über Hardware Serial

ArduBlock:
Br Bt BTGroveStartenundWartenBisVerbundenHWSerial AB.png Arduino:
#include <letsgoING_Ardudroid.h>
void setup()
{
delay(2000);
Remote.printMonitor(“\r\n+INQ=1\r\n”);
//Grove BTmodul gibt Verbindungszustand zurück (0-4)
while(Remote.readConState()!= 4);
}
BT Grove Starten und WartenBisVerbunden HWSerial
Die Grove-Module brauchen zwingend einen zweiten Setup-Block. Wenn das BT-Grove-Modul an Pin0 und Pin1 angeschlossen ist, dann braucht es diesen
Block. Der Vorteil beim Grove-Modul ist, dass hier kontrolliert wird, ob die Verbindung zustande gekommen ist. Das Modul gibt den Wert 4 zurück,
wenn die Verbindung steht.

Grove-Modul: Starten und Warten bis verbunden über SoftSerial

ArduBlock:
Br Bt BTGroveStartenundWartenBisVerbundenSoftSerial AB.png Arduino:
#include <letsgoING_Ardudroid.h>
void setup()
{
delay(2000);
Remote.printSoftMonitor(“\r\n+INQ=1\r\n”);
//Grove BTmodul gibt Verbindungszustand zurück (0-4)
while(Remote.readSoftConState()!= 4);
}
BT Grove Starten und WartenBisVerbunden SoftSerial
Die Grove-Module brauchen zwingend einen zweiten Setup-Block. Wenn das BT-Grove-Modul eine SoftSerial-Verbindung nutzt, dann braucht es diesen
Block. Der Attiny nutzt immer eine SoftSerial-Schnittstelle! Der Vorteil beim Grove-Modul ist, dass hier kontrolliert wird, ob die Verbindung
zustande gekommen ist. Das Modul gibt den Wert 4 zurück, wenn die Verbindung steht.

Werte und Zustände für die Fernbedienung auslesen (Fahrzeug oder LEDLampe): HWSerial

ArduBlock:
Br Bt BTreadHWSerialRemote AB.png Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote;
void setup()
{Remote.BTserial_begin(9600);}
void loop()
{Remote.readRemote();}
Remote.readRemote();
Diesen Block brauchst du, wenn du für die Fernbedienung deines Fahrzeugs oder für die Fernbedienung deiner Lampe die Zustände und Werte von der
App über Pin0 und Pin1 auslesen möchtest. Der Block braucht im Setup den Setup-Bluetooth-HWSerial-Block. Der Block muss in jeder Loop ausgelesen
werden oder kann auch im SerialEvent-Block ausgelesen werden.

Werte und Zustände für die Fernbedienung auslesen (Fahrzeug oder LEDLampe): SoftSerial

ArduBlock:
Br Bt BTreadSoftSerialRemote AB.png Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote(2,3);
void setup()
{Remote.BTsoftserial_begin(9600);}
void loop()
{Remote.readSoftRemote();}
Remote.readRemote();
Diesen Block brauchst du, wenn du für die Fernbedienung deines Fahrzeugs oder für die Fernbedienung deiner Lampe die Zustände und Werte von der
App über SoftSerial auslesen möchtest. Der Block braucht im Setup den Setup-Bluetooth-SoftSerial-Block.

Serial Monitor auslesen: Hardware Serial

ArduBlock:
Br Bt BTreadHWSerialMonitor AB.png Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote();
char Name_der_ZeichenVariablen = ’ ’ ;
void setup()
{Remote.BTserial_begin(9600);}
void loop()
{Name_der_ZeichenVariablen =
Remote.readMonitor();}
BT read HWSerial Monitor
Wenn du in die Kommandozeile deiner Monitor-App einen Befehl schreibst, wird der via Bluetooth an den Arduino übertragen. Mit diesem Block wird
ein AscII-Zeichen ausgelesen und dann der Speicher wieder geleert. Wir verwenden den Block gemeinsam mit dem ”Setze Zeichen-Variable Block”.
Das BT-Modul ist an Pin0 und Pin1 vom Arduino angeschlossen.

Serial Monitor auslesen: Software Serial

ArduBlock:
Br Bt BTreadSoftSerialMonitor AB.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote(2,3);
char Name_der_ZeichenVariablen = ’ ’ ;
void setup()
{Remote.BTsoftSerial_begin(9600);}
void loop()
{Name_der_ZeichenVariablen = Remote.readSoftMonitor();}
BT read SoftSerial Monitor
Wenn du in die Kommandozeile deiner Monitor-App einen Befehl schreibst, wird der via Bluetooth an den Arduino übertragen. Mit diesem Block wird
ein AscII-Zeichen ausgelesen und dann der Speicher wieder geleert. Wir verwenden den Block gemeinsam mit dem Setze Zeichen-Variable-Block.
Das BT-Modul ist über SoftSerial mit dem Arduino verbunden.

Texte und Werte auf dem Smartphone ausgeben: Hardware Serial

ArduBlock:
Br Bt BTprintHWSerialMonitor AB.png Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote();
void setup()
{Remote.BTserial_begin(9600);}
void loop()
{Remote.printMonitor(”message”;
Remote.printMonitor(”\n”);}
BT print HWSerial Monitor
Du nimmst diesen Block, wenn du in der Monitor-App Werte oder Texte ausgeben möchtest. Du überschreibst einfach ”message” mit einem Text. Mit
Hilfe eines passenden Verbinde-Blocks aus dem Menü ”Kommunikation” kannst du dann noch die passenden Variable anhängen. Dieser Block wird
über die Hardware-Schnittstelle (Pin0 und Pin1) verwendet.

Texte und Werte auf dem Smartphone ausgeben: Software Serial

ArduBlock:
Br Bt BTprintSoftSerialMonitor AB.png

Arduino:
#include <letsgoING_Ardudroid.h>
Ardudroid Remote(2,3);
void setup()
{Remote.BTsoftSerial_begin(9600);}
void loop()
{Remote.printSoftMonitor(”message”;
Remote.printSoftMonitor(”\n”);}
BT print SoftSerial Monitor
Du nimmst diesen Block, wenn du in der Monitor-App Werte oder Texte ausgeben möchtest. Du überschreibst einfach ”message” mit einem Text. Mit
Hilfe eines passenden Verbinde-Blocks aus dem Menü ”Kommunikation” kannst du dann noch die passenden Variable anhängen. Dieser Block
wird über die Software-Schnittstelle verwendet.

Bluetooth RGB Farben

ArduBlock:
Br Bt btRot AB.png
Arduino:
Remote.getRed()
Remote.getGreen()
Remote.getBlue()
BT rot
An den “’RGB Pin 4/5”’ können die sechseckigen Blöcke “’BT rot”’, “’BT gruen”’ und “’BT blau”’ angehängt werden. Damit werden für die LED-Kette
die auf dem Android-Gerät eingestellten Werte für die Farben übernommen.(Im Setup braucht man den Block “’Setup BluetoothSerial”’)

BT-Schalter

ArduBlock:
Br Bt btLedSchalter AB.png
Arduino:
if (Remote.getLedSwitch())
BT LED Schalter
Der Block “’BT LED Schalter”’ kann in einen falls/sonst Block überprüfen, ob am Smartphone oder Tablet der Schalter “’LED An”’ angeklickt wurde.
Man kann damit z.B. die LED-Kette ausschalten. (Im Setup braucht man den Block “’Setup BluetoothSerial”’)

Bluetooth Richtung und Geschwindigkeit

ArduBlock:
Br Bt btGeschwindigkeit AB.png

Br Bt btRichtung AB.png
Arduino:
Remote.getDirection()
Remote.getSpeed()
BT Geschwindigkeit
Über die Blöcke “’BT Richtung”’ und “’BT Geschwindigkeit”’ kann man im “’fahre Kurve Block”’ festlegen, dass die vom Android-Gerät gesendeten
Werte für Richtung (Rotation) und Geschwindigkeit (Translation) aufs Fahrzeug übertragen werden. (Im Setup braucht man beim Cherokey den Block
“’Setup BluetoothBee”’ - beim letsgoING-Fahrzeug braucht man den Block “’Setup BluetoothSerial”’)

Bluetooth Button

ArduBlock:
Br Bt btButton AB.png
Arduino:
if (Remote.getButton(1))
BT Button
Wenn man den “’BT Button”’ Block auf die ArduBlock-Fläche zieht, kann man über das kleine Pfeilchen auf dem Block auch den “’BT Button2”’ sowie
die Blöcke “’BT Switch1”’ und “’BT Switch2”’ auswählen. Über falls/sonst kann man überprüfen, ob diese Schalter / Tasten auf dem Smartphone
gedrückt wurden und Anweisungen für die Fälle programmieren. (Im Setup braucht man beim Cherokey den Block “’Setup BluetoothBee”’ - beim
letsgoING-Fahrzeug braucht man den Block “’Setup BluetoothSerial”’)

Bluetooth Event

ArduBlock:
BtEvent.png Arduino:
if (Remote.getEvent(1))
BT Event
Wenn man den “’BT Event1”’ Block auf die ArduBlock-Fläche zieht, kann man über das kleine Pfeilchen auf dem Block auch den “’BT Event2”’ bis
“’BT Event6”’ auswählen. Über falls/sonst kann man abhängig von den Events Anweisungen programmieren. Die Android-Anwendung zur Nutzung der
Events gibt es im Augenblick noch nicht.

Bluetooth Event

ArduBlock:
BTDaten.png
BT Daten verfuegbar
Über den Serial Monitor des Tablets / Smartphones kann man Daten via Bluetooth mit dem Arduino austauschen.
a) falls BT Daten verfuegbar > 0
b) Setze Char-variable auf BT serial read
c) falls Char-variable == bestimmer Buchstabe
d) dann BT serial println : nachricht...

Logische Vergleichsoperatoren

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt logische Operatoren findet.

analoge Vergleichsoperatoren

ArduBlock:
Br Lo groesser AB.png

Arduino:
if (var > 10)
analoge Vergleichsoperatoren
Es gibt 6 Vergleichsoperatoren für analoge Werte. Erkennbar sind sie an den sechseckigen Platzhaltern. Man kann mit ihnen Variable oder Konstante
miteinander vergleichen. Z.B. ist eine Variable größer als, kleiner als, größer oder gleich, kleiner oder gleich, gleich oder nicht gleich einem
anderen Wert.

digitale Vergleichsoperatoren

ArduBlock:
Br Lo digitalGleich AB.png

Arduino:
if (var == HIGH)
digitale Vergleichsoperatoren
Mit den digitalen Vergleichsoperatoren kann man überprüfen, ob ein Wert TRUE oder FALSE ist. Erkennbar sind die digitalen Vergleichsoperatoren
an den runden Platzhaltern.

Vergleichsoperatoren für Zeichen

ArduBlock:
CharGleich.png

Arduino:
if (var == ’A’)
Vergleichsoperatoren für Zeichen
Mit den beiden Vergleichsoperatoren für Zeichen kann man überprüfen, ob zwei Zeichen identisch oder nicht identisch sind. Man erkennt die
Vergleichsoperatoren für Zeichen an den Platzhaltern “’Rechteck mit Flügeln”’.

logisches und

ArduBlock:
Br Lo und AB.png
Arduino:
if (var == HIGH && i > 10)
logisches und
Mit dem “’logischen und”’ kann man überprüfen, ob zwei Vergleiche gleichzeitig wahr sind. Das Resultat ist TRUE, wenn beide Werte TRUE sind.

logisches oder

ArduBlock:
Br Lo oder AB.png
Arduino:
if (var == HIGH || i > 10)
logisches oder
Mit dem “’logischen oder”’ kann man überprüfen, ob mindestens einer von zwei durchgeführten Vergleichen wahr ist. Das Resultat ist TRUE, wenn
mindestens ein Wert TRUE ist.

Verneinung

ArduBlock:
Br Lo nicht AB.png
Arduino:
if (!var == HIGH)
logisches nicht
Mit dem “’logischen nicht”’ wird überprüft, ob ein Vergleich falsch ergibt. Das Resultat ist TRUE, wenn der Vergleich FALSE ergibt.

Mathematische Vergleichsoperatoren

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt mathematische Operatoren findet.

Arithmetik

ArduBlock:
Br Mo plus AB.png

Arduino:
y = y +5;
a = 6 % 4; //Modulo mit Ergebnis 2
Berechnungen
Mit den arithmetischen Blöcken kann man Werte addieren, subtrahieren, multiplizieren, dividieren und den Rest einer Division ermitteln (Modulo)

Betrag

ArduBlock:
Br Mo betrag AB.png

Arduino:
int a = -50;
int b = abs(a); //Ergebnis b=50
abs()
Mit diesem Block kann man den Absolutwert (Betrag) ermitteln.

Potenz

ArduBlock:
Br Lo potenz AB.png

Arduino:
int y = pow(x,3); //y = x hoch 3
pow(Zahl, Exponent)
Mit diesem Block kann man potenzieren.

Wurzel

ArduBlock:
Br Mo wurzel AB.png

Arduino:
int y = sqrt(x); // y = Wurzel von x
sqrt(x) sin(rad) cos(rad) tan(rad)
Mit diesem Blöcken kann man die Wurzel / Sinus / Cosinus oder Tangens einer übergebenen Zahl berechnen.

Zufallszahl

ArduBlock:
Br Mo zufallszahl AB.png

Arduino:
var = random( 1024 ) ;
// Zufallszahl zwischen 0 und 1023
random(x)
Mit diesem Block kann man eine Zufallszahl zwischen Null und der angegebenen Zahl generieren.

Minimum Maximum

ArduBlock:
Br Mo minimum AB.png

Arduino:
wert = min(x,y); // Ermittelt Minimum der beiden Werte
min(x,y)
Ermittelt welcher der beiden Werte kleiner ist. max(x,y); Ermittelt welcher der beiden Werte größer ist.

zuordnen 8bit

ArduBlock:
Br Mo zuordnen AB.png

Arduino:
map(sensorwert,0,1023,0,255); // Konvertiert den Sensorwert
map(fromLow, fromHigh, toLow, toHiGH)
Mit diesem Block kann man den 10-bit-Wertebereich (von 0 bis 1023) auf den 8-bit-Wertebereich (von Null bis 255) konvertieren. Z.B. der vom Sensor
eingelesene 1023-Wert soll die Max-Geschwindigkeit ergeben, also 255.

zuordnen allgemein

ArduBlock:
Br Mo zurordnen2 AB.png

Arduino:
map(sensorwert,0,1023,0,255); // Konvertiert den Sensorwert
map(fromLow, fromHigh, toLow, toHiGH)
Mit diesem Block kann man einen Wertebereich in einen anderen Wertebereich konvertieren. Im Gegensatz zum obigen Block, kann man hier alle Werte
frei wählen. Man kann damit auch einen Bereich invertieren: Also den Betreich von 0 bis 1023 zum Bereich 1023 bis 0.

einschränken

ArduBlock:
Br Mo einschraenken AB.png

Arduino:
contrain(Zahl,Minimum,Maximum); // Schränkt den Bereich ein
constrain(x,a,b)
Mit diesem Block kann ein Wert so festgelegt werden, dass er in einem Sollbereich liegt.

Variablen/Konstanten

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt “’Variablen/Konstanten”’ findet.

Werte, die im Programm mehrfach gebraucht werden, kann man in eine Variable speichern. Der Variablenname sollte möglichst sprechend sein. Der Wert einer Variablen kann sich im Programm laufend ändern. Eine Variable hat immer auch einen Datentyp, der den Wertebereich festlegt. Bei ArduBlock wird der Datentyp einer Variablen durch die Wahl der Blöcke festgelegt (Sechseck = integer-Werte, Kreis=boolsche Werte und Rechteck mit Flügeln=character Werte). Variablen, die sich im Programm nicht ändern, nennt man Konstanten. ArduBlock hat keinen eigenen Block für die Definition von Konstanten. Man verwendet statt dessen die Blöcke “’Setze Variable”’. In Kombination mit den Blöcken aus dem Menü “’Math. Operatoren”’ können Zuweisungen getätigt werden. (Im Arduino-Code erfolgt dies mit dem einfachen Gleichheitszeichen)

Setze Digitale Variable

ArduBlock:
Br Vk setzeDigitaleVar AB.png

Arduino:
im Deklarationsblock
bool Linienfolgesensor=false ;
in der loop
Linienfolgesensor = HIGH;
bool var=HIGH
Mit dem Block “’Setze Digitale Variable”’ kann man einen Variablennamen wählen und den Variablenwert festlegen (HIGH oder LOW). Die Variablen-
deklaration tätigt ArduBlock selbstständig.Man kann den Wert direkt übergeben, ihn berechnen lassen oder über einen digitalen Sensor beziehen.

Setze Digitale Variable invertiert

ArduBlock:
Br Vk setzeDigitaleVar2 AB.png

Arduino:
im Deklarationsblock:
bool DigitalWert= false ;
in der loop
DigitalWert = !( DigitalWert ) ;
bool var=!var
Hier wird der Wert der Variablen “’DigitalWert”’ invertiert.

Setze Analoge Variable

ArduBlock:
Br Vk setzeAnalogeVar AB.png

Arduino:
im Setup:
int Distanzsensor = 0;
in der loop
Distanzsensor = 100;
 var=10
Mit dem Block “’Setze Analoge Variable”’ kann man einen Variablennamen wählen und den Variablenwert festlegen (eine Zahl). Die Variablendeklaration
tätigt ArduBlock selbstständig. Man kann den Wert direkt übergeben, ihn berechnen lassen oder über einen analogen Sensor beziehen.

Setze Analoge Variable Zähler

ArduBlock:
Br Vk setzeAnalogeVar3 AB.png

Arduino:
im Deklarationsblock:
int i = 0;
in der loop
i = i+1;
 var=var+1
Mit diesen Blöcken wird die Variable “’Zähler”’ um 1 hoch gezählt. Über diesen Block werden Änderungen einer Variablen getätigt.


Setze Analoge Variable Sensor

ArduBlock:
SetzeAnalogeVar2.png

Arduino:
im Deklarationsblock:
int Distanzsensor = 0;
in der loop
Distanzsensor = analogRead(0);


 var=analogRead()
Mit dem Blöcken wird der Wert des Sensors, der am Pin A0 liegt, in die Varaible Entfernung geschrieben.

Setze Zeichen Variable

ArduBlock:
Br Vk setzeZeichenVar AB.png

Arduino:
im Deklarationsblock:
char ZeichenVariablen = ’ ’ ;
in der loop
ZeichenVariable = ’A’;
Zeichen=’A’
Mit dem Block “’Setze Zeichen Variable”’ kann man einen Variablennamen wählen und den Variablenwert festlegen (ein Zeichen). Die Variablen-
deklaration tätigt ArduBlock selbstständig.

Setze Zeichen Variable

ArduBlock:
Br Vk setzeZeichenVar2 AB.png

Arduino:
im Deklarationsblock:
char Zeichen = ’ ’;
in der loop
Zeichen = Serial.read();
Zeichen=Serial.read()
Mit dem Block “’Setze Zeichen Variable”’ kann man einen Variablennamen wählen und das über Serial.read eingelesene Zeichen in diese Variable
schreiben. Die Variablendeklaration tätigt ArduBlock selbstständig.

Name der analogen Variablen

ArduBlock:
Br Vk analogeVar AB.png

Br Vk analogeVarBsp AB.png

var
Diesen Block braucht man, wenn man den Wert einer schon gesetzten analogen Variablen abfragen möchte.
Wenn man mit einer Steuerfunktion (if, if else, while, for) überprüfen möchte, ob eine Bedingung zutrifft. Hier: solange die Distanz größer
als 1 ist.

Name der digitalen Variablen

ArduBlock:
Br Vk digitaleVar AB.png

Br Vk digitaleVarBsp AB.png

var
Diesen Block braucht man, wenn man den Wert einer schon gesetzten digitalen Variablen abfragen möchte.
Wenn man mit einer Steuerfunktion (if, if else, while, for) überprüfen möchte, ob eine Bedingung zutrifft. Hier: falls der Linienfolgesensor (LFS)
schwarz sieht.

Name der Zeichen-Variablen

ArduBlock:
Br Vk NameDerZeichenVar AB.png

Br Vk NameDerZeichenVarBsp AB.png

var
Diesen Block braucht man, wenn man den Wert einer schon gesetzten Zeichen-Variablen abfragen möchte.
Wenn man mit einer Steuerfunktion (if, if else, while, for) überprüfen möchte, ob eine Bedingung zutrifft. Hier: falls das Zeichen gleich “’a”’ ist.

Kommunikation

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt “’Kommunikation”’ findet.

serial println

ArduBlock:
Br Ko serialPrintln AB.png

Arduino:
Serial.print( “Hallo” );
Serial.println(“”);
serial println
Dieser Block sendet Daten an die serielle Schnittstelle mit anschließendem Zeilenumbruch (ln steht für linefeed). “’message”’ kann mit einem
eigenen Texteintrag überschrieben werden. In der Regel wird der Befehl zusammen mit den Befehlen “’verbinde”’ + der passenden Variable
eingesetzt.

serial print

ArduBlock:
Br Ko serialPrint AB.png

Arduino:
Serial.print( “Hallo” );
Serial.println(“”);
serial print
Dieser Block sendet Daten an die serielle Schnittstelle. Man kann über die Eingabe “’true”’ oder “’false”’ festlegen, ob ein Zeilenumbruch folgen
soll. Der Block “’message”’ kann mit einem eigenen Texteintrag überschrieben werden. In der Regel wird der Befehl zusammen mit den Befehlen
“’verbinde”’ + der passenden Variable eingesetzt.

verbinde

ArduBlock:
Br Ko verbindeAnalog AB.png

Br Ko verbindeDigital AB.png

Br Ko verbindeZeichen AB.png

verbinde
Mit diesem Block kann man die jeweils passenden Variablen mit dem print-Befehl verknüpfen

parseInt

ArduBlock:
Br Ko parseInt AB.png

Arduino:
rot = Serial.parseInt() ;
gruen = Serial.parseInt() ;
blau = Serial.parseInt() ;
Serial.parseInt
Mit dem Befehl “’Serial.parseInt”’ wird die erste Integer Zahl aus dem seriellen Pufferspeicher ausgegeben. Zeichen, die keine Ganzzahlen sind,
werden ebenso wie ein Minuszeichen ignoriert bzw. weggeschnitten. Das erste Zeichen, das keine Ziffer ist, beendet den Befehl.

Daten verfügbar

ArduBlock:
Br Ko serialDataAvailable AB.png

Arduino:
while (Serial.available() > 0)
Serial.available
Dieser Block prüft, ob im Eingangspuffer der seriellen Schnittstelle Daten vorhanden sind. Wenn ja, wird die Anzahl der vorhandenen Bytes
zurückgegeben, die dann mit Serial.read ausgelesen werden können.

Serielles Lesen

ArduBlock:
Br Ko seriellesLesen AB.png

Arduino:
if (Serial.read() == ’\n’)
//falls Zeilenumbruch
(gelesen wird nur der backslash)
Serial.read
Dieser Block liest das erste Zeichen aus dem Eingangspuffer der seriellen Schnittstelle. Falls keine Daten vorhanden sind, wird der Wert -1 von
der Funktion zurückgegeben.

Fahre

Im folgenden Teil sind alle Blöcke beschrieben, welche man unter dem ArduBlock-Menüpunkt Fahre findet. Wenn man einen Fahrbefehl-Block in sein Programm einbaut, wird automatisch die Bibliothek “’letsgoING_Drive.h”’ eingebunden. Dort sind Werte für die Fahrzeuggeometrie und den Radencoder hinterlegt.
Voreingestellt sind folgende Pins:
Geschwindigkeit rechts (PWM1): Pin 10
Geschwindigkeit links (PWM2): Pin 11
Richtung rechts (dir1): Pin 9
Richtung links (dir2): Pin 12
Wenn man andere Pins verwenden möchte, dann muss man über den Befehl „Drive Rover“ mit folgenden Parametern versehen: Drive Rover (PWM1, PWM2, dir1, dir2) Drive Rover(5,6,4,7); 5 für Geschwindigkeit rechts, 6 für Geschwindigkeit links, 4 für Richtung rechts und 7 für Richtung links. Bei der Übersetzung in die Arduinosprache erkennt man die Befehle aus der Fahren – Library an der Vorsilbe Rover.

Fahre

ArduBlock:
Br Fa fahreGeschwindigkeitRichtung AB.png

Arduino:
Einbindung der library und Aufruf der Rover-Instanz
#include <letsgoING_Drive.h>
Drive Rover;
Befehl in der loop
Rover.drive(50,HIGH);
Fahre
Mit dem Block Fahre kann man festlegen, mit welcher Geschwindigkeit (0 bis 100) und in welche Richtung (HIGH oder LOW) das Fahrzeug fahren soll.

fahre Distanz

ArduBlock:
Br Fa fahreDistanz AB.png Arduino:
Einbindung der library und Aufruf der Rover-Instanz
#include <letsgoING_Drive.h>
Drive Rover;
Befehl in der loop
Rover.driveDistance(50,50,HIGH);
fahre Distanz
Mit dem Block Fahre Distanz kann man festlegen, mit welcher Geschwindigkeit (0 bis 100), in welche Richtung, (HIGH) oder (LOW) und wie weit (in cm)
das Fahrzeug fahren soll. Die Distanz wird aus den von den Raddecodern erzeugten Interrupts berechnet. Beim Decoder kommt es häufig zu prellenden
Werten. Deshalb wird nur der niedrigere Wert ausgewählt.

drehe

ArduBlock:
Br Fa dreheGeschwindigkeitRichtung AB.png
Arduino:
Rover.turn(50,HIGH);
drehe
Mit dem Block Drehe kann man festlegen mit welcher Geschwindigkeit (0 bis 100) und in welche Richtung (HIGH) oder (LOW) das Fahrzeug um die eigene
Achse drehen soll.

Drehe Winkel

ArduBlock:
Br Fa dreheWinkel AB.png
Arduino:
Rover.turnAngle(90,50,HIGH);
drehe Winkel
Mit dem Block Drehe Winkel kann man festlegen mit welcher Geschwindigkeit (0 bis 100), in welche Richtung (HIGH) oder (LOW) und um welchen Winkel
(0 bis 360 grad) das Fahrzeug um die eigene Achse drehen soll.

fahre Kurve

ArduBlock:
Br Fa fahreKurveRotation AB.png
Arduino:
Rover.driveCurve(0,50);
fahre Kurve Mit dem Block “’Fahre Kurve”’ kann man wie bei einer Panzersteuerung die Drehbewegung (Rotation) [-100,100] und die Vorwärtsbewegung 
(Translation) [-100,100] festlegen.

In der LGI_Drive-Library werden aus diesen beiden Bewegungen die Geschwindigkeiten für die beiden Motoren berechnet.

Mit diesem Block können vom Geradeauslauf über weite und enge Kurven bis hin zur Drehung um die eigene Achse alle Bewegungen ausgeführt werden.
Bei einer reinen Drehbewegung bewegt sich ein Motor mit der eingegebenen Geschwindigkeit vorwärts, der andere rückwärts. Die resultierende Bewegung ergibt sich aus der Addition der Vorwärtsbewegung und Drehbewegung.
Beispiele findest du in Kapitel 11.7

fahre Kurve Distanz

ArduBlock:
Br Fa fahreKurveDistanz AB.png
Arduino:
Rover.driveCurveDistance(50,0,50);
fahre Kurve Distanz
Mit dem Block Fahre Kurve Distanz kann man über die Panzersteuerung festlegen wie weit (in cm) das Fahrzeug in die eingestellte Richtung fahren
soll. Rotation = Drehbewegung [-100,100] und Translation = Vorwärtsbewegung [-100,100].

Motoren stopp

ArduBlock:
Br Fa motorenStop AB.png
Arduino:
Rover.stopp();
Motoren stopp
Stoppt beide Motoren. Das Fahrzeug wird allerdings nicht gebremst und fährt somit noch ein Stück weiter.

Motoren bremsen

ArduBlock:
Br Fa bremsen AB.png
Arduino:
Rover.brake();
bremsen
Das Fahrzeug wird aktiv gebremst. Es hält ruckartig an.

Messung starten

ArduBlock:
Br Fa messungStarten AB.png
Arduino:
Rover.startMeasure();
Messung starten
Mit dem Block “’Messung starten”’ kann der Punkt festgelegt werden, ab welchem die gefahrene Distanz ermittelt werden soll.

Distanz ermitteln

ArduBlock:
Br Fa distanzErmitteln AB.png
Arduino:
if (Rover.getDistance() > 50)
Distanz ermitteln
Mit dem Block “’Distanz ermitteln”’ wird die gefahrene Distanz zurückgeben.
Meine Werkzeuge
Namensräume

Varianten
Aktionen
Navigation
Projekte
letsgoING Material
letsgoING Hardware
letsgoING Software
Sensoren
Aktoren
LED
Bluetooth
Wissen
Werkzeuge