Kompetenzorientierte Prüfung mit Arduino?

Ich hat­te Anfang des Jah­res mein Kon­zept vor­ge­stellt, SuS Infor­ma­tik zu ver­mit­teln. Das war sehr eigen­wil­lig, ein Ver­such und über­haupt sehr viel Lern­an­lass für mich im letz­ten Jahr. Die SuS haben im zwei­ten Halb­jahr an Pro­jek­ten gear­bei­tet und — so die Hoff­nung — ihre Pro­gram­mier­kennt­nis­se ver­tieft. Kon­kret wird an fol­gen­den Pro­jek­ten gear­bei­tet:

  • didak­ti­sche Auf­be­rei­tung eines kom­ple­xen Ardui­no­codes für Anfän­ger
  • ein auto­no­mes Robo­ter­fahr­zeug
  • zwei Light­cu­bes, einer mit Musik­steue­rung
  • ein Quiz­du­ell­clo­ne auf einem 2x40 Matrix ASCII-Dis­play
  • ein Mor­se­zei­chen­de­ko­der

… und natür­lich wird neben­bei in einem Wiki doku­men­tiert und Code zwi­schen­ge­parkt.

Eine Klau­sur ver­lang­te nun die Fach­schaft (die aus zwei Lehr­kräf­ten besteht). Ich hät­te bestimmt auch auf eine Ersatz­leis­tung aus­wei­chen kön­nen, aber ich woll­te Schwarz auf Weiß sehen, was die SuS jetzt kön­nen und was sich im Ver­gleich zum Anfang des Jah­res geän­dert hat. Des­we­gen gab es doch eine Klau­sur, aber eine ganz ande­re.

Infor­ma­tik­klau­sur Nr. 2

Mate­ri­al:

  1. Ein Ardui­no­board (Art egal)
  2. drei Leds (ggf. ver­schie­de­ne Far­ben)
  3. drei Vor­wi­der­stän­de für die Leds (220–330 Ohm)
  4. zwei Tas­ter
  5. zwei Wider­stän­de für die Tas­ter (1kOhm oder 10kOhm)
  6. ein Steck­brett
  7. Kabel­ver­bin­der

Vor­be­mer­kun­gen:
Wenn du Tas­ter an den Ardui­no anschlie­ßen und ihren Zustand aus­le­sen möch­test, musst du einen zusätz­li­chen Wider­stand ver­wen­den, um defi­nier­te Pegel zu bekom­men. Die­ser Wider­stand soll­te einen Wert zwi­schen 1kOhm und 10kOhm haben.

Hier eine Bei­spiel­schal­tung

Auf­ga­be:
Du sollst ein Spiel pro­gram­mie­ren. In die­sem Spiel gibt es drei Leds (links, rechts, Erfolg) und zwei Tas­ter (links, rechts).

Dabei gilt:
Led rechts: Pin03
Led Erfolg: Pin04
Led links: Pin05
Tas­ter rechts: Pin06
Tas­ter links: Pin07

Spiel­ab­lauf ist fol­gen­der:

  1. Zufäl­lig leuch­tet ent­we­der die rech­te oder die lin­ke Led auf.
  2. Der Spie­ler muss nun mög­lichst schnell eine ent­spre­chen­de Tas­te (links oder rechts) drü­cken
  3. Hat er das inner­halb einer bestimm­ten Zeit­span­ne geschafft, leuch­tet die Led „Erfolg“ auf, ansons­ten blin­ken alle Leds kurz auf
  4. Die Zeit­span­ne wird im Lau­fe des Spiel immer kür­zer

Für jede rea­li­sier­te Stu­fe 1–4 gibt es bereits Punk­te!

Tipp:
Suche mit Goog­le nach „Ardui­no Zufall“, um her­aus­zu­be­kom­men, wie du zufäl­li­ge Wer­te erhältst.

Abga­be:
Du erstellst mit Libre­Of­fice eine Datei, die dei­nen aus­führ­lich kom­men­tier­ten Code ent­hält.
Du erläu­terst dei­nen Code.
Du beschreibst zusätz­lich, wel­che Schwie­rig­kei­ten du wäh­rend der Pro­gram­mie­rung hat­test, ins­be­son­de­re dann, wenn dir etwas nicht gelun­gen ist.

Die Datei spei­cherst du unter:

Der Datei­na­me muss dei­nen Namen ent­hal­ten, z.B. „karl_mustermann_klausur.ods“.

Du darfst:

  • Im Inter­net recher­chie­ren
  • Dir selbst­stän­dig Mate­ri­al holen / orga­ni­sie­ren
  • Dei­nen Code an einer Schal­tung aus­pro­bie­ren

Du darfst nicht:

  • mit dei­nen Kurs­kol­le­gin­nen und Kol­le­gen spre­chen

viel Erfolg!

 

Die Zeit war für die­se Auf­ga­be mit 90 Minu­ten sehr knapp bemes­sen, aber es gibt sogar voll­stän­di­ge und funk­tio­nie­ren­de Lösun­gen, min­des­tens aber immer kon­kre­te Ansät­ze und was mich beson­ders freut: Die meis­ten Schal­tun­gen sind kor­rekt und sau­ber auf­ge­baut. Das Prü­fungs­for­mat ist im BBS-Kon­text erst­mal über­haupt nicht unge­wöhn­lich, bei uns an der Schu­le jedoch schon ein Novum. Mit Goog­le ist die­se Auf­ga­be nur sehr ein­ge­schränkt lösbbar, gera­de auch in der gege­be­nen Zeit, man braucht dafür also mei­ner Ansicht nach auch gar nicht mal so wenig Wis­sen. Ich hat­te erst ein wenig Angst vor der Bewer­tung, aber schluss­end­lich gibt es für Code­qua­li­tät schon genug Kri­te­ri­en und auch für die Beschrei­bun­gen. Span­nend fin­de ich, dass man rela­tiv genau sehen kann, wie jemand denkt, weil der Code im Prin­zip ja ein for­ma­li­sier­ter Plot des Den­kens ist — ohne die­ses Over­head-Geschwur­bel in geis­tes­wis­sen­schaft­li­chen Fächern (ich darf das als Deutsch­leh­rer sagen).

Mein Pro­blem mit dem erfolg­ten Unter­richt ist ein ande­res: Ich kom­me mir so unver­ant­wort­lich vor, weil ich ja nie klas­sisch unter­rich­tet, son­dern ganz viel 1:1 bera­ten, gelenkt, unter­stützt habe und auch oft fach­lich die Segel strei­chen muss­te (ich kann jetzt aber einen ein­stu­fi­gen Ver­stär­ker ste­cken). Die „Vor­be­rei­tung” des Unter­richt besteht bei die­ser Unter­richts­form eher dar­in, ganz viel selbst ler­nen zu müs­sen, weil es um sehr indi­vi­du­el­le Pro­ble­me geht. Nach jeder Stun­de bin ich fix und foxi, weil ich immer gedank­lich hin- und hers­wit­chen und auch Anfra­gen prio­ri­sie­ren muss.

 

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 Min­e­craft ver­ar­bei­tet.

Die Situa­ti­on ent­stammt nicht dem Ent­wick­lungs­la­bor einer ner­di­gen Elek­tro­nik­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 her­aus­kom­men:

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

  • ein Ardui­no UNO-Nach­bau
  • ein Adaf­ruit-Motor­shield-Nach­bau
  • ein HC-SR04 Ultra­schall­sen­sor
  • ein 4WD-Chas­sis
  • sechs Mignon-Akkus
  • ein Bat­te­rie­f­ach
  • Kabel und ande­rer Klein­kram

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-ähn­li­chen Dia­lekt. Der Robo­ter aus dem Video wird von die­sem Pro­gramm gesteu­ert:

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 Her­aus­for­de­run­gen:

  • Es muss zumin­dest in Grund­zü­gen pro­gram­miert wer­den
  • Die­se Pro­gram­me bedür­fen einer stän­di­gen Opti­mie­rung
  • 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 wor­den.
  • 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äf­ti­gen.
  • 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 Pro­ble­me?
  • Die meis­ten Pro­gram­mier­bei­spie­le im Netz sind auf Eng­lisch …

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 dazu­kom­men.
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 Syn­tax.

Informatik mit Arduino

leonardo

Ich habe in die­sem Jahr einen Infor­ma­tik­kurs in der Klas­se 10 über­nom­men. Den besucht man als Schü­le­rin oder Schü­ler zusätz­lich zu einem recht vol­len Stun­den­plan in Klas­se 10, um die Opti­on auf eine Teil­nah­me an einem Infor­ma­tik­kurs in Klas­se 11 zu bekom­men. Man darf dann im Abitur zwei Kur­se Natur­wis­sen­schaft durch Infor­ma­tik erset­zen. Ich bin kein gelern­ter Infor­ma­tik­leh­rer — ich bin ein­fach nur ein grö­ßen­wahn­sin­ni­ger Freak und wahr­schein­lich schlägt die Infor­ma­tik­di­dak­tik über mei­ne Ansät­ze die Hän­de in der Luft zusam­men.  Egal — ent­we­der man ist kon­ven­tio­nell oder man lebt.

Stu­fe 1:

Wir haben Pro­ble­me in Ein­zel­pro­ble­me zer­legt — z.B. soll­ten 20 Zah­len von 20 Per­so­nen abge­fragt und addiert wer­den. Unse­re Stra­te­gi­en haben wir auf­ge­schrie­ben. Dabei spielteh fol­gen­de Fra­gen eine Rol­le:

  • Wie mer­ken wir uns die gan­zen Zah­len?
  • Wenn wir sie uns auf­schrei­ben: Wir machen wir das genau? Neben­ein­an­der? Unter­ein­an­der?
  • Addie­ren wir bei jeder Abfra­ge oder fra­gen wir alle Zah­len ab und addie­ren dann?
  • […]

Stu­fe 2:

Wir haben mit dem Fluss­dia­gramm ein Ver­fah­ren ken­nen gelernt, dass Auf­ge­schrie­be­ne zu visua­li­sie­ren und die­se Visua­li­sie­rung für wei­te­re Pro­ble­me durch­ge­spielt, die z.B. Fall­un­ter­schei­dun­gen ent­hiel­ten.

Stu­fe 3:

Mit Scratch haben wir unser Pro­blem aus Stu­fe 1 ganz kon­kret gelöst und zwar durch Pass&Fail. Für Scratch muss man heu­te im Prin­zip nicht ein­mal ein Pro­gramm instal­lie­ren — das läuft auch kom­plett im Brow­ser — wenn man beim MIT einen Account anlegt. Wer moch­te, konn­te sich auch schon am klas­si­schen Rate­spiel „rate eine Zahl zwi­schen 1 und 100” ver­su­chen oder sich eines der vie­len ver­öf­fent­lich­ten Pro­jek­te zu Scratch vor­neh­men. Die Lösungs­an­sät­ze haben wir uns vor­ge­stellt und teil­wei­se dis­ku­tiert.

Stu­fe 4:

Anhand eines Aus­drucks eines „Scratch­pro­gram­mes” galt es, ein Fluss­dia­gramm zu zeich­nen und einen fie­sen, von mir natür­lich absicht­lich ein­ge­bau­ten Feh­ler zu fin­den. Dazu gab es noch eini­ge Erwei­te­rungs- und Opti­mie­rungs­auf­ga­ben.

Stu­fe 5:

In einem Doku­wi­ki­sys­tem haben die Schü­le­rin­nen und Schü­ler Sei­ten zu Pro­gram­mier­spra­chen erstellt. Ich habe eine kla­re Struk­tur vor­ge­ge­ben: Eine kur­ze Beschrei­bung zur Spra­che, ein „Hel­lo World!”- , ein „if -then — else”- und ein „while”-Codebeispiel. Doku­wi­ki kann das abso­lut pri­ma, weil es einen leis­tungs­fä­hi­gen Syn­tax­high­ligh­ter für fast alles hat. Es braucht kei­ne Daten­bank, ist ajax­ba­siert — ein­fach und umkom­pli­ziert. Unnö­tig zu erwäh­nen, dass dabei die Kon­fron­ta­ti­on mit dem Begriff „Syn­tax” sowohl theo­re­tisch (für die Spra­che suchen) als auch prak­tisch (Wiki­syn­tax) erfolg­te.

Zwi­schen­stand:

Die Schü­le­rin­nen und Schü­ler haben bis jetzt eigent­lich schon alles erlebt, was man beim Pro­gram­mie­ren so erle­ben kann:

  • Mein Code läuft nicht!” — „Hm. Da fehlt ‚ne Klam­mer” — „Oha, wenn ich da etwas ein­rü­cke, dann wird es ja viel über­sicht­li­cher.”
  • Sein Code läuft und mei­ner auch. Wel­cher ist denn nun rich­tig?” — „Wel­cher gefällt dir denn war­um bes­ser?”
  • Boah, ist das viel zu schrei­ben!” — „Nun­ja — aber wenn sich das stän­dig wie­der­holt, könn­test du ja viel­leicht auch …”
  • […]

Stu­fe 6:

Kur­zer Leh­rer­vor­trag zu Ardui­no. Dann ran an den Simu­la­tor — der ist abso­lut toll und zu emp­feh­len, bevor die ers­ten Bau­tei­le in Rauch auf­ge­hen.

Natür­lich habe ich zunächst eine ganz ein­fa­che Bei­spiel­schal­tung vor­ge­stellt (blin­ken­de LED).

(circuits.io klappt bis­her so rich­tig gut nur mit Chro­me oder Chro­mi­um als Brow­ser.)

Die soll­te dann um drei LEDs in einer Ampel­schal­tung erwei­tert wer­den. Dazu muss­te man schon ein Biss­chen was am Bre­ad­board ver­ste­hen. Neben­bei wur­de auch etwas über die Wel­len­län­ge des Lichts und Far­be gelernt: Im Simu­la­tor ändert man die LED-Far­be durch Ein­ga­be von Wel­len­län­gen in nm. Und ohne Vor­wi­der­stand macht die LED „peng”, ver­polt macht sie gar nichts. Es gab sofort das Spiel: „Wie klein darf ich den Wider­stand machen, dass die LED heil bleibt?” Neben­bei ist die Simu­la­tor­home­page auf Eng­lisch (Wider­stand = resis­tor).

Stu­fe 7:

Es kommt etwas Theo­rie zur Ardui­no-IDE. Wir wer­den den Ardui­no Leo­nar­do bzw. einen pin­kom­pa­ti­blen Nach­bau  nut­zen, weil der durch sein HID-Funk­tio­nen in Kom­bi­na­ti­on mit Lage­sen­so­ren auch als Game­con­trol­ler oder Mauser­satz taugt. Den Ardui­no kau­fen sich die Schü­le­rin­nen und Schü­ler selbst, das Zube­hör stift­tet unser För­der­ver­ein. Die Kos­ten sind aber sehr mar­gi­nal im Ver­hält­nis zu den sich bie­ten­den Mög­lich­kei­ten. Dann kön­nen wir unse­re Schal­tung aus Stu­fe 6 real auf­bau­en.

Aus­blick

Die Schü­le­rin­nen und Schü­ler sol­len sich nach Mög­lich­keit eige­ne Pro­jek­te suchen, die sie mit dem Ardui­no rea­li­sie­ren. Natür­lich habe ich not­falls Pro­jek­te von unter­schied­li­chem Schwie­rig­keits­grad in der Hin­ter­hand. Der Kom­ple­xi­täts­grad der Pro­jek­te darf natür­lich mit dem wach­sen­den Wis­sens­be­stän­den stei­gen. Die Schu­le bekommt aus einem N21-Pro­jekt für eine AG Robo­ter auf Ardui­no­ba­sis gestellt, auf die sich dann ggf. die erwo­be­nen Kennt­nis­se über­tra­gen las­sen.

Mit der stei­gen­den Kom­ple­xi­tät der Pro­jek­te erwar­te ich ein Anwach­sen der Pro­gramm­codes, das irgend­wann dazu füh­ren soll, bestimm­te Funk­tio­nen aus­zu­la­gern in objekt­ori­en­tier­te Set­tings (Ende 2. Halb­jahr). Schön wäre es, wenn der Code für einen allei­ne nicht mehr zu pfle­gen ist, sodass auch Struk­tu­ren wie SVN not­wen­dig wer­den.

Ers­te Ein­drü­cke

  1. Ich ler­ne mit den Schü­le­rin­nen und Schü­lern mit. Für mich ist vie­les Neu­land.
  2. Schü­le­rin­nen und Schü­ler fin­den Feh­ler im Pro­gramm­code viel schnel­ler in Peer-Reviews als ich
  3. Die­ser Ansatz schreckt auch eini­ge ab. Man muss ja aller­hand aus­hal­ten und sogar auch Elek­tro­nik- und Eng­li­sch­wis­sen aus­bau­en
  4. Ich muss­te die Beschäf­ti­gung mit der Hard­ware vor­zie­hen. Ich und die Schü­le­rin­nen und Schü­ler kön­nen es teil­wei­se kaum erwar­ten.
  5. Es wird sehr selbst­stän­dig und kon­zen­triert gear­bei­tet — auf die Fra­ge: „Kann ich das so machen?” ant­wor­te ich oft: „Pro­bie­re es aus!” — und mit die­ser Ant­wort sind sie oft zufrie­den.
  6. Per­fek­tio­nis­ten sind in der Hin­ter­hand — am effek­tivs­ten arbei­ten die Expe­ri­men­tier­freu­di­gen
  7. Man kann wun­der­bar dif­fe­ren­zie­ren: Der C-Freak bekommt eben eine Bild­röh­re mit Com­po­si­te-Ein­gang, auf der er ein Spiel pro­gram­miert. Das ist vom Timing her nicht tri­vi­al, da der Ardui­no von sei­ner Rechen­leis­tung damit an eine Gren­ze kommt. Dem Anfän­ger reicht viel­leicht ein Lauf­licht als ers­tes Pro­jekt — oder ein Ther­mo­me­ter (NTCs haben eine Kenn­li­nie, muss muss mathe­ma­ti­siert oder mit einem ande­ren Ther­mo­me­ter kal­li­briert wer­den).
  8. Es kom­men Fra­gen wie: „Darf ich zu Hau­se an mei­ner Schal­tung im Simu­la­tor wei­ter­ar­bei­ten?” „Dür­fen wir unser Pro­jekt auch mit nach Hau­se neh­men?”