Vorstellung eines aktuellen kleinen Weihnachtsurlaub Projekts (ab 22.12.)
Vorstellung eines aktuellen kleinen Weihnachtsurlaub Projekts.
Ich habe zwar schon ein paar Roboter mit jugendlichen gebaut, aber die Altersklasse für dieses Projektes ist neu für mich.
Die Herausvorderung ist:
begrenzter Fachwortschatz, Lese- und Schreibanfänger, kein Englisch.
Bisher nur Rechenregeln für Addition und Subtraktion bekannt (wegen ohmschen Gesetz etc.)
Noch keine schulischen Physikvorkenntnisse.
Also ist eine ganz andere Herangehensweise notwendig wie bei Acht- bis Zehntklässlern.
Momentan laufen die Vorbereitungen.
Um einen aktuellen Controller zu nehmen und nicht mit Assembler anzufangen, habe ich zwei Arduino Nano Clones und etwas Beiwerk (Sensoren und Motortreiber) besorgt und bin seit dem 4.12. da dran.
Erstes Fazit: die Arduino Refernz von der Webseite scheint unvollständig zu sein (Oder ich bin wiederholt Blind gewesen) Auf jeden Fall habe ich nur millis() gefunden, das es micros() gibt habe ich dann so ergoogelt.
Mein Großneffe (7 Jahre) interessiert sich seit neustem für Roboter (Aufräumen, Putzen, Geschirrspülen, Hausaufgaben machen und Treppensteigen soll er können).
Zu Nikolaus gab es den "Galileo - mein Roboter".
Das Ding hat zwei Motoren, zwei LEDs, sechs Taster und einen Einschalter.
Programmiert wird über die Taster.
Es gibt Programmiermodus an-aus, vor, zurück, links, rechts und Programm start.
Daß dad natürlich kein richtiger Roboter ist, sondern eher ein Automat mit einer Schrittkettensteuerung ist klar.
Die Motoren werden ohne Odometrie nur über einen Timer gesteuert. Somit sind dann die Schwenks auch nicht genau 90°,
sondern beim einen Motor über 100° und beim anderen grob 90°
Also kleines Projekt für den Einstieg in "richtige" Robotik:
(Vorgabe meiner Finazministerin: es darf "nichts" {wenig} kosten, damit scheidet Mindstorm aus obwohl schon genug LEGO vorhanden ist)
Als Exkurs habe ich erst mal ein Beispiel vorgesehen das ihm bekannt ist.
Da vor der Schule eine Fußgängerampel steht, also erst mal eine Ampelschaltung mit einem Arduino nano und als Erweiterung einen LDR für eine Nachtschaltung (Gelb für die Autos blinkt).
Mit dem LDR lernt er einen Sensor kennen, der eine Reaktion auf verschiedene äußere Einflüsse ermöglicht.
Schnell gestricktes Programm, schon mit dem LDR und bewust mit delay Befehlen.
Code:
int f_tast = 2;
int a_rot = 3;
int a_gelb = 4;
int a_gruen = 5;
int f_rot = 8;
int f_gruen = 9;
int f_lamp_tast = 13;
int s_licht = A0;
void setup() {
pinMode(f_tast, INPUT);
pinMode(a_rot, OUTPUT);
pinMode(a_gelb, OUTPUT);
pinMode(a_gruen, OUTPUT);
pinMode(f_rot, OUTPUT);
pinMode(f_gruen, OUTPUT);
}
void loop() {
int sensorValue = analogRead(s_licht);
digitalWrite(f_lamp_tast, HIGH); //Blinker an Taste fuer Fussgaenger
delay(500);
digitalWrite(f_lamp_tast, LOW);
delay(500);
if (sensorValue > 300){ //Dämmerungswert für Nachtschaltung
digitalWrite(a_rot, LOW);
digitalWrite(a_gelb, HIGH); //Autos Gelb für Blinker
digitalWrite(a_gruen, LOW);
digitalWrite(f_rot, LOW);
digitalWrite(f_gruen, LOW);
delay(500);
digitalWrite(a_gelb, LOW);
}
else {
digitalWrite(a_rot, LOW);
digitalWrite(a_gelb, LOW);
digitalWrite(a_gruen, HIGH); //Autos gruen
digitalWrite(f_rot, HIGH); //Fussgaenger rot
digitalWrite(f_gruen, LOW);
}
if (digitalRead(f_tast) == LOW){ //Taste Fussgaenger abfragen
digitalWrite(13, HIGH); //Taste Fussgaenger ist gedrueckt worden
digitalWrite(f_rot, HIGH); //Fussgaenger rot
digitalWrite(a_gruen, LOW);
digitalWrite(a_gelb, HIGH); //Autos gelb
delay(1000); // Autos Gelbphase
digitalWrite(a_gelb, LOW);
digitalWrite(a_rot, HIGH); //Autos rot
delay(500); // Fussgaenger Wartezeit damit kein Auto mehr fährt
digitalWrite(13, LOW);
digitalWrite(f_rot, LOW);
digitalWrite(f_gruen, HIGH); //Fussgaenger gruen
delay (6000); //Fussgaenger gruenphase
digitalWrite(f_rot, HIGH); //Fussgaenger rot
digitalWrite(f_gruen, LOW);
delay(1000); //Autos Wartezeit damit kein Fussgaenger mehr laeuft
digitalWrite(a_gelb, HIGH); //Autos gelb
delay(1000); // Autos Gelbphase
}
}
Der Taster für die Fußgänger um grün anzufordern, wird später auf Interrupt umgestellt, da die Delay Befehle ja dafür sorgen, das nur ein langer Tastendruck sicher erkannt wird (bzw. ein Tastendruck der genau zum Zeitpunkt der Abfrage erfolgt).
Um den Interrupt zu verstehen, gibt es ein kleines Spiel.
Ich stehe hinter meinem Großneffen und ihm gegenüber stehen seine Eltern.
Für die zyklische Abarbeitung hält seine Mutter alle 10 Sekunden einen Spigel hin, so da er sehen kann was ich hinter ihm mache.
(Ich halte von Zeit zu Zeit ein Handtuch hoch)
Das wird ein paar mal gemacht, dann kommt sein Vater ins Spiel.
Jedesmal wenn ich ein Handtuch hochhalte sagt er "Alarm", er ist also der Interrupt.
Die Variante mit Interrupt:
Code:
int f_tast = 2;
int a_rot = 3;
int a_gelb = 4;
int a_gruen = 5;
int f_rot = 8;
int f_gruen = 9;
int f_lamp_tast = 13;
int s_licht = A0;
byte f_press = HIGH;
void setup() {
pinMode(f_tast, INPUT);
pinMode(a_rot, OUTPUT);
pinMode(a_gelb, OUTPUT);
pinMode(a_gruen, OUTPUT);
pinMode(f_rot, OUTPUT);
pinMode(f_gruen, OUTPUT);
attachInterrupt(0, button, LOW);
//Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(s_licht);
//Serial.println(sensorValue);
// Blinker code zum Prüfen ob Programm läuft
digitalWrite(f_lamp_tast, HIGH); //Blinker an Taste fuer Fussgaenger
delay(500);
digitalWrite(f_lamp_tast, LOW);
delay(500);
if (sensorValue > 500){ //Dämmerungswert für Nachtschaltung
digitalWrite(a_rot, LOW);
digitalWrite(a_gelb, HIGH); //Autos Gelb für Blinker
digitalWrite(a_gruen, LOW);
digitalWrite(f_rot, LOW);
digitalWrite(f_gruen, LOW);
delay(500);
digitalWrite(a_gelb, LOW);
}
else {
digitalWrite(a_rot, LOW);
digitalWrite(a_gelb, LOW);
digitalWrite(a_gruen, HIGH); //Autos gruen
digitalWrite(f_rot, HIGH); //Fussgaenger rot
digitalWrite(f_gruen, LOW);
}
// if (digitalRead(f_tast) == LOW){ //Taste Fussgaenger abfragen
if (f_press == LOW){ //Statusvariable Taste Fussgaenger abfragen
delay(500);
digitalWrite(13, HIGH); //Taste Fussgaenger ist gedrueckt worden
digitalWrite(f_rot, HIGH); //Fussgaenger rot
digitalWrite(a_gruen, LOW);
digitalWrite(a_gelb, HIGH); //Autos gelb
delay(1000); // Autos Gelbphase
digitalWrite(a_gelb, LOW);
digitalWrite(a_rot, HIGH); //Autos rot
delay(1000); // Fussgaenger Wartezeit damit kein Auto mehr fährt
digitalWrite(13, LOW);
digitalWrite(f_rot, LOW);
digitalWrite(f_gruen, HIGH); //Fussgaenger gruen
delay (6000); //Fussgaenger gruenphase
digitalWrite(f_rot, HIGH); //Fussgaenger rot
digitalWrite(f_gruen, LOW);
delay(1000); //Autos Wartezeit damit kein Fussgaenger mehr laeuft
digitalWrite(a_gelb, HIGH); //Autos gelb
delay(1000); // Autos Gelbphase
f_press = HIGH;
}
}
void button(){
f_press = LOW;
}
Da der Galileo "Roboter" ja keinerlei Sensorik hat, will ich ihm erst mal zeigen was mit relativ einfachen Mitteln geht.
Also:
1- Bumper zu Kollisionserkennung. (ein Paar Mikroschalter aus Computermäusen per Wiederstandsnetzwerk an einem Analogeingang)
2- Linienfolge Sensor
3- Ultraschall Sensoren um Entfernungen (Abstände) zu messen.
4- IR Sharp GP2D120 um Treppenabsätze zu erkennen. (Kinderzimmer ist im ersten Stock)
(GP2D120 muß ich aber erst besorgen, habe zur Zeit keine mehr übrig)
Um ein Vorführbeispiel zu haben, habe ich mal mit einem Arduino nano, zwei HC-SR04 Ultraschallmodulem und einem Funduino Tracker Sensor (Linienfolgesensor mit 3 IR Reflexkopplern - TCRT5000)
ein Funktionsmuster gebaut.
Code:
const int us1_echo = 2;
const int us2_echo = 3;
const int us1_trig = 4;
const int us2_trig = 5;
const int lf_le = 8;
const int lf_ce = 9;
const int lf_ri = 10;
int lf_le_state = LOW;
int lf_ce_state = LOW;
int lf_ri_state = LOW;
unsigned long us1_echo_st;
unsigned long us2_echo_st;
unsigned long us1_echo_et;
unsigned long us2_echo_et;
unsigned long us1_srt;
unsigned long us2_srt;
unsigned long us1_dist;
unsigned long us2_dist;
unsigned long prev1micros = 0;
const long toggleinterval = 1000;
int togglestate = LOW;
int us1_flag = 0;
int us2_flag = 0;
char* string_[]={"Linefollow:", "US-Echo1:", "US-Echo2:", "Cycletime:"};
unsigned long prev2micros = 0;
void setup() {
Serial.begin(9600);
pinMode(us1_echo, INPUT);
pinMode(us2_echo, INPUT);
pinMode(us1_trig, OUTPUT);
pinMode(us2_trig, OUTPUT);
pinMode(lf_le, INPUT);
pinMode(lf_ce, INPUT);
pinMode(lf_ri, INPUT);
attachInterrupt(0, US1_ISR, CHANGE);
attachInterrupt(1, US2_ISR, CHANGE);
}
void loop() {
lf_le_state = digitalRead(lf_le);
lf_ce_state = digitalRead(lf_ce);
lf_ri_state = digitalRead(lf_ri);
unsigned long cur1micros = millis();
if (cur1micros - prev1micros >= toggleinterval) { //alle 10ms umschalten
prev1micros = cur1micros;
if (togglestate == LOW){
togglestate = HIGH;
digitalWrite(us1_trig, HIGH);
digitalWrite(us2_trig, LOW);
us1_echo_st = 0;
us1_flag = 0;
}else{
togglestate = LOW;
digitalWrite(us1_trig, LOW);
digitalWrite(us2_trig, HIGH);
us2_echo_st = 0;
us2_flag = 0;
}
}
us1_dist = (us1_srt / 58); // Umrechnung des Sensorwerts, ungefähr in cm (für 343m/s bei trockner Luft und 20° wäre 58,3 der genaue Wert)
us2_dist = (us2_srt / 58);
Serial.print(string_[1]);
Serial.println(us1_dist);
Serial.print(string_[2]);
Serial.println(us2_dist);
Serial.print(string_[0]);
Serial.print(lf_le_state);
Serial.print(lf_ce_state);
Serial.println(lf_ri_state);
unsigned long cur2micros = micros();
Serial.print(string_[3]);
Serial.println(cur2micros - prev2micros);
prev2micros = cur2micros;
}
void US1_ISR(){
if (us1_echo_st == 0) {
us1_echo_st = micros();
} else {
us1_echo_et = micros();
++us1_flag;
}
if (us1_flag == 1) {
us1_srt = (us1_echo_et - us1_echo_st);
}
}
void US2_ISR(){
if (us2_echo_st == 0) {
us2_echo_st = micros();
} else {
us2_echo_et = micros();
++us2_flag;
}
if (us2_flag == 1) {
us2_srt = (us2_echo_et - us2_echo_st);
}
}
Ergebniss der Ausgabe:
US-Echo1:226
US-Echo2:227
Linefollow:000
Cycletime:63440
Als nächstes kommen die Antriebe dran.
Da bin ich noch am Überlegen ob gehackte Servos mit Elektronik und Servo Library oder gehackt ohne Elektronik mit H-Brücke als Getriebemotoren.
Letzeres wäre vom Erklären her einfacher (Modell mit 4 Schaltern).
Ggf. ja später zwei Mikroservos out of the Box um mit den zwei US-Sensoren eine 360° Überwachung zu realisieren.
Da ja DC Motoren ohne Regelung nicht besser sind wie bei dem Galileo "Roboter", kommt dann das Innenleben einer Kugelmaus zu neuen Ehren (Odometrie).
Da suche ich allerdings noch den Karton wo die alten Mäuse drin sind.
Als Demonstrationsbeispiel nehme ich eine schwarz gestrichene Pringles Dose bei der man so nicht erkennen kann ob ich sie linksrum oder rechtsrum drehe.
Dann zwei Reihen Löcher versetzt in den Rand gelocht und eine Lampe (mit Pappblenden) innen rein um zu erkennen in welcher Reihenfolge beim Drehen die Lichter an und aus gehen.
Liste der Anhänge anzeigen (Anzahl: 2)
Zitat:
Zitat von
HaWe
Meine Favoriten sind ja immer noch die Lego Encodermotoren.
Man kann sie als einfache DC Motoren verwenden (L293-H-Brücken reichen), bei ca 2-3 U/sek kann man sie direkt an Radachsen ansetzen (und auch noch mit Lego Rädern und Chassis verbauen ), sie sind (gebraucht) einigermaßen preiswert, und die Encoder sind wirklich Top!
Es darf halt nichts (nur wenig) kosten.
Modelcraft RS-2 Servos habe ich hier halt noch einige in der Krabbelkiste liegen.
Beim Neupreis der Mindstorm Motoren würde ich für eigene Projekte auf die Pololu 12VDC mit Metallgetriebe und Quadraturencoder Wechseln oder halt richtige Encoder:
http://www.amazon.de/Encoder-Increme...hase+6mm+Shaft
und dann beliebige Motoren. (Die Pololu Encoder einzeln mit beliebigen Motoren wären dann die günstige Variante)
Aber mal sehen sollte er dabei bleiben, könnte es sein das passend zum schon vorhandenen Lego sich da was tut.
Zitat:
Zitat von
Rabenauge
Preiswerte Hindernissensoren:
http://www.ebay.de/itm/10pcs-IR-Infr...8AAOSwgQ9VrfV6
Hab ich mir neulich mal fünf Stück von besorgt- für _den_ Preis allemal gut.
Gibts auch in einer "Linienfolger"-Version und eine, bei der das Ding einfach nach unten guckt.
Sehr einfach zu handhaben (Strom ran, und dann ein simpler Digitalausgang) und funktionieren recht gut.
Selbst zweie davon nebeneinander (~5cm, das gabs Steckbrettl grade her) kommen sich nicht ins Gehege.
Auch toll zum rum probieren: die haben ne LED drauf für "ich sehe was"-die geht an, wenn er nen Hindernis entdeckt.
Mit nem bissel Treiberei könnte man damit nen Roboter sogar ohne Controller Hindernissen ausweichen lassen (sie schalten HIGH bei feier Bahn, und LOW wenn sie was entdecken).
Ja, die habe ich mir schon angesehen, der Preis ist beim Selbstbau nicht zu schlagen, (Da kommen die Teile ja schon teuerer wenn man sie in Kleinmengen holt)
Bei mir betreibe ich 38/40kHz IR Sensoren im Time Multiplex, da kann ich die wenn nötig dichter packen ohne das die sich in die Quere kommen. Und bei mehr wie 4 Stück spare ich Pins (ein Signaleingang, und 3 Adressausgänge für 7 Stück)
Wegen der Erkennung des Treppenabsatzes und anderer Abgründe, wird es später aber auf jeden Fall GP2D120 geben. (Auch wenn die teuere sind)
Für den Anfang schau ich die mir aber mal an.
- - - Aktualisiert - - -
Einmal die Ampelschaltung als Bild:
Anhang 31039
und der Schaltplan.
Anhang 31040
Liste der Anhänge anzeigen (Anzahl: 7)
Mal ein paar Bilder.
Sensor Testaufbau:
Anhang 31045
Da es möglichst wenig kosten darf und mein Großneffe auch was selbst machen möchte, hier mal meine Selbstbauräder aus Sperrholz und Dichtungen für 50mm Abflußrohren.
Einzelteile:
Anhang 31046
von der Seite:
Anhang 31048
zusammengebaut:
Anhang 31047
Da ich die Kiste mit den Mäusen nicht finde, eben ein Alublech für eine Encoderscheibe gemacht.
Anhang 31049
Auf dem Servo montiert
Anhang 31050
mit Sicht auf die Encoderscheibe
Anhang 31051
Da ich das Alublech, die Schrauben und das Sperrholz als Reste da habe, belaufen sich die Kosten pro Rad auf 0,45€ für die Dichtungen.
Ich habe noch ein paar SG-105F Reflex Lichtschranken da, da muß man zwar recht genau arbeiten, da die nur knapp 1mm haben, aber das geht schon.
- - - Aktualisiert - - -
Zitat:
Zitat von
Rabenauge
Was deine Antriebe angeht: Servos sind doch keine üble Wahl.
Auf arduinisch leicht anzusteuern...
Ich bin noch am Überlegen ob gehackte Servos mit Elektronik und Servo Library oder gehackt ohne Elektronik mit H-Brücke als Getriebemotoren.
Letzeres wäre vom Erklären her einfacher (Modell mit 4 Schaltern).
Das Projekt soll ja didaktisch für einen 7 jährigen möglichst viel bringen.
Zitat:
Zitat von
Rabenauge
Das mit der Kugelmaus interessiert mich übrigens auch brennend, wenn du das machst, erzähl mal bitte mehr drüber. Ich hatte mal versucht, eine Mäuse-Kamera mit nem Arduino zu verbinden, das funktioniert auch als Weggeber, aber nur bei extrem geringem Bodenabstand. So Kugelmausteile hab ich nämlich auch noch da, nur sind meine Elektronikkenntnisse eher rudimentär.
Habe festgestellt das die Kiste eingelagert ist (da ich alle Kisten in der Wohnung durch habe)
Plan B ist jetzt eine Aluscheibe mit einer Maskenfolie fürs Airbrush und schwarzem Mattlack in eine Reflektorscheibe zu verwandeln.
Mit zwei SG-105F Reflex Lichtschranken die im richtigen Abstand zueinander angeordnet sind, kann man dann einen Quadraturencoder wie bei einer Maus aufbauen.
Mit einem 4093 kann man einen Schmitt-Trigger für beide Kanäle aufbauen und mit einem 4069 und 4030 ein Summensignal bei dem jede Flanke an beiden Kanälen einen Puls auslöst. Also ein Signalverdopplung gegenüber den beiden Kanälen.
Dieses Signal kann man zum einen zum Regeln nehmen und zum anderen als Takt auf einen aus D-Flopflops und XOR aufgebaute Richtungsauswertung leiten die so aus beiden Kanälen ein DIR Signal erzeugt.
Damit wird die Auswertung relativ einfach.
Timerauswertung für das Summensignal und Pegelauswertung für das DIR Signal.
Liste der Anhänge anzeigen (Anzahl: 1)
Zitat:
Zitat von
oberallgeier
Die Ansteuerung der LED erfolgt
"gechirpt" (hier mehr davon) und nicht mit Dauerstrich,
Chirpen lasse ich erst mal außen vor, das kann je nach Entwicklung meines Großneffen in eins zwei Jahren kommen, wenn wir uns mit FMCW für Sensoren befassen.
Momentan will ich mit Festfrequenz anfangen.
Als Exkurs werden wir wohl einen einfachen Multivibrator mit Transistoren (Rechteck) und einen Phasenschieber Oszilator (Sinus/Dreieck) bauen.
Dann wird er sich aus dem Phasenschieber einen Durchgangsflöter als erstes eigenes Prüfgerät bauen.
Für die Sensoren werde ich dann wohl aus NANDs oder Invertern einen Generator bauen um die Frequenz zu erzeugen.
Dann muß mit den Portpins die jeweilige LED nur noch gegen GND geschaltet werden.
Erst mal wird je LED ein Receiver genutzt, dann werden wir testen in wieweit ein Receiver mit zwei zeitversetzt sendenden LEDs eine Einsparung von Receivern und Portpins zulässt.
(später dann eventuell mit zwei 4028 eine Adressierung der LEDs und der Receiver realisieren um mehr Sensoren mit wenig Portpins zu realisieren.)
Auch werden alle Teilsysteme immer erst mal separat aufgebaut und programmiert. Erst wenn sie einwandfrei funktionieren erfolgt die Integation in den zweiten Arduino nano.
Da wird dann mit Timing etc. wohl noch genug passieren was die Freude am ersten Erfolg wieder dämpft.
Nur eine Direktintegration bei der Entwicklung wird in diesem Alter wohl noch zu frustrierend sein, das möchte ich vermeiden.
Ich rechne eh damit das der Roboter mindestens drei mal komplett neu designed und aufgebaut wird.
Spätestens beim Treppensteigen, wird wohl ein Kettenantrieb fällig werden.
Bsp.: Anhang 31052
