Raspberry
 
   

Meine Seiten zur Nutzung des Raspberry PI 2       (In Bearbeitung / 15 Apr 2016 )


Raspberry in Betrieb nehmen

Den Raspberry habe ich im Paket erworben, also folgende Teile:
  • Platine: Raspberry pi 2
  • Kühlkörper für 2 Schaltkreise
  • Gehäuse zum Raspberry
  • Mini-SD-Karte (8GByte)
  • WLAN-Adapter für USB-Anschluss
  • HDMI-Kabel
  • Netzteil
   

Zunächst wurden die Kühlkörper auf die beiden Schaltkreise auf der Platinen-Seite, auf der sich auch die GPIO-Kontakte befinden, aufgeklebt. Für den Schaltkreis auf der anderen Seite gibt es keinen Kühlkörper.
Dann wurde der "Raspi" ins Gehäuse gesetzt, das schützt die Platine auch vor unerlaubten elektrischen Berührungen.

Die SD-Karte war bereits mit "NOOBS" bespielt, so dass man einfach den Raspberry starten konnte - eigentlich einfach. Das Ergebnis war jedoch ernüchternd, denn es gab eine Fehlerausschrift:
    [ 3.236233] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(179,2)
und der Raspberry war nicht bereit weiter zu arbeiten!

Mist - der "Raspi" ist kaputt!
Rücksprachen mit UNIX-Kennern erbrachten, dass "Unable to mount" eigentlich auf ein fehlendes Dateisystem auf der SD-Karte hinweist - also wieder von vorn:


Das Ergebnis blieb unverändert, die gleiche Fehlerausschrift.

Als nächsten Schritt nach dem Formatieren habe ich dann "NOOBS" auf dem PC entpakt und dann auf die SD-Karte rüber kopiert und da kam dann die Erleuchtung als er meckerte, dass nicht genug Speicherplatz vorhanden wäre - die SD-Karte war defekt!
Eine neue Karte führte sofort zum Erfolg - der "Raspi" lief!

In der Zwischenzeit habe ich nun natürlich alle Programm auf dem PC gespeichert, da der "Raspi" erneut bei anderen Installationen abgestürzt ist.
Ich habe mich auch beim Franzis-Verlag angemeldet und ein Handbuch heruntergeladen - das beschreibt aber nicht den "Raspberry PI 2", es funktioniert also nicht alles so wie beschrieben. Aber, da ich dann im Eifer vergessen habe die deutsche Tastatur einzustellen musste das nachher erfolgen, da war das Handbuch sehr hilfreich.

Die Firma "Conrad" bietet einen Adventskalender mit Experimenten zum "Raspi" an. Der Preis entspricht nach meiner Meinung nicht dem Angebot, ich schließe mich damit anderen Meinungen an. Ein Bastler hat die LED's (außer vielleicht die RGB-LED's), die Taster und die Widerstände in der Bastelkiste. Das Steckbrett kann man von vorhergehenden einfachen Elektronikkalendern nutzen. Die Verbindung zwischen "Raspi" und Steckbrett kann man sich einfach selbst erstellen ( siehe unten ).
Positiv zum Kalender muss man aber vermerken, dass es eine recht gute Anleitung mit entsprechenden Programmen zur Nutzung der GPIO-Kontakte gibt!


Nutzung der GPIO-Kontakte
(GPIO - General Purpose Input Output)

Da es eines meiner wichtigten Ziele ist, über die GPIO-Kontakte einen technischen Prozeß zu steuern, muss eine Verbindung zwischen beiden geschaffen werden. Die Industrie bietet dazu Kabel für eine und alle Verbindungen an. Dann kann es so wie in den beiden Bildern aussehen:

   

Aus meinen frühen Erfahrungen, da habe ich so elektronische Schaltungen aufgebaut, weiß ich, dass das ganz schnell auf Grund von unerwünschten Berührungen von Leitungen mal schief gehen kann und ein Bauteil stirbt, was in diesem Fall aber der "Raspi" sein kann.
Um diese Problematik etwas umgehen zu können, habe ich eine 40-adrige (also alle) Verbindung vom "Raspi" zur Schaltung erstellt.

    Das geht relativ einfach, da der Stecker auf dem Raspi offensichtlich dem ATA-System von älteren Rechnern entspricht. Folglich sollte man so ein Kabel zur Verbindung verwenden können.
Auf der "Raspi"-Seite kann man sofort ohne Probleme das Kabel aufstecken.
Problematischer ist es auf der Prozeßseite, hier braucht man ebenfalls eine Buchse, die ja vorhanden ist - aber die Seiten sind getauscht!
Man müßte also die Buchse vom Kabel trennen und immer zwei Leitungen vertauscht sie wieder mit dem Kabel verbinden. Ich habe für die ersten Versuche festgelegt, dass das mit den vertauschten Seiten in der Buchse machbar sein könnte!

Im Folgenden soll nun kurz das Prinzip beschrieben werden.

    Aus einer kleinen Sperrholzplatte, etwa 5...6mm dick, 5cm breit und 9cm hoch, wird ein Schlitz herausgeschnitten (mit der Laubsäge), so dass die ATA-Buchse festsitzend eingedrückt werden kann. Das Kabel bleibt dran und wird zur Seite nach außen geführt.
Da das Teil mechanisch mit einem Steckbrett verbunden werden soll, wird auf der Kabel abgewandten Seite ein Winkel angebracht. Solche Teile kann man als Meterware kaufen, bedürfen aber immer einer Anpaßarbeit. Auf der anderen Seite wird mit einem Blechstreifen das Kabel befestigt und gleichzeitig die gleiche Höhe wie auf der Winkelseite hergestellt.

    So sieht das Teil dann von unten aus.
Der Winkel (rechts) und der Blechstreifen sind alte noch vorhandene Reste, erfüllen aber ihren Zweck.

    Als Steckbretter sollen solche aus alten Anventskalendern verwendet werden.
Und da wird dann auch klar, warum die Größe des Sperholzbretts gerade 5 x 9cm sein soll - das ist etwa die Größe dieser Steckbretter.

Der weitere Vorteil ist, dass man die Buchse nun beschriften kann, man hat den Platz.

       

Das linke Bild zeigt Original-Belegung der Stifte auf dem "Raspi", das mittlere Bild die neue Belegung auf der Buchse.
Letztere kann man ausdrucken und auf des Sperrholzbrett kleben, dann sollte es keine Verwechselung geben.
Im rechten Bild ist das fertige Teil zu sehen (aufgeklebte Belegung, Winkel zur mechanischen befestigung der folgenden Teile).
(die Beschriftung zum Ausdrucken: als jpg-Bild / als: pdf)

Warum es außerdem auch noch zwei unterschiedliche Beschriftungen der Kontakte gibt, wird später unter Nutzung der GPIO-Kontakte beschrieben

    Und so kann es dann aussehen (hier wurde lediglich die 5V Betriebsspannung aufs Steckbrett geführt und über einen 1KOhm Widerstand eine LED angesteuert - Betriebsspannungsanzeige).
Wer möchte, kann natürlich auch noch die Löcher zur Befestigung der Platte bohren, dafür ist auch noch Platz.
Die weitere Verdrahtung kann nun mit den passgerechten Drahtbrücken zum Steckbrett erfolgen.

Der beschriebene Aufbau dient natürlich nur der experimentellen Steuerung eines technischen Prozesses mit dem "Raspi". Steuert man hingegen einen festen technischen Prozess, dann entfernt man die Buchse vom ATA-Kabel und wird die Drähte fest anlöten.


Nutzung der GPIO-Kontakte

    Mit diesem Aufbau werden die ersten Versuche zur Steuerung der GPIO-Kontakte durchgeführt.

Oben der "Raspi" mit Verbindung der GPIO-Kontakte zum Experementieraufbau, unten eine kleine Funktastatur mit Touchpad (rechts).
Die Anordnung auf der Tastatur ist sehr günstig, da die "Enter"-Taste direkt neben dem Touchpad liegt.
(Mit dem zusätzlichen Anschluss einer Maus arbeitet es sich besser am "Raspi")

Die GPIO-Kontakte lassen sich mit verschiedenen Programmen ansteuern. Ich möchte einmal die symbolische Programmierung mit "Scratch" probieren.
"Scratch" ist bereits auf dem "Raspi" installiert, jedoch braucht man zur Ansteuerung der GPIO-Kontakte ein weiteres Zusatztool. "ScratchGPIO" erfüllt diese Aufgabe. Das Tool wird aus dem Internet geladen (also Internetverbindung ist notwendig) und dann installiert. Das erfolgt im Terminal des "Raspi".
Das Terminal im "Raspi" liegt völlig in der Tradition der Terminale - Fenster mit schwarzem Hintergrund und bunter Schrift:

pi@raspberrypi ~ $ ∎       das steht in der Zeile im Terminal

pi@raspberrypi ~ $        so sieht es dann etwa aus

Erstes Kommando

pi@raspberrypi ~ $   wget http://bit.ly/1wxrqdp -O isgh7.sh∎

(bei: bit.ly ist das Zeichen vor y ein kleines L;
  bei: 1wxrqdp ist das erste Zeichen eine 1 (eins);
  bei: -O handelt es sich um ein großes o (keine 0 (Null))
Das Kommando wird nach Betätigung der "Eingabetaste" (Enter) ausgeführt.
Das Tool wird aus dem Internet geladen - Verbindung ist notwendig!

Ist das Kommando abgearbeitet folgt das zweite:

pi@raspberrypi ~ $   sudo bash isgh7.sh∎

Das Tool wird abgelegt.

Ganz wichtig ist, dass das Tool ScratchGPIO eine andere Pin-Belegung für die GPIO-Kontakte festlegt:

     

Nun können wir eine erste kleine Ansteuerung Programmieren.

AufgabeG1:
Es sollen 2 LED's fortlaufend abwechselnd angesteuert werden!
Zur Ansteuerung der LED's werden die Pins 12 und 18 genutzt.

Dazu folgende Schaltung und die daraus resultierende Verdrahtung:

       

Die rechteste Steckreihe ist senkrecht verbunden (siehe rechtes Bild), somit kann dort Masse (GRD) aufgelegt werden. Das erfolgt über die weiße Leitung von Pin 34 (man könnte auch Pin 39, 30, 25, 20, 14, 9 oder 6 nehmen). Das kurze Bein der LED's wird dort gesteckt.
Die von der Mitte nach rechts und links jeweils 5 Steckkontakte sind wagerecht verbunden (siehe rechtes Bild). Auf jeweils eine dieser Reihen steckt man das lange Bein der LED's, dann mit einem Widerstand von 220Ohm wird die nächste Reihe verbunden und von dieser Reihe dann die Pins12 und 18.
Die rote LED ist nicht notwendig, hier wird die Betriebsspannung 5V über einen Widerstand an die LED geführt. Das andere Bein steckt auf Masse.
Rein elektrisch ist nun alles verbunden. Beim Einschalten des "Raspi" sollte die rote LED leuchten, die Ansteuerung der gelben und grünen LED bedürfen ein Programm!

Das Programm könnte mit Scratch so aussehen:

    Das Programm funktioniert als Endlos-Schleife (wiederhole fortlaufend).
Was in der Schleife steht wird nun immer wieder, von oben beginnend, bis zum unteren letzten Befehl abgearbeitet.
  1. mit "on" wird Spannung auf Pin12 gelegt, die grüne LED leuchtet
  2. mit "off" wird die Spannung von Pin18 weggeschaltet, die gelbe LED ist dunkel.
    eigentlich denkt man, dass das nicht notwendig ist, aber da die Schleife immer wieder abgearbeitet wird, könnte die LED ja zuvor an sein - in der Tat, das ist so!
    Man programmiert nicht den ersten Fall, sondern immer den allgemeinen i-ten Fall!
  3. da die LED nicht sofort wieder ausgehen soll, muss man etwas warten.
    anderenfalls würden beide LED's nur noch flimmern
  4. Pin12 Spannung weg - grüne LED aus
  5. Pin18 Spannung anlegen - gelbe LED an
  6. Warten - danach wieder weiter bei 1.

Und siehe da, es geht!


Allgemeine Programme mit Scratch

Bevor ich nun umfangreiche Programme zur Steuerungen von Prozessen erstelle, muss ich natürlich allgemein den Umgang mit Scratch lernen.
Dazu sollen hier Programme ohne Nutzung der GPIO-Kontakte beschrieben werden.
Das kann man natürlich am "Raspi" ohne Zusatztool durchführen, es geht aber auch am PC.
Unter:

Scratch_life     (https://scratch.mit.edu/projects/editor/?tip_bar=getStarted)

findet man ein sehr konfortables System zum Arbeiten mit Scratch.

(Programm: ball_spiel1b.sb2     Dieses Programm kann man sich vor Start von "Scratch life" runterladen und auf dem PC speichern und dann nach Start von "Scratch life" "vom eigenen PC hochladen". Mit Klicken auf die grüne Fahne startet das Programm.)

AufgabeA1:
Es soll eine Dezimalzahl in eine Dualzahl gewandelt werden. .

Algorhithmus:
(das ist ein sehr bekanntes Verfahren - entspricht etwa dem umgekehrten Horner-Schema)
  1. man teilt die Dezimalzahl ganzzahlig durch 2 (also 13 / 2 = 6) = Erg1
  2. man wendet auf die Dezimalzahl eine Modulo-Operation mit 2 an (Dezimalzahl mod 2) = Erg2.
    Das Ergebnis kann nur 0 oder 1 sein!
  3. Erg1 wird als neue Dezimalzahl verwendet, danach weiter bei 1.
Die Aktionen werden sooft wiederholt bis Erg1 0 ist.

Die Digitalzahl entsteht in umgekehrter Reihenfolge der Werte Erg2!

Beispiel:
Die Zahl 13(dez) ist in eine Dualzahl zu wandeln.

Dez (Erg1)          Erg1  Erg2
    13    /    2    =    6      1 (1)
      6    /    2    =    3      0 (2)
      3    /    2    =    1      1 (3)
      1    /    2    =    0      1 (4)

 

      Das Ergebnis ist Erg2 in umgekehrter Reihenfolge:

(4)(3)(2)(1)
  1  1  0  1

    Es wurde nun versucht mit Scratch den Algorhitmus umzusetzen.

Zunächst soll das nur für eine Zeile erfolgen.
Der Wert wird in Befehl(1) erwartet. Mit <Enter> wird die Eingabe beendet und zum Befehl(2) gegangen. Hier wird der Wert der Eingabe, zwischengespeichert auf "Antwort", auf die Variable "eing" übertragen. Befehl(3) überträgt den Wert von der Variablen "eing" auch noch auf die Variable "wert".
Nach Anzeige der Werte und einer Wartezeit kommt nun der eigentliche Algorhithmus. Das Problem ist die ganzzahlige Division, die gibt es nicht in Scatch, denn 13 / 2 ist natürlich 6.5. Rundet man diesen Wert kommt 7 heraus. Das kann man aber leicht realisieren, indem man vom Wert 0.1 subtrahiert, das Ergebnis ist nun 13 / 2 - 0.1 = 6.4. Rundet man diesen Wert kommt natürlich 6 heraus!
Das funktioniert auch wenn der Rest 0 ist, z.B. 12 / 2 - 0.1 = 5.9 . Gerundet ist das aber eben 6.
Das setzen die Befehle (4)(5)(6) um (das Ergebnis wird immer wieder auf die Variable "eing" zurück gespeichert).
Mit Befehl(7) wird der ganzzahlige Rest berechnet, der kann bei Division durch 2 nur 1 oder 0 sein!
Damit ist eine Zeile realisiert.

    Nun der ganze Algorhithmus.

Der Anfang ist etwa gleich. Zusätzlich gibt es noch eine Variable "i" zum Zählen der Durchläufe und eine Liste "bit" (Liste entspricht etwa einem Array in anderen Programmiersprachen).
Nach der Wartezeit folgt dann eine Schleife (Befehl(5)), die solange wiederholt wird, bis die Variable "wert" 0 ist (Erg1). Neben den schon bekanten Befehlen (6)(7)(8)(9) gibt es einen Befehl zur Erhöhung des Zählwertes "i" (i = i + 1) und der "wert" wird als i-ter Wert in der Liste "bit" gespeichert (Befehl(11)).
Vor Beendigung der Schleife muss natürlich noch neue Wert "eing" auf "wert" gespeichert werden (Befehl(10)) und es geht wieder mit der Erhöhung von "i" los, sofern "wert" nicht 0 ist.
Nach der Bearbeitung der Schleife erfolgt die Ausgabe der Liste (Befehl(12)) (siehe unten).

Die Werte der Liste von unten nach oben gelesen ergibt genau
    1 1 0 1(dual) = 13(dez)!
Die Werte (Bits) könnte man nun genau einzelnen GPIO-Kontakten zuordnen und damit eine Steuerung eines technischen Prozesses vornehmen.
Die Warte- und Zeige-Befehle können bis auf die Liste natürlich entfallen!

Es ist auch möglich, die einzelnen dualen Werte (Bit's) in eine Variable zu speichern:

    Zwischen Befehl(11) und dem Wartebefehl (2sec) werden die folgenden Befehle eingefügt:

Es handelt sich um eine Frage, deren Antwort nicht umgangen werden kann!
Wenn die Bedingung zwischen "falls <Bedingung> dann" erfüllt wird, wird der nächste Befehl (und folgende wenn vorhanden) abgearbeitet.
Ist die Bedingung nicht erfüllt, wird der Befehl (und weitere wenn vorhanden) unter "sonst" abgearbeitet.
Eigentlich wollen wir eine Folge von einzelnen Ziffern aufbauen, also zu einem Anfangswert werden weitere hinzugefügt. Den Anfangswert erhält man beim ersten Durchlauf der großen Schleife für "i = 1", das ist die Bedingung:
Im linken Feld setzt man die Variable "i" ein, im rechten per Tastatur 1.
Der Befehl nach "Bedingung erfüllt" ist bekannt, der Wert der Variablen "wert" wird auf Variable "dual" abgespeichert (bei 13(dez) ist das 1).
Beim nächsten Durchlauf der Schleife (und folgende) ist die "Bedingung" nicht erfüllt, denn "2 = 1" ist falsch! - es geht weiter hinter "sonst" (Befehl(15)).
Das ist wieder eine ganz einfache Zuweisung: "dual" = 0. Aus der Befehlsgruppe "Operationen" wird nun anstelle der 0 die Operation "verbinde" genutzt: "hello" wird mit "world" verbunden - "helloworld"
(in anderen Programmiersprachen wird das als "Konkatenation" bezeichnet - z.B. zusammenfügen von Zeichenketten)
Toll ist nun, dass anstelle der Zeichenfolgen auch Variable eingesetzt werden können! Es wird der Inhalt der Variablen verbunden und damit entsteht Befehl(15): an den Inhalt der Variablen "dual" wird links der Inhalt der Variablen "wert" hinzugefügt und wieder auf "dual" abgespeichert!
Für 13(dez) steht dann nach dem 2.Durchlauf auf "dual" 01, nach 4 Durchläufen 1101(dual).

 

AufgabeA2:
Pong-Ball-Spiel

Eigentlich sollte als nächstes ein über Taster bedienbares Spiel bearbeitet werden. Da dafür aber noch zu viel Wissen fehlte, wurde zunächst am PC ein ähnliches Spiel, bedienbar mit Maus bearbeitet. Alles erfolgte eng nach der Hilfe-Anleitung des Systems.
Und so sieht es fast komplett aus, es fehlt ein kleines Skript, wird später erleutert.

    ⇐ Anordnung auf dem "Raspi"

Zunächst einmal stellt man fest, dass sich die Bildschirmanordnung auf der PC- und Raspi-Version unterscheiden es sind aber die gleichen Elemente. Das liegt daran, dass auf dem PC die Scratch-Version 2.0 und auf dem Raspberry die Version 1.4 bereit gestellt wird. Links oben ("Raspi" rechts oben) gibt es so eine Art Bildschirm, wird als Bühne bezeichnet, auf dem sich das erarbeitete Programm abspielt, es erfolgt hier die Ausgabe aber auch die Bedienung. Das Feld darunter, leicht in zwei Bereiche geteilt, zeigt links die erarbeiteten Bühnenbilder und rechts die veränderbaren Elemente (Figuren) auf der Bühne. Die Bühnenbilder können aus Vorgaben, aus selbstgestalteten Elementen, aus eigenen Dateien entnommen oder fotografiert werden. Klickt man auf die Bühne (links) und wählt im mittleren Feld oben "Bühnenbilder" aus, erhält man ein Grafiksystem zur Gestaltung (nächstes Bild; da ist vieles möglich):

Gleiches gilt in etwa für die Figuren. Akteure (Figuren) auf der Bühne sind ein Ball und ein Schläger (Paddle). Die Figuren sind unter der Bühne aufgeführt und sind anklickbar. Klickt man den Ball an, erhält man die Darstellung vom ersten Bild. Ganz rechts werden nun alle Skripte zur ausgewählten Figur dargestellt, bzw. können erzeugt werden.
Oberhalb der Figuren gibt es wie bei den Bühnenbildern Möglichkeiten zur Gestaltung dieser.

        Mit Anklicken von erhält man eine Liste vorhandener Spieler, es wurde ein Ball ausgewählt.
Den Spieler Ball kann man gestalten und mit Programmen zu gewünschten Aktionen verhelfen.
Im mittleren Bildschirmbereich (beim "Raspi" links) kann man oben auswählen, was man tun will. Wählt man "Kostüme" (ein Schauspieler verändert eben durch Kostüme sein Aussehen) bietet das System mögliche Gestaltungsformen an, in diesem Fall gibt es Bälle in anderer Farbe (links).
Klickt man auf "Skripte" erhält man alle Befehlsblöcke zur Gestaltung der Programme für diesen Spieler (rechts, jetzt alle Steuerungs-Befehle). Ganz rechts auf dem Bildschirm erscheinen dazu die schon vorhandenen Programme, bzw. eine leere Fläche zur Gestaltung der Programme, das erste Bild zu dieser Aufgabe zeigt die Situation.

    Und das sind die Programme zur Steuerung des Balls:
Der Ball muss 3 Aktionen ausführen:
  1. allgemeine Bewegung in dem Raum (oberstes Skript)
  2. Änderung der Bewegung bei Berürung des Balls mit dem Schläger (mittleres Skript)
  3. Beendigung der Bewegung (des Spiels; unterstes Skript)

Alle 3 Skripte werden unabhängig voneinander ständig ausgeführt.

Skript 1 (allgemeine Bewegung)
Es gibt eine Endlos-Schleife, in der sich der Ball in der vorgegebenen Richtung immer um 15 Schritte auf die nächste Position bewegt. Berührt er den Rand soll er abprallen (das passiert quasi nach den Lichtgesetzes: Ausfallwinkel = Einfallwinkel). Der Winkel wird vor der Schleife auf 45° festgelegt.
Der Befehl zuvor legt lediglich die Startposition des Balls fest.

Skript 2 (Schläger trifft den Ball)
Wo und wie der Schläger trifft, ist völlig beliebig (kann man bei weiteren Spielen zur Richtungsänderung des Balls nutzen).
Es gibt wieder eine Endlosschleife in der "Nichts" passiert, solange der Schläger nicht den Ball berührt.
Dann aber (falls)
wird zunächst der "Treffer-Zähler" um 1 erhöht, die Richtung des Balls um 180° geändert (er bewegt sich auf der gleichen Richtung zurück), dann wird ein Ton erzeugt (kann entfallen) und es wird eine Sekunde gewartet, würden sich wahrscheinlich sonst mehrfach berühren.
Der Treffer-Zähler muss natürlich zuvor außerhalb der Schleife auf einen Startwert gesetzt werden (0).

Skript 3 (Spiel-Ende)
Das funktioniert, da bei der Bühnengestaltung am unteren Rand ein markanter Strich gezogen wurde, markant ist in diesem Fall die rote Farbe.
Die Endlos-Schleife wird nur unterbrochen, wenn der Ball (genau) die Farbe rot berührt. Dann werden mit dem Befehl: "stoppe alles" alle Prozesse beendet.

Man kann jedes Skript durch Klicken auf die darüberliegende Fahne starten, das Spiel funktioniert damit aber nicht. Der Start aller Skripte erfolgt mit der Fahne über der Bühne, vorzeitiges Beenden mit dem roten Knopf.

Was fehlt, ist die Bewegung des Schlägers?

    Der Schläger (Paddle) wurde ebenfalls mit als "neue Figur" aus der Liste ausgewählt, eigentlich nur ein Strich.
Ganz wichtig ist, dass alle zu benutzenden Figuren vor dem Erstellen der Skripte vorhanden sind, denn nur dann erhält man den Zugriff auf diese, z.B. im 2.Skript für den Ball der Befehl nach der Schleife "wird ▼ berührt" ergibt beim Klicken auf ▼:
. Das Paddle erscheint nicht, wenn die Figur bisher nicht erzeugt wurde!
Wie soll er bedient werden?
Es wären die Kursor-Tasten möglich, in diesem Fall soll einfach der Mauszeiger genutzt werden. Das geht ganz einfach, indem in der Endlos-Schleife der Befehl "gehe zu ..." genutzt und dann Mauszeiger ausgewählt wird.
Jetzt folgt der Schläger jeglicher Mausbewegungen!

Eine kleine Änderung zum Spiel soll noch angebracht werden: "Immer nach 10 Treffern soll die Geschwindigkeit des Balls erhöht werden!"

    Dazu wird im 1.Programm für die Festlegung des Tempos eine Variable "tempo" festgelegt. Die muss natürlich außerhalb der Endlos-Schleife auf einen Anfangswert gesetzt werden, in diesem Fall auf 5.

Im 2.Programm werden die Treffer ausgewertet, hier muss dann auch das Tempo verändert werden. Das passiert nach dem Klang-Befehl durch Errechnen eines Wertes "wert" aus der Modulo-Operation des Treffers mit 10, es geht um den ganzzahligen Rest der Division durch 10. Der kann nur Werte von 0 bis 9 annehmen und ist für den Fall i * 10 immer 0. Nach diesem Wert wird in der nächsten Konstruktion gefragt. Ist das der Fall, wird durch den folgenden Befehl das Tempo um 5 erhöht (tempo = tempo + 5).
Das wird dann immer hektischer, bis man den Ball nicht mehr trifft!


AufgabeA3:
Würfel

Bei Betätigung einer beliebigen Taste soll eine Zufallszahl zwischen 1 und 6 ermittelt und mittels üblicher Punktedarstellung zur Anzeige gebracht werden.

    Das ist auch bereits der Algorhithmus,
nach Start des Programms soll eine Endlosschleife gestartet werden, an deren Anfang auf eine Tastatureingabe gewartet wird (Taste "any" soll betätigt werden - also eine beliebige Taste).
Danach erfolgt mittels Zufallsgenerator die Bereitstellung einer Zahl die danach mittels Fallentscheidung dargestellt wird, in diesem Beispiel wird nur die ermittelte Zahl angezeigt.

Bevor man nun die symbolische Darstellung programmiert, muss man die Art der Darstellung analysieren.
Vermutlich gibt es mindest 2 Möglichkeiten:

  1. die Punktedarstellung wird als Figur realisiert (auf einem Hintergrund (Bühne) erfolgt die Darstellung der Punkte als Grafik (Figur) oder auch zusammengesetzt aus Teilfiguren)
  2. die Punktedarstellung wird als mehrere Bühnen realisiert

Die 2. Variante soll realisiert werden.

    Zunächst wurden mit einem Grafiksystem alle Würfelbilder als jpg-Datei erzeugt und als Bühnenbilder w1 bis w6 geladen (linkes Bild: links erscheint das aktuelle, rechts alle Bilder).
Das rechte Bild zeigt das veränderte Programm.
Ist die Zufallszahl ermittelt ermittelt, erfolgt die Fall-Auswahl, in diesem Fall also 6 Fragen. Trifft der Fall zu, wird einfach zum entsprechenden Bühnenbild gewechselt.
Ganz wichtig ist jedoch, dass die Bühnenbilder und wenn vorhanden auch Figuren vor dem Programmieren vorhanden sein müssen, sonst kann man sie nicht auswählen!
   

Nun erscheint das Würfel-Bild sofort.
Es soll in einer Erweiterung so ein "Würfel-Efekt" eingebaut werden, es sollen in langsamwerdener Reihenfolge erst mehrer Zahlen erzeugt werden, bis er (der Würfel) bei der richtigen Zahl anhält.
Nun wäre es auch angenehm, wenn angezeigt wird, dass es die endgültige Zahl ist, bzw. wenn sie noch verändert wird.

    Die erste Veränderung besteht darin, dass in die Enlosschleife eine Zählschleife eingefügt wird, die in diesem Fall 5 mal durchlaufen wird. In der Zählschleife erfolgt die Ermittlung der Zufallzahl und die Fallentscheidung. Nun werden also 5 Bühnenbilder zufällig dargestellt. Das letzte bleibt stehen, ist also die gewürfelte Zahl.
Und es gibt noch eine weitere Variable "warte". Diese wird außerhalb der Zählschleife auf 1 gesetzt und dann am Ende in der Zählschleife um 1 erhöht. Dieser Wert multipliziert mit 0.1 ergibt eine wachsende Verzögerung zwischen den einzelnen Bühnenbildern - Würfeleffekt!

Die andere Forderung nach ok. der gewürfelten Zahl läßt sich einfach durch Figuren erfüllen. Sichtbar wird das in einer neuen Bühnendarstellung:

    Es wurden zwei Figuren, diesmal jedoch aus der Bibliothek , hinzugefügt.
Scratch funktioniert so, dass jedem Teil sein eigenes, bzw. seine eigenen Programme gegeben werden, die das realisieren, was diese Figur machen soll!
Startet man hier durch klicken auf die Fahne , dann wird nur dieses Programm gestartet, hingegen beim Klicken auf die Fahne über dem "Bühnen-Bild" , dann werden alle Programme des Projektes gestartet!
Die Programme sind eigenständig, können aber über Mitteilungen miteinander kommunizieren oder benutzen, wie in diesem Fall, gemeinsame Variable. Bei der Vereinbarung einer Variablen kann man entscheiden, ob sie "für alle Figuren" gelten soll, damit kann man also auf die Variable "warte", die in der Bühne vereinbart wurde, auch hier bei der Figur zugreifen. Das Programm für "ok - richtige Zahl" sieht dann etwa so aus:
    Wenn die Variable "warte" den Wert 6 hat, dann soll "sie" sich zeigen - wer soll sich zeigen? - na die Figur . In allen anderen Fällen (sonst) soll sie sich "verstecken", also nicht zu sehen sein.
Das Programm funktioniert, jedoch nur ein mal und damit wird es nicht richtig arbeiten!
    Damit es immer funktioniert, braucht es eine Endlosschleife.
Mit dem Start des Projektes läuft auch dieses Programm und kontrolliert ständig den Wert von "warte", führt eigenständig seine Aktionen aus.

    In gleicher Weise wird mit der Figur verfahren, nur die Frage wird anders gestellt.
beide Figuren werden auf der Bühne an die selbe Stelle plaziert, damit scheinen sie sich auszuwechseln. Die Figur hat noch ein anderes "Kostüm" erhalten, das Kreuz wird in rot dargestellt.

(Programm: Würfel     Dieses Programm zum Runterladen)

Und hier gibt es die Hardware-Lösung auf dem "Raspi": wuerfel_Raspi


Scratch Programme mit GPIO

(die Schriftfarbe in den Blöcken wurde auf Grund der besseren Sichbarkeit teilweise geändert!)

Das erste Programm wurde bereits unter Aufgabe1 beschrieben, es sollten 2 LED's abwechselnd angesteuert werden.

Ausgabe

    Für viele Aktionen, wie auch für die Ausgabe, werden die Befehle aus einzelnen Teilen erstellt. Der Grundbefehl wird aus der Gruppe "Steuerung" (braun) kopiert.
Zu beachten ist, dass bei der "Scratch" PC-Variante die Gruppe Steuerung in Steuerung (hellbraun) und Ereignisse (dunkelbraun) unterteilt wird. Bei "Scratch" auf dem "Raspi" befinden sich alle Strukturen der beiden Gruppen nur in der einen Gruppe "Steuerung" (braun).
In den Befehl
aus "Steuerung" wird aus der Gruppe "Operatoren" (hellgrün) die Operation
anstelle von "message1" eingefügt. Mittels Tastatur wird nun "hello" in "pin12" und "world" in "on" bzw. "off" geändert. (on legt auf pin12 eine 1, off eine 0)
Der Befehl ist nun funktionsfähig.
Interessant ist, dass die Operation "verbinde" nun eine andere Funktion erhält, als oben beschrieben, jetzt werden elektrisch Ausgänge verbunden und beschaltet.

 

AufgabeG2:
Es soll eine RGB-LED angesteuert werden.

    Die Schaltung ist sehr einfach.
Die LED hat 4 Anschlüsse (Beine), Masse, rot, grün und blau, die müssen wie LED's jeweils über einen Widerstand von 220Ohm angesteuert werden.

    Aus der Gruppe "Ereignisse" (bzw. "Steuerung" bei "Raspi") wird der "sende-Bef" entnommen:

In diesen wird nun anstelle von "message1" aus Gruppe "Operatoren" "verbinde" eingesetzt:

Auf "hello" kann die Pin-Nr und auf "world" "on/off", jetzt "on", eingetragen werden. Da die Pin's 11, 12, 13 genutzt werden, kann man die Auswahl des Pin 's dem Zufall überlassen. Dazu wird auf "hello" noch einmal "verbinde" abgelegt:

Aus dem "verbinde" "hello" "world" muss nun der zu schaltende Pin hervorgehen! Dazu wird auf "hello" "pin" (irgend ein pin) eingetragen. Welcher Pin soll als Zufall ermittelt werden, eine Zufallszahl zwischen 11 und 13, diese Zufallsoperation wird auf "world" abgelegt:

Nun ist der Befehl komplett (siehe auch links).

Eingabe
Als nächstes geht es um die Eingabe von Signalen vom technischen Prozeß.
Die GPIO-Kontakte verarbeiten digitale Werte, folglich kann nur eine 1 oder 0 genutzt werden!
Will man z.B. den Wert 13(dez) bearbeiten, dann braucht man 4 GPIO-Kontakte, bzw. 4Bit, also 1101(dual).
Grundsätzlich gilt für Eingänge von logischen Bauelementen, dass der Eingangswert immer definiert sein muss. Das gilt natürlich auch für die GPIO-Eingänge des "Raspi"! Damit das nicht zu Fehlern führt, sind bereits intern Pull-Up-Widerstände an den Eingangs-Pins vorhanden. Das gilt sowohl für die Pins, die ausschließlich als Eingänge verwendet werden, als auch für die, die wahlweise Ein- oder Ausgang sein können.

    Durch die Pull-Up-Widerstände wird auf jeden Eingang die Betriebsspannung +3,3V gelegt, diese wird als logisch 1 definiert. Wird nun der Taster betätigt, wird der Eingang auf Masse (GRD) gelegt, logisch 0. Das gibt elektrisch keine Probleme, da nun die Betriebsspannung zwar auf Masse gelegt wird, aber über den Widerstand fließt nur ein sehr kleiner Strom ( siehe dig. Schaltungen ).

Der Befehl zur Eingabe wird in "Scratch" ähnlich wie bei der Ausgabe aus verschieden Gruppen zusammen gesetzt.

    In den Befehl

aus "Steuerung" wird aus der Gruppe "Operatoren" (hellgrün) die logische Operation

eingefügt. Das Ergebnis ist bei Übereinstimmung 1 ansonsten 0. Mittels Tastatur wird "Oprd2" auf 0 gesetzt. Oprd1, die Eingabe, soll also mit dem Wert 0 verglichen werden, was völlig richtig ist, da am Pin auf Grund des Pull-Up-Widerstandes logisch 1 liegt. Betätigt man den Taster wird 0 angelegt, dann stimmt die Bedingung, 0 = 0 und es geht zum nächsten Befehl.
Für "Oprd1" wird aus Gruppe "füllen" (hellblau)

eingesetzt. Bei Anklicken von ▼ erhält man die Möglichkeit anstelle des "Regler" andere Sensoren zu wählen, in diesem Fall wurde "pin22" gewählt. Hat man nicht "Scratch" mit dem ErweiterungsTool "ScratchGPIO" gestartet, gibt es diese Auswahl nicht, man kann den Pin22 auch nicht mittels Tastatur eingeben!

Was ebenfalls ganz wichtig ist, ist die Tatsache, dass alle wahlweise als Eingang schaltbare Pins auch mit angegeben werden, eine extra Vereinbarung ist also nicht notwendig.

Alle Eingänge werden mit 0 geschaltet!

Es folgt ein Beispiel zur Nutzung der Eingabe:

AufgabeG3:
Es sollen eine LED mittels Betätigung eines Tasters
eingeschaltet werden und bei Loslassen des Tasters weiter leuchten.
Bei erneuter Betätigung das Tasters soll sie wieder ausgehen.
Der Ablauf soll beliebig oft wiederholbar sein!

Die Schaltung dafür sieht wie folgt aus:

    Nach Festlegung liegt pin22 über den Pull-Up-Widerstand auf logisch 1. Der Taster legt den Pin auf GRD (Masse), auf 0.
Die Anzeige erfolgt über die LED an pin12.

    Das ist das Programm zur Realisierung der Aufgabe.

Die Eingabe erfolgt wie beschrieben. Das Programm wartet an diesem Befehl, bis der Wert an pin22 0 ist. Dann folgt der Ausgabe-Befehl und pin12 wird mit on auf 1 geschaltet, die LED leuchtet.
Das Warten im nächsten Befehl ist notwendig, da man sonst keine Zeit hätte um den Taster wieder loszulassen. Nach dem nächsten Warten auf Eingabe wird die LED wieder ausgeschaltet.
Der Vorgang wird durch die umhüllende Schleife fortlaufend wiederholt!

Hält man den Taster dauernd gedrückt, blinkt die LED.

Das Beispiel zeigt die typische Arbeitsweise. Über den Eingang wird lediglich mitgeteilt, dass da eine Anforderung vorliegt, Werte aber nicht. Aus dem weiteren Programm muss nun also hervorgehen, was in diesem Fall zu tun ist!

Eine interessante Frage ist, was passiert, wenn ein wahlweises Ein- und Ausgabe-Pin, was bei der der Sensorauswahl mit angezeigt wurde als Ausgang verwendet wird?
Das soll mit pin40 probiert werden. Ein mit 220Ohm und LED beschalteter pin dürfte daran nicht kaputt gehen.

        Da beim Zusammen- und Einbau der Befehle immer irgend etwas im Programm durcheinander kam, wurden die beiden Befehle in der Programmebene extra aufgebaut. Durch Zufall stellte ich dabei fest, dass sie auch einzel funktionsfähig sind, man kann die LED durch Anklicken des jeweiligen Befehls an- und ausschalten - es geht also so mit pin40!
Man braucht keine extra Initialisierung der Ausgänge vornehmen!

AufgabeG4:
Pong-Spiel
Das oben am PC erstellte Pong-Spiel soll so geändert werden,
das die Bewegung des Schlägers über 2 Sensoren gesteuert wird.

    Der entscheidende Unterschied ist, dass keine Taster sondern Sensoren, also eine Verbindung des GPIO-Eingangs über Hautkontakt, genutzt werden sollen!
Das Problem liegt darin, dass die Haut eventuell einen größeren Widerstand hat, als die Pull-Up-Widerstände der GPIO-Eingänge. Damit kann man den Eingang dann nicht auf 0 ziehen. Man muß also die internen Widerstände sehr groß machen, was ja so nicht geht!?
Der "Raspi" bietet aber mit dem Befehl die Möglichkeit an, die Widerstände "wegzuschalten". Nun haben wir die Situation, dass die Eingänge undefiniert sind - es geht nicht!

    Es bleibt also wieder nur übrig, selbst Widerstände einzufügen. Diese müssen aber so groß wie möglich sein, damit das Verhältnis zum Hautwiderstand noch messbar ist, mit 10MegaOhm funktioniert das (sie müssenaber auch noch definiert eine 1 auf den Eingang legen).

        Im Unterschied zum PC-Programm bewegt sich der Schläger nur nach oben oder nach unten. Für diesen Teil soll das Scratch-Programm beschrieben werden (der Ball braucht natürlich auch Programme - so wie er sich bewegen soll).
Das Programm beginnt mit dem beschriebenen Befehl zum Wegschalten der Pul-Up-Widerstände. Danach wird der Schläger auf eine Startposition gesetzt und es folgt die übliche Endlosschleife. In der Schleife werden fortlaufend die Pins 24 und 26 abgefragt (es wird nicht auf die Eingabe gewartet!), wurde einer durch Berührung betätigt, wird eine Aktion mit dem Schläger ausgeführt (pin24 = 0, der Schläger wird um 20 Schritte nach oben bewegt, pin26 = 0, um 20 Schritte nach unten). Das geht natürlich nur bis an den Rand der Bühne. Wird der Wert überschritten, wird er auf den Maximalwert zurückgesetzt.
Man kann natürlich weitere Aktionen in die "falls-Befehle" einbauen, z.B. eine LED-Azeige.

 

AufgabeG5:
Aufbau eines elektronischen Würfels - Auslösung des Vorgangs mit Taster

Die Schaltung dafür sieht wie folgt aus:

    Mit 4 Adressen und deren Kombination kann man alle Würfelbilder darstellen:

Um z.B. die 4 darzustellen, braucht man die Adressen 16 und 18
In der Schaltung und der Beschreibung sind bereits die verwendeten Adressen angegeben, das können natürlich auch andere sein.

    So sieht das dann im Original aus - es wurde 5 gewürfelt.

    Das Programm wird in einer Enlosschleife ausgeführt, an deren Anfang auf die Eingabe vom "Pin26" gewartet wird (die Eigabe "pin26" erhält man nur, wenn das GPIO-System aktiviert wurde, der Füll-Befehl: wurde deshalb selbst gestaltet ). Wird durch den Taster der Eingangswert auf 0 gezogen, geht es weiter im Programm. Vom letzten Würfeln müssen alle Anzeigen zunächst ausgeschaltet werden (sende verbinde pini off). Danach ermittelt der "setze-Befehl" eine Zufallszahl zwischen 1 und 6, die dann in der Folge mittels 6 "falls-Befehlen" ausgewertet wird. Je nach Zahl schaltet man die entsprechenden LED's durch "on" auf der Adresse an.
Dann geht's wieder von vorne los.

    Ähnlich wie beim Würfel auf dem PC soll nun auch eine Variante mit "Würfel-Effekt" programmiert werden.
Prinzipiell funktioniert das so, dass mehrmals gewürfelt wird und dazwischen die Verzögerungszeit wächst.
Aber die Art der Programmierung ist anders, es wird so eine Art "Unterprogramm" verwendet. Der Teil zur Ansteuerung der LED's ist in allen Fällen gleich - also kann man den immer wieder nutzen, nur die gewürfelte Zahl ändert sich.
Das rechte Programm ist das Unterprogramm, welches vom linken Programm 5 mal aufgerufen wird. Da steckt auch die Schleife, die die Wiederholung organisiert.
Der Aufruf des Unterprogramms erfolgt durch eine Nachricht: "sende (Name) an alle". Alle anderen Programme kontrollieren darauf hin ("wenn ich (Name) empfange"), ob sie mit diesem Namen, in diesem Fall "wuerfeln" gemeint sind und stimmt das, beginnen sie zu arbeiten (was in diesem Fall stimmt)! Das Programm wird nur einmal durchlaufen.


 

AufgabeG6:
Bahn-Steuerung (V1)

Das große Ziel bei der Arbeit mit "Scratch" war die Steuerung eines technischen Prozesses.
Jetzt soll als erstes die Fahrspannung einer Modelleisenbahngesteuert werden.
Die Steuerung könnte etwa prinzipiell wie folgt aussehen:

Kurze Beschreibung:
Zunächst muss man den Wert der Fahrspannung bereitstellen.
Das kann durch Eingabe des Wertes oder durch Einstellung einer symbolischen der Technik angepaßten Eistelleinrichtung erfolgen (Block1).
Dieser Wert muss nun digitalisiert werden, günstiger Weise so, dass jedes Bit auf einem Speicherplatz bereitsteht (Block2).
Mit den so erzeugten Bits werden die GPIO-Kontakte angesteuert, Bit = 1 -> Kontakt on, Bit = 0 -> Kontakt off (Block3).
Im nächsten Schritt erfolgt der Übergang zur Elektronik, es wird ein Digital-Analog-Wandler gebraucht (Block4). Aus den Möglichkeiten wird ein aditiver dargestellt. Bit0, geringste Wertigkeit, erhält den Wert 1V, Bit1 hat die doppelte Wertigkeit 2V usw. Im Beispiel sind Bit0 und Bit1 = 1, die Addition ergibt natürlich 3V (das war der Eingangswert im Block1).
Dieser Wert wird entsprechend verstärkt als Fahrspannung auf die Schiene geschaltet.

Wir wollen uns nun nur um die 3 ersten Blöcke kümmern, dass ist der Teil der "Scratch"-Programmierung.
Block1 könnte man sich sparen, indem sofort die einzelnen Bits in die Speicherplätze geschrieben werden - diese Arbeitsweise ist umständlich (man muss die Digitalisierung selbst vornehmen) und hat nichts mit der üblichen Steuerung der Fahspannung zu tun!
Schaut man nach der Technik, so sind dort Drehknöpfe oder Schieberegler üblich. Prinzipiel muss zur Realisierung solcher Gebilde "Scratch" geeignet sein, denn Spiele zu programmieren ist eine der Zielstellungen der Sprache.
Vermutlich ist ein Schieberegler leichter zu realisieren als ein Drehknopf - probieren wir es!

    So sieht so ein Teil etwa aus.
Es gibt sie auch wagerecht, aber sinnhaft ist die senkrechte Variante, unten kleine Spannung (min. 0), nach oben größere. Der Schieber kann in der Natur jede Stellung einnehmen und damit jeden Wert zwischen Min und Max annehmen, es ist ja ein Analog-Regler. Nicht so bei unserer Rechnersimulation, es können nur einzelne Werte sein. Außerdem ist es auch nicht notwendig, denn üblicher Weise fährt die Bahn in Fahrstufen.
Ein weiteres Problem ist die Digitalisierung der eingestellten Werte. Je feiner die Einstellung gewählt wird, um so mehr Aufwand ist bei der Digitalisierung und der anschließenden Analogwandlung zu betreiben. Und man muss die Möglichkeit der Digitalisierung beachten, es macht kein Sinn 9 Fahrstufen vorzusehen, denn dazu braucht man 4 Bits, bei 8 Stufen wären es nur 3 Bits (mit 3 Bits 8 Stufen, mit 4 Bits 16 Stufen). Ich denke einmal, das 8 Fahrstufen (also 0 und 7 verschiedene Fahrspannunge) ausreichen sollten. Später muss man über die einzelnen Werte nachdenken.
Und so könnte es dann aussehen
   

Zur Programmierung des Problems kann man den gleichen Weg wie beim Würfel nutzen, also 8 verschiedene Bühnenbilder zu den 8 möglichen Stellungen des Schiebers.

    Diesmal soll jedoch anders verfahren werden.
Es gibt ein Bühnenbild (Schieberegler ohne Schieber) und eine Figur Schieber:

Der Schieber ist eine Figur, die sich in y-Richtung in Schritten bewegt. Mit "Scratch" geht das sehr gut.
Mit ⇑ (Pfeil nach oben) wird der Schieber um eine Einheit nach oben bewegt, mit ⇓ (Pfeil nach unten) nach unten und mit der "Leertaste" aus jeder Position auf die Stellung 0.

    Das ist das Programm für den Schieber (ein Teil).
Als erstes wird der Schieber auf die Stufe 0 gesetzt. Diese hat natürlich eindeutige Koordinaten, die man aber prima unterhalb der Bühne an der Position des Mauszeigers ablesen kann. Die Stufen werden durch die Variable "temp" beschrieben, die wird natürlich am Anfang auf 0 gesetzt. Danach wird fortlaufend in einer Endlosschleife die Tastatur abgefragt.
Wurde die Taste (Pfeil nach oben) gedrückt,so wird die Position des Schiebers um 19 (+19 nach oben; 19 wurde ermittelt als nächste Position des Schiebers) geändert und "temp" um 1 erhöht. Nun kann es natürlich sein, dass der Schieber schon auf Stufe 7 stand, dann ist die Position und "temp" falsch, was in der folgenden Frage ermittelt wird. Ist das so, dann wird die Position auf den maximalen Wert und "temp" aud 7 gesetzt und schon stimmt alles wieder.
Für den neuen Wert für "temp", der neuen Fahrstufe, muss nun auch die Digitalisierung des Wertes vorgenommen werden. Anders als in den verhergehenden Beispielen, in denen mit Start des Projektes auch alle Prozesse zur Berechnung gestartet werden, wird der Prozess zur Digitalisierung erst bei Bedarf gestartet, also jetzt mit .
Diese Anweisung ergeht an alle passiven Prozesse (passiv - Prozess arbeitet nicht ist aber bereit). Der Parameter "dig_ber1" wird von diesen Prozessen analysiert, stimmt er mit dem eigenen Namen überein, beginnt er zu arbeiten. Diese Arbeitsweise spart gegenüber der ständigen Arbeit des Prozesses Zeit für die Gesamtbearbeitung.
Das Ergebnis dieser Bearbeitung sind Werte in 3 Variablen (Werte 0 oder 1; Bit2, Bit1, Bit0).
Im nächsten Schritt wird mit wieder ein Prozess gestartet, der die Steuerung der GPIO-Kontakte vornimmt.
Am Ende muss man eine Verzögerung einbauen, man bekommt den Finger nicht schnell genug von den Tasten - folglich werden gleich mehrere Stufen übersprungen.

Digitalisierung

    Das Bild zeigt das Programm zur Digitalisierung des Wertes "temp", dabei gehört das rechte Bild unters linke Bild.
Als Algorhthmus wurde nicht der oben beschriebene verwendet, es wurden einfach alle möglichen Situationen aufgeschrieben. Für 3 Bits sind das wie hier 8 Fälle. Wollte man das auch für 8 Bits tun, wären 256 Fälle notwendig, das geht dann nur noch mit dem Algorhthmus. Als Variable für die Bits wurden "dig_regl0", "dig_regl1" und "dig_regl2" verwendet, wobei "dig_regl0" die geringste Wertigkeit 20 hat. Beispielsweise wird dann aus dem Wert "temp" =3:
"dig_regl2" = 0; "dig_regl1" = 1; "dig_regl0 = 1" also 011
Da diese Variablen als globale Variable vereinbart wurden, können sie nun auch von anderen Prozessen genutzt werden.
Im Gegensatz zum bisher benutzten Start-Kopf eines Prozesses wird nun der Start-Kopf genutzt. Dieser Prozess wird nur aktiv, wenn als Parameter "dig_ber1" übertragen wurde! Und das Programm wird nur genau einmal abgearbeitet, dann endet der Prozess, er ist wieder passiv.

Ansteuerung der GPIO-Kontakte

    Auch dieser Prozess ist passiv. Erst wenn der Parameter "anz_regl" übertragen wird, wird der Prozess aktiv und arbeitet einmal das folgende Programm ab.
Zunächst werden alle GPIO-Kontakte abgeschaltet (Ausgang = 0). Dann erfolgt die Überprüfung der einzelnen Bits ("dig_regli"). Ist der Wert 1, wird der GPIO-Kontakt angeschaltet (Ausgang = 1).
Ob diese Arbeitsweise für das Erzeugen der Fahrspannung ungünstig ist, muss noch getestet werden, eine andere Lösung ist nicht sonderlich schwer (falls-dann-sonst Befehl).

Der Regler funktioniert nun schon sehr ordentlich,
aber
es gibt ein Problem - der Zug kann nur in einer Richtung fahren
Das Problem kann man einfach mit einem Umschalter lösen, bzw. einem weiteren GPIO-Kontakt. Man definiert: links = 1; rechts = 0 (oder anders herum).

        Der Schalter wird mit den "Pfeiltasten nach links und nach rechts betätigt.
Da es so aussehen soll, als wenn der Schalter umschaltet, müssen beide Schalter je nach Situation an der selben Stelle ausgegeben werden.
   

Für diese Situation ist nun "Scratch" bestens geeignet. Man macht aus den beiden Schaltern Figuren, setzt sie an die selbe Stelle und legt durch Befehle für die jeweilige Figur ihr erscheinen fest:

Da das Projekt mit dem System aus dem Internet am PC erarbeitet und getestet wurde, stellt man dann aber bei der Überführung auf den "Raspi" zuweilen Unterschiede fest. Die Sichtbarmachung reagierte zum Teil anders.
Auch gibt es am "Raspi" keine "Any"-Taste wie in der PC-Version. Für die Bühne kann man weiteren Bilder aber anders laden. Die Figuren heißen Objekte.
Die Programme für die Figuren "Schalter" werden mit dem Start des Projektes gestartet, damit laufen sie parallel zum Regler.

    Das ist das Programm für den Schalter nach links.
Es gibt eine Besonderheit. Bei dem Vorbild der Modellbahn der Bahn funktioniert es so ähnlich. Mit einem Schieber kann man die Geschwindigkeit wählen. Was natürlich überhaupt nicht geht, ist bei Fahrt die Richtung ändern. Bei der Modellbahn soll es auch nicht gehen, also soll der Schalter nur umschalten können wenn "temp" = 0 ist, das ist in der ersten Frage enthalten. Was mir in der Folge Probleme bereitet hat ist dann die Auswahl des jeweiligen Schalters. Es wurden deshalb noch die Variablen "ml" (merk-links) und "mr" eingeführt. "ml" ist zugleich die Basis für die Ansteuerung des GPIO-Kontaktes.

Schalter rechts funktioniert ähnlich, nur wird der GPIO-Kontakt abgeschaltet.

(Test-Steuerung     dieses Programm kann man runterladen)

 

Mehr auf die Steuerung einer Modelleisenbahn zugeschnitten ist ein Regler für beide Fahrtrichtungen. Der könnte so aussehen:

    Der Schalter entfällt und ein Umschalten der Fahrtrichtung bei voller Fahrt geht auch nicht, denn das geht automatisch nur über 0.
Die Programmierung ist ähnlich wie zuvor, sogar etwas einfacher.
(Test-Steuerung (V2)     dieses Programm kann man runterladen)

Das genannte Programm wurde sowohl mit der PC-Variante als auch mit der "Raspi"-Variante getestet. Bei der PC-Variante können die GPIO-Kontakte natürlich nicht getestet werden.

    Kleine Probleme!
Das Bild zeigt den prinzipiellen Aufruf eines passiven Prozesses in den beiden Reglerprogrammen.
Die Variante1 wurde beim senkrechten Regler angewendet. Hinter jeder zutreffenden Bedingung erfolgte nach Bearbeitung auch der Aufruf des Prozesses.
Beim waagerechten Regler sollte der Aufruf (Aufruf2) einmal am Ende der Schleife erfolgen! Das Ergebnis ist, dass er ständig im 0.1sec Takt gestartet wird. Bei der PC-Variante ist davon nichts zu sehen, beim "Raspi" Flackern die Prozesse. Diese Arbeitsweise bringt Unruhe und Zeit wird auch nicht gespart. Bei der "Raspi"-Variante wurde also wieder bei jeder Bedingung der entsprechende Prozess gestartet (Aufruf1).


 

Scratch-Nutzung Einschätzung

"Wenn man programmieren kann, ist die Nutzung von "Scratch" ganz einfach"

Allerdings muss man dann auch einige Aktionen umständlich programmieren, wofür es in anderen Sprachen einfache Befehle gibt.

Und ganz wichtig ist der Algorhithmus!
Bevor man "losprogrammiert" muss der Algorhithmus zur Lösung meines Problems klar sein! Ohne geht es auch nicht mit Scratch!
Wenn ich nicht weiß, wie man z.B. aus einer Dezimalzahl eine Dualzahl erzeugt, kann man dafür auch kein Programm erstellen ( siehe oben )!