SCRATCH

http://sites.prenninger.com/arduino-uno-r3/franzis-maker-kit/scratch

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2017-08-12

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-franzis.maker.kit-scratch (xx Seiten)_1a.pdf




              S4A  =  Scratch for Arduino

Sie müssen sich nicht mehr mit der Arduino-IDE beschäftigen, sondern können die Sketche grafisch mit Scratch für Arduino erstellen.

Scratch (Programmiersprache)

Scratch ist eine erstmals 2007 veröffentlichte erziehungsorientierte visuelle Programmiersprache für Kinder und Jugendliche inklusive ihrer Entwicklungsumgebung und der eng verknüpften Online-Community-Plattform.



Quelle:
https://de.wikipedia.org/wiki/Scratch_(Programmiersprache)



********************************************************I*

About S4A

S4A - Scratch for Arduino

S4A ist eine Scratch-Modifikation, die eine einfache Programmierung der Arduino Open Source Hardware Plattform ermöglicht. Es gibt neue Blöcke für die Verwaltung von Sensoren und Aktoren, die mit Arduino verbunden sind. Es gibt auch eine Sensor-Report-Board ähnlich der PicoBoard ein.

Das Hauptziel des Projektes ist es, Menschen in die Programmierwelt zu locken. Das Ziel ist auch, eine hochgradige Schnittstelle zu Arduino Programmierern mit Funktionalitäten wie Interaktion mit einem Satz von Boards durch Benutzerereignisse zur Verfügung zu stellen


Quelle:
http://s4a.cat/




********************************************************I*

Graphische Programmierumgebungen (IDE) für Arduino


Der normale Ansatz zur Programmierung ist über die Standard Arduino IDE (Aktuelle Version 1.0.6), die wir alle kennen, (manche von uns auch) lieben und hassen gelernt haben.
Die Programmierung erfolgt dabei textuell, als Programmiersprache kommt C bzw. C++ zum Einsatz.

Quelle:
https://www.lxrobotics.com/graphische-programmierumgebungen-ide-fuer-arduino





********************************************************I*

S4A – Das deutschsprachige Scratch-Wiki

S4A bedeutet "Scratch for Arduino".
Einige findige Spanier haben hier eine wundervolle Modifikation entwickelt, das eine Programmierumgebung im Scratch-Design für den Arduino-Mikrocontroller zur Verfügung stellt.

Inhaltsverzeichnis

Funktion

Nachdem man sich das Programm S4A heruntergeladen hat und die Firmware auf seinen Arduino gebrannt hat, hat man Zugriff auf die Aktoren und Sensoren die man am Arduino angeschlossen hat.
So lassen sich z.B. Servos auf eine bestimmte Gradzahl drehen oder umlaufende Servos vor- oder zurückdrehen.
Man sieht im Scratchbildschirm welche Werte die angeschlossenen Sensoren haben und kann in Abhängigkeit dieser Werte entweder die Aktoren oder Scratchobjekte steuern.
Da das System äußerst interaktiv ist, hat man jederzeit ein direktes Feedback!
usw. usw.
Quelle:
https://scratch-dach.info/wiki/S4A





********************************************************I*
Scratch ist eine sehr einfach zu bedienen und lernen Sprache entworfen von der MIT Media Lab vor allem zur Einführung von Programmierung für Kinder im Alter von 7-16.
Eine Arduino-Erweiterung ist auf ScratchX verfügbar, eine Scratch-Schwester-Website, die experimentelle Erweiterungen hostet. Siehe die Anleitung für die experimentelle Arduino-Erweiterung für Scratch.
Der Quellcode der vorherigen (Desktop-) Version von Scratch wurde von einem anderen Team modifiziert, um S4A zu erzeugen, das Scratch-Programme liest, aber Erweiterungen enthält, um eine Teilmenge eines Arduino-Ein- / Ausgabegeräts zu nutzen.

LinksQuelle:
https://playground.arduino.cc/Interfacing/Scratch







********************************************************I*

Scratch for Arduino (S4A)

Über den Button gelangen Sie zur Internetseite von Citilab Projecte Scratch.
Dort können Sie sich unter "Downloads" die aktuelle Software- und Firmwareversion herunterladen.Download S4A

Über S4A

Bei Scratch for Arduino (S4A), handelt es sich um eine ikonisch-symbolische Programmierumgebung, die, wie der Name schon vermuten lässt, auf Scratch basiert und die Programmierung der Arduino-Mikrocontroller ermöglicht.
Es wird hier also eine für Programmieranfänger geeignete, sehr intuitiv bedienbare Programmierumgebung für Anfänger im Bereich des Physical Computing mit geeigneter Hardware kombiniert.
Vor Benutzung muss eine Firmware über die Arduino-IDE auf das Board gespielt werden, welche quelloffen zum Download angeboten wird.
Diese Firmware ist nichts anderes, als ein Programm, welches die Interaktion mit dem Board über S4A ermöglicht.
Leider ist es durch diese Lösung nicht möglich, in Scratch erstellte Algorithmen direkt auf dem Board zu speichern.
S4A eignet sich jedoch besonders gut für die ersten Versuche mit Arduino.
Es gibt einige über den Sprachumfang von Scratch hinausgehende Blöcke, die dazu dienen, die Sensoren und Aktoren zu verwalten.
Mit der hier verwendeten S4A-Version (1.4) stehen sechs analoge und zwei digitale Eingänge, je drei analoge (0-5V) und digitale (5V) Ausgänge, sowie je zwei Ausgänge für Continuous-Rotation-Servos und Standard-Servos zur Verfügung.
In der Programmierumgebung werden alle Eingänge überwacht, man kann also die jeweils anliegenden Werte zu jeder Zeit ablesen.
Mit S4A ist es möglich, mehrere Arduinos gleichzeitig zu steuern.
So können sich die Boards untereinander Nachrichten schicken und dadurch aufeinander reagieren.
Dies ist besonders für den Aspekt der Interaktivität von Interesse.
Es wird hierdurch möglich, nicht nur die Interaktion zwischen einem Board und seiner Umwelt, sondern auch verschiedener Boards untereinander mit einfachen Mitteln zu realisieren.
S4A bietet die Möglichkeit, so viele Boards gleich zeitig zu betreiben, wie es USB-Anschlüsse am entsprechenden Rechner gibt.

Hinweise

Leider sind die im Vergleich zu Scratch neu hinzugekommenen Bausteine alle in der Kategorie „Bewegung“ zu finden.
Leider sind in der Mac-Version unter dem Menüpunkt „Hilfe“ keine entsprechenden Hilfedateien hinterlegt.
Teile der Software wurden bereits ins Deutsche übertragen, jedoch sind einige Menüpunkte, Dialogfenster und vor allem die Arduino-Bausteine noch nicht übersetzt worden.
Hier bietet es sich an, zumindest für die Übergangszeit bis zur vollständigen Übersetzung der Entwicklungsumgebung, die englische Version zu nutzen oder eine Übersetzungshilfe zu erstellen, die von den Schülern genutzt werden kann.

Quelle:
http://www.cs.uni-potsdam.de/~mprz/s4a.html




********************************************************I*

Arduino mit Scratch programmieren

In diesem Post geht es darum, wie man den Arduino über Scratch programmiert.
Der große Unterschied zwischen Scratch und C++ ist, dass man in Scratch sogenannte Blöcke hat und man diese hintereinander hängt, anstatt Code zu schreiben.


Die Installation von Scratch für den Arduino

Um den Arduino mit Blöcken zu programmieren gibt es eine angepasste Scratch Version namens Scratch for Arduino(S4A).
Diese Programm kann man sich auf der offiziellen Website herunterladen. Die Installation geht auch schnell von der Hand, da man nur einen Speicherort angeben muss, und auswählen muss, ob man ein Desktop Icon erstellen will.
Da Scratch, ähnlich wie bei NodeJS, die Befehle immer live an den Arduino sendet, muss es einen Sketch auf dem Arduino geben, der die empfangenen Befehle ausführt.
Diesen Sketch könnt ihr hier herunterladen. Nachdem ihr ihn mit der Arduino IDE hochgeladen habt ist die Vorbereitung abgeschlossen.

Programme für den Arduino mit Scratch erstellen 

Wenn ihr Scratch startet sucht Scratch euren Arduino. Sobald er gefunden wurde, werden euch laufend die aktuellen Sensorwerte angezeigt.
Etwa die analog Inputs oder einige digital Pins.
Das erleichtert das Programmieren, da ihr dadurch überprüfen könnt, wie euer Arduino auf etwas reagiert und was er gerade misst.
Dafür muss der Arduino jedoch die ganze Zeit an euren PC angeschlossen bleiben und mit Scratch für den Arduino ist es auch nicht möglich ein Programm auf dem Arduino dauerhaft zu speichern.

Komischerweise wurde mein Arduino Uno als Arduino Duemilanove erkannt. Abgesehen davon hat jedoch alles einwandfrei geklappt.
Um nun ein erstes Programm für den Arduino zu erstellen, kann man sich in der rechten Spalte die passenden Befehle aussuchen.
Diese sind in 8 Kategorien eingeteilt.

Wenn wir ein blink Programm schreiben wollen, so muss erst die Led an pin-13 an sein, eine Sekunde gewartet werden, und die Led an pin-13 wieder ausgeschaltet werden.
Nach einer weiteren Sekunde warten, soll der ganze Vorgang wiederholt werden.
Das an- und ausschalten der Led befindet sich in der Kategorie Bewegung.
Das 1 Sekunde warten und die Endlosschleife in der Kategorie Steuerung.


Praktischerweise sieht man den einzelnen Befehlsblöcken immer an, wie sie verwendet werden können.
Wenn sie oben eine Einbuchtung haben kann man vor sie noch etwas stellen.
Wenn sie unten eine Ausbeulung haben kann man sie zu einer Reihe zusammenbauen.


Da ein Scratch Programm nicht auf den Arduino geladen werden muss, wird ein Bereich automatisch ausgeführt, sobald die jeweilige Bedingung zutrifft.
Dabei werden dann auch die jeweiligen Blöcke weiß umrahmt.


Scratch ist eine tolle und einfache Möglichkeit, um den Arduino grafisch zu programmieren.
Dabei gibt es jedoch auch einige Einschränkungen (immer mit PC verbunden), die negativ aufgefallen sind.


Quelle:
http://michaelsarduino.blogspot.co.at/2015/07/arduino-mit-scratch-programmieren.html

http://michaelsarduino.blogspot.co.at/2015/07/arduino-mit-scratch-programmieren.html







********************************************************I*

S4A - Einführung - Messen-Steuern-Regeln

Scratch4Arduino - Programmaufbau



Basis für das Programmiermodul S4A (Scratch4 Arduino) ist die Version 1.4 der Programier-sprache SCRATCH.
Die Befehle sind in 8 Gruppen unterteilt, die jeweils eine eigene Farbe haben.
Alle Befehlsbausteine einer Gruppe haben die gleiche Farbe.

 

Die Programmiersprache SCRATCH wurde speziell dafür entwickelt, grafische Animationen und Abläufe "kinderleicht" zu gestalten.
Darauf sind auch die einzelnen Befehle und Befehlsgruppen ausgerichtet.

Eine spanische User-Gruppe hat die Erweiterung SCRATCH4ARDUINO entwickelt, die eine Programmierumgebung im Scratch-Design für den ARDUINO-Mikrocontroller zur Verfügung stellt.
Damit ist es kinderleicht die Ausgänge des ARDUINO-Boards anzusteuern bzw. die Eingänge abzufragen.
http://msr.leo-edv.com/index.php?option=com_content&view=article&id=88&Itemid=88



In den letzten Jahren wurden grafische Softwareentwicklungsumgebungen geschaffen, die auf spielerische Weise den Zugang zu den Grundstrukturen der Programmierung ermöglichen. Scratch ist hier als die Referenz zu bezeichnen.
Damit ist es schon den Allerjüngsten möglich auf spielerische Weise zu programmieren.
Schon in der Primarstufe lässt sich mit der iPad App "Scratch Junior"
http://www.scratchjr.org
eine Vielzahl von kreativen Projekten realisieren.
So können die Kleinsten beim Erzählen einer Geschichte mit den vorgegebenen Figuren (Objekten) die immer gleichbleibenden Abläufe der Programmierung kennenlernen.
Dabei ist es nicht notwendig komplizierte Befehlswörter zu lernen.
Fertige Bausteine werden zusammengefügt und der Ablauf lässt sich sofort überprüfen und unerwartete Ergebnisse raschkorrigieren.
Für die größeren Kinder bietet sich die Web Version von Scratch als Plattform an.
Ein genialer Ansatz der Entwickler um Mitchel Resnikist die Möglichkeit die Programmierung aller veröffentlichten Projekte auf der Homepage

https://scratch.mit.edu

herunterzuladen und als Basis für eigene Projekte zu verwenden.


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


Quelle:
http://epict.virtuelle-ph.at/pluginfile.php/19470/mod_resource/content/2/Modul17_Einfuehrung.pdf







********************************************************I*

Scratch

Scratch ist eine visuelle Programmiersprache, die für den Einsatz in Bildungskontexten mit Kindern entwickelt wurde.
Die Einarbeitung ist sehr simpel, denn „programmiert“ wird über das einfache Ineinanderstecken und Verschachteln von Blöcken, die einzelne Befehle darstellen und wie Puzzleteile miteinander kombiniert werden können.
Sie können hierzu aus einer Übersicht mit unterschiedlichen Blocktypen auf eine freie Fläche gezogen werden.
Dies geschieht browserbasiert oder über einen Offline-Editor am Laptop.
Im Wesentlichen lassen sich in Scratch Spielfiguren oder Objekte (sog. Sprites, siehe Glossar) auf einem Hintergrund (der sog. Bühne) programmieren.
So entstehen selbstgebaute kleine Spiele oder Animationen, die sich wiederum auf der Scratch-Plattform veröffentlichen, bewerten und kommentieren lassen und auf anderen Webseiten einbettbar sind.













Mit Scratch sind so erste spielerische Gehversuche in der Programmierung von Software möglich.
Kombinieren lässt sich das Ganze mit dem Basteln eigener Hardware,
z.B. mit Makey Makey. Zudem gibt es unterschiedlichste Modifikationen.
Über das Projekt „Scratch 4 Arduino“ lässt sich
z.B. über Scratch ein Arduino ansteuern (siehe Artikel Arduino) und im browserbasierten BlocksCAD können Schüler 3D-Modelle in Scratch programmieren.

Internetadresse:
Quelle:
http://www.medien-in-die-schule.de/werkzeugkaesten/werkzeugkasten-diy-und-making/maker-werkzeuge/scratch/




********************************************************I*

Stefam Baireuther

Arduino der freie Microcontroller

Arduino

Der Arduino ist ein quelloffener Microprozessor. Download der Steuerungssoftware unter: arduino.cc

Links zum Arduino

ArduBlock

ArduBlock bietet eine grafische Programmieroberfläche für die Programmierung eines Arduino, die stark an Scratch angelehnt ist.

Im Gegensatz zu S4A (Scratch4Arduino) erzeugt diese einen einsehbaren Arduino-Code, übergibt diesen an die Arduino-Software und wird dann auf den Arduino hochgeladen.

Installation

Download der ArduBlock-Version der Mechotronik Hochschule Reutlingen unter https://github.com/letsgoing/ardublock

Eine erweiterte Version gibt es unter: https://sourceforge.net/projects/ardublock/files/

  • Windows/Mac: Im Ordner „Arduino“ folgende Ordner erstellen: /tools/ArduBlockTool/tool/
  • Linux: Im Ordner „sketchbook“ folgende Ordner erstellen: /tools/ArduBlockTool/tool/
Das heruntergeladene Archiv entpacken und die Datei ardublock-all.jar aus dem Ordner “JAR” in den erstellen Ordner „tool“ kopieren.
Arduino starten.
Unter „Tools“ findet sich nun der Eintrag „ArduBlock“ über den die grafische Entwicklungsumgebung für Arduino gestartet werden kann.
Alle Elemente werden einfach aus den Vorgaben auf der linken Seite herausgezogen und zusammengesetzt.
Nicht benötigte Bauteile werden in das linke Fenster gezogen. Mit einem Rechtsklick auf bestehende Elemente können diese kopiert werden.

Links zu ArduBlock

Beispiele

Nachdem ein Programm erstellt ist, muss dieses zuerst gespeichert werden.
Dann wird es mit einem Klick auf „Hochladen auf Arduino“ auf dem Arduino kopiert.
Mit einem Klick auf “Seriellmonitor” öffnet sich ein Fenster, in dem die Werte des Befehls “serial println” angezeigt werden.

LED

Die LED an „Digital 1“ blinkt im Sekundentakt

LED blinkt 

LED blinkt ArduBlock

void setup()
{
  pinMode( 1 , OUTPUT);
}

void loop()
{
  digitalWrite( 1 , HIGH );
  delay( 1000 );
  digitalWrite( 1 , LOW );
  delay( 1000 );
}

LDR




LED anzeigen

 LED anzeigen ArduBlock

Der Wert des lichtempfindlichen Widerstands wird im Serial Monitor angezeigt.

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Serial.print("LDR-Wert:");
  Serial.print(analogRead(0));
  Serial.println();
}

LED mit LDR dimmen

LED mit LDR dimmen

LED mit LDR dimmen ArduBlock



Der Wert des LDR wird in der Variable “Helligkeit” gespeichert, umgerechnet und dann an die LED gesendet.
Der Wert “970” hängt vom Widerstand ab und muss angepasst werden.
Zur Orientierung dienen daher die Werte im Serialmonitor.
int Helligkeit = 0 ;

void setup()
{
  pinMode( 3 , OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  Helligkeit = analogRead(0) ;
  Serial.print("LDR-Wert:");
  Serial.print(Helligkeit);
  Serial.println();
  Helligkeit = ( Helligkeit - 970 ) ;
  Serial.print("neuer Wert:");
  Serial.print(Helligkeit);
  Serial.println();
  analogWrite(3 , Helligkeit);
}

Taster

Der Wert eines Tasters wird ausgelesen und damit eine LED geschaltet. Ist der Taster gedrückt, leuchtet die LED.

Taster

Taster ArduBlock

int taster = 0 ;

void setup()
{
  Serial.begin(9600);
  pinMode( 7 , OUTPUT);
}

void loop()
{
  taster = analogRead(1) ;
  delay( 10 );
  Serial.print("message");
  Serial.print(taster);
  Serial.println();
  if (( ( taster ) > ( 1 ) ))
  {
    digitalWrite( 7 , HIGH );
  }
  else
  {
    digitalWrite( 7 , LOW );
  }
}

Taster als Impulsgeber

Ein Druck auf den Taster lässt die LED leuchten, ein weiterer Druck schaltet die LED wieder aus.

Taster

Taster ArduBlock

bool taster= false ;

void setup()
{
  pinMode( 7 , INPUT);
  pinMode( 8 , INPUT);
  pinMode( 7 , OUTPUT);
}

void loop()
{
  taster = digitalRead(8) ;
  delay( 200 );
  if (( ( taster ) == ( HIGH ) ))
  {
    if (digitalRead(7))
    {
      digitalWrite( 7 , LOW );
    }
    else
    {
      digitalWrite( 7 , HIGH );
    }
  }
}

Ultraschallsensor

Ultraschallsensor

Ultraschallsensor ArduBlock

Die Werte des Ultraschallsensors (in cm) werden im Serial Monitor angezeigt.

int UltraschallSensor(int SensorPin){
  long duration, cm; 
  pinMode(SensorPin, OUTPUT); 
  digitalWrite(SensorPin, LOW);  
  delayMicroseconds(2); 
  digitalWrite(SensorPin, HIGH); 
  delayMicroseconds(5); 
  digitalWrite(SensorPin, LOW); 
  pinMode(SensorPin, INPUT); 
  duration = pulseIn(SensorPin, HIGH); 
  cm =  duration / 29 / 2; 
  return cm;
}

void setup()
{
  Serial.begin(9600);
  digitalWrite( 11 , LOW );

}

void loop()
{
  Serial.print(    UltraschallSensor( 11 ));
  Serial.println();
}

Variablen

Eine LED wird gedimmt. Dazu zählt die Variable “Helligkeit” von 1 bis 30 und zurück.

LED dimmen LED dimmen ArduBlock

int Helligkeit = 0 ;

void setup()
{
  pinMode( 3 , OUTPUT);
}

void loop()
{
  while ( ( ( Helligkeit ) < ( 30 ) ) )
  {
    Helligkeit = ( Helligkeit + 1 ) ;
    analogWrite(3 , Helligkeit);
    delay( 100 );
  }

  while ( ( ( Helligkeit ) > ( 1 ) ) )
  {
    Helligkeit = ( Helligkeit - 1 ) ;
    analogWrite(3 , Helligkeit);
    delay( 100 );
  }

}

Servo-Motor

Ein Servo-Motor kann feste Werte (in Grad) einnehmen.

Servo

Servo ArduBlock

#include <Servo.h>

Servo servo_pin_5;

void setup()
{
  servo_pin_5.attach(5);
}

void loop()
{
  servo_pin_5.attach(5);
  servo_pin_5.write( 0 );
  delay( 1000 );
  servo_pin_5.write( 90 );
  delay( 1000 );
  servo_pin_5.detach();
}

Tresor

Ein 4-stelliger Code muss eingegeben werden.

Tresor Tresor ArduBlock

int zaehler = 0 ;
int w1 = 0 ;
int w2 = 0 ;
int w3 = 0 ;
int w4 = 0 ;
int wert = 0 ;

void setup()
{
  pinMode( 2 , INPUT);
  pinMode( 3 , INPUT);
  pinMode( 4 , INPUT);
  pinMode( 5 , INPUT);
  Serial.begin(9600);
  zaehler = 0 ;

}

void loop()
{
  while ( ( ( zaehler ) < ( 4 ) ) )
  {
    if (digitalRead(2))
    {
      delay( 300 );
      zaehler = ( zaehler + 1 ) ;
      w1 = ( zaehler * 1000 ) ;
    }
    if (digitalRead(3))
    {
      delay( 300 );
      zaehler = ( zaehler + 1 ) ;
      w2 = ( zaehler * 100 ) ;
    }
    if (digitalRead(4))
    {
      delay( 300 );
      zaehler = ( zaehler + 1 ) ;
      w3 = ( zaehler * 10 ) ;
    }
    if (digitalRead(5))
    {
      delay( 300 );
      zaehler = ( zaehler + 1 ) ;
      w4 = ( zaehler * 1 ) ;
    }
  }

  wert = ( ( w1 + w2 ) + ( w3 + w4 ) ) ;
  Serial.print("Wert:");
  Serial.print(wert);
  Serial.println();
  if (( ( wert ) == ( 4321 ) ))
  {
    Serial.print("Code erraten");
    Serial.println();
  }
  else
  {
    Serial.print("falscher Code");
    Serial.println();
  }
}

Zufallszahl

Das Programm erzeugt Zufallszahlen zwischen 1 und 6. Diese werden über den Serial Monitor ausgegeben.

Zufallszahl ArduBlock

int zahl = 0 ;

void setup()
{
  randomSeed(analogRead(A0) + analogRead(A1) + analogRead(A2));
  Serial.begin(9600);
}

void loop()
{
  zahl = (  random( 6 ) + 1 ) ;
  Serial.print("Zahl:");
  Serial.print(zahl);
  Serial.println();
  delay( 1000 );
}





Quelle:
https://baireuther.de/page/arduino/







DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE















Comments