Wir sind die Roboter

Die Dämp­fe von Löt­zinn bren­nen einer kon­zen­triert über den Löt­kol­ben gebeug­ten Schü­le­rin in den Augen, der Geruch von Röst­zwie­beln liegt in der Luft, über­all lie­gen elek­tro­ni­sche und mecha­ni­sche Bau­tei­le her­um. Selt­sa­me Gefähr­te, die an die­je­ni­gen aus der Mad-Max-Trio­lo­gie anzu­knüp­fen schei­nen, fah­ren über den Flur und dre­hen wie von Geis­ter­hand vor Wän­den und Hin­der­nis­sen um. Rechts wird geflucht über die unver­meid­li­chen Trei­ber­pro­ble­me unter Windows8, links lacht sich dar­über der Nut­zer eines Ubun­tu-Desk­tops ins Fäust­chen, wäh­rend die Grup­pe im hin­te­ren Bereich das Schei­tern des letz­ten Algo­rith­mus bei einem kräf­ti­gen Biss in das selbst­ge­bau­te Hot­dog und einer Par­tie Mine­craft verarbeitet.

Die Situa­ti­on ent­stammt nicht dem Ent­wick­lungs­la­bor einer nerdi­gen Elek­tronik­fir­ma, son­dern beschreibt die Atmo­sphä­re in unse­rer neu­en Ardui­no-AG auf dem letz­ten Regio­nal­grup­pen­tref­fen recht genau. Da kann nach nicht ein­mal acht Wochen dann schon sowas herauskommen:

Die Hard­ware habe ich nach einem Schü­ler­ent­wurf nach­ge­baut. Die hier zu sehen­den Komponenten

  • ein Ardui­no UNO-Nachbau
  • ein Adafruit-Motor­s­hield-Nach­bau
  • ein HC-SR04 Ultraschallsensor
  • ein 4WD-Chas­sis
  • sechs Mignon-Akkus
  • ein Bat­te­rie­fach
  • Kabel und ande­rer Kleinkram

kos­ten etwa 50,- Euro, wenn man etwas war­ten kann. Die not­wen­di­ge Soft­ware gibt es kos­ten­los zum Down­load. Pro­gram­miert wird in einem C‑ähnlichen Dia­lekt. Der Robo­ter aus dem Video wird von die­sem Pro­gramm gesteuert: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
    #include <AFMotor.h>
 
    AF_DCMotor motor_01(1, MOTOR12_64KHZ);
    AF_DCMotor motor_02(2, MOTOR12_64KHZ);
    AF_DCMotor motor_03(3, MOTOR12_64KHZ);
    AF_DCMotor motor_04(4, MOTOR12_64KHZ);
 
    // HC-SR04
    // VCC auf 5V
    // Trig auf Trigger Pin (löst Ultraschallimpuls aus)
    // Echo auf Echo Pin (Zeit in ms bis zum Empfang des Echos)
    // GND auf GND
 
    #define echoPin 15 // Echo Pin
    #define trigPin 14 // Trigger Pin
    int turn = 1;      // Drehrichtungsänderung wenn "festgefahren"
    int count = 0;     // Anzahl der Drehausweichversuche pro Richtung
 
    long duration, distance; // Dauer um Abstand zu berechnen
 
    void setup() {
 
     motor_01.setSpeed(190);  // Wir fahren nicht volle Pulle
     motor_02.setSpeed(190);
     motor_03.setSpeed(190);
     motor_04.setSpeed(190);
 
     Serial.begin (9600);
     pinMode(trigPin, OUTPUT);
     pinMode(echoPin, INPUT);
 
    }
 
    void loop() {
 
 
     /* The following trigPin/echoPin cycle is used to determine the
     distance of the nearest object by bouncing soundwaves off of it. */ 
 
     digitalWrite(trigPin, LOW); 
     delayMicroseconds(2); 
 
     digitalWrite(trigPin, HIGH);
     delayMicroseconds(10); 
 
     digitalWrite(trigPin, LOW);
     duration = pulseIn(echoPin, HIGH);
 
     //Calculate the distance (in cm) based on the speed of sound.
     distance = duration/58.2;
 
     //Delay 50ms before next reading.
     delay(50);
 
     if (distance < 25 && turn > 0 )
 
     {
 
       motor_01.run(FORWARD);   // Motor 1 vorwärts laufen lassen
       motor_02.run(FORWARD);
       motor_03.run(FORWARD);
       motor_04.run(FORWARD); 
 
       delay(200);
 
       motor_01.run(BACKWARD);
       motor_02.run(BACKWARD);  // Motor 2 rückwärts laufen lassen
       motor_03.run(FORWARD);
       motor_04.run(FORWARD);
 
       delay(200);
 
       count++;
 
       if (count >= 3 ) {   
 
         turn = -turn;
 
       }
 
     } 
 
     else if (distance < 25 && turn < 0 )
 
     {
 
       motor_01.run(FORWARD);   // Vorwärts fahren
       motor_02.run(FORWARD);
       motor_03.run(FORWARD);
       motor_04.run(FORWARD); 
 
       delay(200);
 
       motor_01.run(FORWARD);
       motor_02.run(FORWARD);  // Motor 2 rückwärts laufen lassen
       motor_03.run(BACKWARD);
       motor_04.run(BACKWARD);
 
       delay(200);
 
          count++;
 
       if (count >= 3 ) {   
 
         turn = -turn;
 
       }
 
     }
 
     else
 
     {
       motor_01.run(BACKWARD);   // Motor 1 vorwärts laufen lassen
       motor_02.run(BACKWARD);
       motor_03.run(BACKWARD);
       motor_04.run(BACKWARD); 
 
       count = 0;
 
     }
 
    }

Beim Expe­ri­men­tie­ren mit der Ardui­no­platt­form gibt es ganz vie­le ver­schie­de­ne Herausforderungen: 

  • Es muss zumin­dest in Grund­zü­gen pro­gram­miert werden
  • Die­se Pro­gram­me bedür­fen einer stän­di­gen Optimierung
  • Ver­drah­tet“ man mit Löt­kol­ben und Schrau­bern­dre­her oder gleich im Pro­gramm selbst? – Im obe­ren Pro­gramm sind z.B. „falsch“ ange­schlos­se­ne Moto­ren durch ent­spre­chen­de Code­än­de­run­gen kom­pen­siert worden.
  • Wie struk­tu­riert man sein Pro­gramm so, dass man es die Woche dar­auf noch ver­steht? – Mor­gen wer­den wir uns mit Unter­pro­gram­men und der Para­me­ter­über­ga­be beschäftigen.
  • Wie arbei­ten die Sen­so­ren eigent­lich? (Der HC-SR04 muss z.B. so aus­ge­rich­tet wer­den, dass er nicht schon Uneben­hei­ten auf dem Boden als Hin­der­nis erfasst, mit meh­re­ren Sen­so­ren erhö­he ich die Mess­ge­nau­ig­keit usw.)
  • Wie löse ich die vie­len mecha­ni­schen Probleme?
  • Die meis­ten Pro­gram­mier­bei­spie­le im Netz sind auf Englisch …

Ich fin­de es pri­ma, dass Infor­ma­tik hier erfahr­bar wird und dass nicht nur vir­tu­ell ver­mit­tel­te Erfah­run­gen und Lern­an­läs­se vor­han­den sind. Grund­struk­tu­ren zum Pro­gram­mie­ren geben wir in der AG vor, da rei­nes Aus­pro­bie­ren schnell zu Frus­t­er­leb­nis­sen führt, ins­be­son­de­re wenn meh­re­re Akto­ren und Sen­so­ren dazukommen.
Die Schü­le­rin­nen und Schü­ler doku­men­tie­ren das im in einem Doku­Wi­ki, was sie über Akto­ren und Sen­so­ren her­aus­fin­den oder stel­len auch ganz Code­schnip­sel ein. Neben­bei ler­nen sie etwas über Syntax.