Deprecated: Assigning the return value of new by reference is deprecated in /www/htdocs/w009f8cd/blog/wp-settings.php on line 520

Deprecated: Assigning the return value of new by reference is deprecated in /www/htdocs/w009f8cd/blog/wp-settings.php on line 535

Deprecated: Assigning the return value of new by reference is deprecated in /www/htdocs/w009f8cd/blog/wp-settings.php on line 542

Deprecated: Assigning the return value of new by reference is deprecated in /www/htdocs/w009f8cd/blog/wp-settings.php on line 578

Deprecated: Function set_magic_quotes_runtime() is deprecated in /www/htdocs/w009f8cd/blog/wp-settings.php on line 18

Strict Standards: Declaration of Walker_Page::start_lvl() should be compatible with Walker::start_lvl(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1199

Strict Standards: Declaration of Walker_Page::end_lvl() should be compatible with Walker::end_lvl(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1199

Strict Standards: Declaration of Walker_Page::start_el() should be compatible with Walker::start_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1199

Strict Standards: Declaration of Walker_Page::end_el() should be compatible with Walker::end_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1199

Strict Standards: Declaration of Walker_PageDropdown::start_el() should be compatible with Walker::start_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1244

Strict Standards: Declaration of Walker_Category::start_lvl() should be compatible with Walker::start_lvl(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1391

Strict Standards: Declaration of Walker_Category::end_lvl() should be compatible with Walker::end_lvl(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1391

Strict Standards: Declaration of Walker_Category::start_el() should be compatible with Walker::start_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1391

Strict Standards: Declaration of Walker_Category::end_el() should be compatible with Walker::end_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1391

Strict Standards: Declaration of Walker_CategoryDropdown::start_el() should be compatible with Walker::start_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/classes.php on line 1442

Strict Standards: Redefining already defined constructor for class wpdb in /www/htdocs/w009f8cd/blog/wp-includes/wp-db.php on line 306

Strict Standards: Redefining already defined constructor for class WP_Object_Cache in /www/htdocs/w009f8cd/blog/wp-includes/cache.php on line 431

Strict Standards: Declaration of Walker_Comment::start_lvl() should be compatible with Walker::start_lvl(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/comment-template.php on line 1266

Strict Standards: Declaration of Walker_Comment::end_lvl() should be compatible with Walker::end_lvl(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/comment-template.php on line 1266

Strict Standards: Declaration of Walker_Comment::start_el() should be compatible with Walker::start_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/comment-template.php on line 1266

Strict Standards: Declaration of Walker_Comment::end_el() should be compatible with Walker::end_el(&$output) in /www/htdocs/w009f8cd/blog/wp-includes/comment-template.php on line 1266

Strict Standards: Redefining already defined constructor for class WP_Dependencies in /www/htdocs/w009f8cd/blog/wp-includes/class.wp-dependencies.php on line 31

Strict Standards: Redefining already defined constructor for class WP_Http in /www/htdocs/w009f8cd/blog/wp-includes/http.php on line 61
Physical Computing

JEP Opto

Optokoppler kann man zum hacken von Tasten aller möglicher Geräte verwenden. Einfach Kabel an die Handytaste löten und ins JEP Shield stecken.

lab_jep_opto

Mögliche Einsatzgebiete:
Hacks von Handys, MP3 Playern, Videorecordern, Fernbedienungen

Outputs:
3x Optokoppler

Inputs:
3x Input analog oder digital verwendbar

Specs:
gedacht für kleine Ströme

Extras:
Anschluss Logik Spannungsausgangs (5V und GND)
LED-Anzeige für Output
Servo-Anschluss

Dateien:
JEP Opto v0.6 Eagle-Datei
JEP Opto vo.6 Kupferbahnen (pdf)
JEP Opto Oberseite (pdf)

Bestückungsplan:
R1 – R6: 220 Ohm
R7: 100 Ohm
IC1 – IC3: 4N35

Potis (R8–R11): 100kOhm (Bauform: PT6KV)

1x Federleiste 32 Pins 4,2 mm Höhe, enge Kontakte
1x Stiftleiste 90 Grad 3 Pins für Servoanschluss
4x Printklemme 2pol RM 3,5
2x Printklemme 3pol RM 3,5

Stack Through Pinheader von www.samtec.com:
2x SSW-106-04-F-S
2x SSW-108-04-F-S

Demnächst im FRITZING-SHOP als Set erhältlich.

JEP Übersicht >

JEP Motor

Motortreiber für zwei 9 – 12 V Motoren.

JEP Motor

Mögliche Einsatzgebiete:
größere Motoren
Steppermotoren

Outputs:
2x Motortreiber

Inputs:
3x Input analog oder digital verwendbar

Specs:
9 – 12 V über externes Netzteil
max. 2 Ampere

Extras:
Überlastabschaltung

Dateien:
JEP Motor v0.6 Eagle-Datei
JEP Motor vo.6 Kupferbahnen (pdf)
JEP Motor Oberseite (pdf)

Bestückungsplan:

IC1: L6205
C1: 100uF
C2: 100nF
CBoot: 220 nF
Cp: 10 nF
CENA: 5.6 nF
CENB: 5.6 nF
D1, D2: 1N4148
Rena, Renb: 100 kOhm
D3: BY299 2Ampere
Rp: 100 Ohm
RAN1: 100 Ohm
DC Buchse
Br: Kabelbrücke

Potis (R4–R6): 100kOhm (Bauform: PT6KV)

1x Federleiste 32 Pins 4,2 mm Höhe, enge Kontakte
2x Printklemme 2pol RM 3,5
2x Printklemme 3pol RM 3,5

Stack Through Pinheader von www.samtec.com:
2x SSW-106-04-F-S
2x SSW-108-04-F-S

Optional: IC Kühlkörper

Arduino Beispielcode:

int A1Pin=10;
int B1Pin=11;
int E1Pin=9;

void setup(){
pinMode(A1Pin,OUTPUT);
pinMode(B1Pin,OUTPUT);
pinMode(E1Pin,OUTPUT);
}

void loop(){
analogWrite(E1Pin,240);
digitalWrite(A1Pin,HIGH);
digitalWrite(B1Pin,LOW);
delay(500);
digitalWrite(E1Pin,LOW);
delay(2000);
analogWrite(E1Pin,240);
digitalWrite(A1Pin,LOW);
digitalWrite(B1Pin,HIGH);
delay(500);
digitalWrite(E1Pin,LOW);
delay(2000);
}

Demnächst im FRITZING-SHOP als Set erhältlich.

JEP Übersicht >

JEP FET N

Oft benötigt man mehr Strom, als ein digitaler Output des Arduino-Boards zur Verfügung stellen kann. Dann kann man das JEP FET N Shield benutzen.

lab_jep_fet_n

Mögliche Einsatzgebiete:
Vibrationsmotoren
Superhelle LEDs
Peltier-Elemente
Glühbirnen

Outputs:
3x MOS-FET N Transistor

Inputs:
3x Input analog oder digital verwendbar

Technische Daten:
5 – 12 V über Arduino
1,5 V – 12 V per externer Stromversorgung
1 Ampere gesamt über Vin von Arduino

Extras:
Jumper für 5V oder Vin
Anschluss Logik Spannungsausgangs (5V und GND)
LED-Anzeige für Output
Servo-Anschluss

Dateien:
JEP FET N v0.6 Eagle-Datei
JEP FET N vo.6 Kupferbahnen (pdf)
JEP FET N Oberseite (pdf)

Bestückungsplan:

R1: 220 Ohm
R2: 220 Ohm
R3: 220 Ohm
R7: 1 kOhm
R8: 1 kOhm
R9: 1 kOhm
R10: 100 kOhm
R11: 100 kOhm
R12: 100 kOhm
R14: 100 Ohm

Potis (R4–R6): 100kOhm (Bauform: PT6KV)
FET1 – FET3: IRF 640 N (Bauform: TO 220)

1x Federleiste 32 Pins 4,2 mm Höhe, enge Kontakte
1x Stiftleiste 90 Grad 3 Pins für Servoanschluss
1x Stiftleiste 3 Pins für Spannungsselektor
1x Jumper
4x Printklemme 2pol RM 3,5
2x Printklemme 3pol RM 3,5

Stack Through Pinheader von www.samtec.com:
2x SSW-106-04-F-S
2x SSW-108-04-F-S

Demnächst im FRITZING-SHOP als Set erhältlich.

JEP Übersicht >

Arduino und iPod

Klar ist es eine gute Idee, einen iPod an Arduino anzuschließen, aber leider fehlen den guten Stück Lötstifte und Federleisten. Wie es doch noch klappt zeigt uns Jan von Freedoino.de.

Fritzing

Morgen erscheint die neue BetaVersion von Fritzing auf www.fritzing.org. Dann werden wir anfangen, die alten Schaltungen umzuarbeiten und Dateien für den Download zur Verfügung zu stellen.

2 neue Teile für Fritzing

Es gibt jetzt auch ein Batteriefach und ein Peltier-Element (sehr gut zum Heizen/Kühlen). Vorschaubild und Download findet ihr im aktualisierten Beitrag » Neue Teile für Fritzing.

Maschinen kommunizieren Teil 1

Mit etlicher Verspätung kommt nun heute endlich das Tutorial zur seriellen Kommunikation. Serielle Kommunikation bedeutet, dass die Daten hintereinander in Form von Strompulsen über eine Leitung geschickt werden (im Gegensatz zur parallelen Kommunikation wo Daten gleichzeitig über mehrere Leitungen geschickt werden).Im Mikrokontroller-Bereich ist die serielle Kommunikation traditionell die am häufigsten verwendete Methode, da sie vergleichsweise simpel und billig zu realisieren ist.

Für unseren Physical-Kurs sind 3 Szenarien besonders interessant:

  • Kommunikation von Arduino zu PC
  • Kommunikation von PC zu Arduino
  • Kommunikation von Arduinos untereinander oder mit anderen Schaltkreisen

Aufgrund der unterschiedlichen Anforderungen beim 3. Punkt, die den Rahmen dieses Beitrags leider sprengen würden, beschränken wir uns hier auf die ersten beiden Möglichkeiten.

Um überhaupt mit der seriellen Schnittstelle arbeiten zu können, brauchen wir auch erstmal eine Software die uns den Zugriff darauf gestattet. Hier funktioniert zum Beispiel PureData oder Processing sehr gut, für Flash brauch man dagegen eine Zusatzsoftware namens “SerialProxy”. Aufgrund der großen Nähe zu Arduino und der Einfachheit halber, wird in diesem Tutorial zunächst nur auf die Kommunikation zwischen Arduino und Processing eingegangen. Die grundlegenden Prinzipien sind aber überall gleich.

EINFACH, ABER INEFFIZIENT

Die einfachste Möglichkeit Daten zwischen Arduino und Processing hin und her zu schicken ist, sie in Form von Strings, also Zeichenketten zu versenden. Beide Programmierumgebungen bieten einfache Funktionen um Strings über die serielle Schnittstelle zu senden und zu empfangen.
Allerdings ist diese Methode nicht die effizienteste, wenn zum Beispiel Messwerte von Sensoren übertragen werden sollen. Beispiel: Der Sensorwert “206″ wird, wenn als String gesendet, zerlegt und hintereinander als “2″ … “0″ … “6″ gesendet. Der gleiche Sensorwert könnte, wenn als Zahl übertragen, mit nur einem Paket (bzw. Byte) geschickt werden.

Wenn ihr besonders viele Daten hin und her schicken wollt, oder es bei der Übertragung auf wenige Millisekunden ankommt, dann solltet ihr versuchen die Übertragung zu optimieren und auf solche Feinheiten achten. Bis dahin machen wir es uns jedoch einfach - hier der erste Arduino-Code:

/*
* AnalogInput
* by DojoDave <http://www.0j0.org>
* angepasst von Marcus <http://physical-computing.de>

* Dieser Code liest die Messwerte von einem Potentiometer
* und sendet sie über die serielle Schnittstelle als String
*
*/

int potPin = 5;    // Der Pin an den das Poti angeschlossen ist
int value = 0;      // Zwischenspeicher für die Werte

void setup() {
Serial.begin(9600);    // Starte die serielle Verbindung mit 9600 baud
}

void loop() {

value = analogRead(potPin) / 4;    // Wert vom Poti auslesen und auf 0..255 runter brechen
Serial.println(value);    // Sende Wert 0...255 als STRING inklusive Zeilenumbruch
delay(20);     // Kurze Pause, um Zeit für die Übertragung zu lassen
}


WAS MUSS MAN GENERELL BEACHTEN

In dem Quellcode oben sind 3 Punkte besonders wichtig für die Serielle Kommunikation. Da hätten wir zunächst Serial.begin(9600); in der setup-Methode, die dem Programm mitteilt, dass wir diese Technik verwenden wollen und - GANZ WICHTIG - die Übertragungsgeschwindigkeit festlegt.
Sender und Empfänger müssen immer auf die gleiche Geschwindigkeit eingestellt sein, da ihr sonst nur Datensalat erhaltet.

Die Funktionen Serial.print() oder Serial.println() senden dann die Daten über den Port, wobei Serial.println() standardmäßig nur Strings verschickt. Ganz wichtig ist auch, dass das Kürzel “ln” in der Funktio für “line” (also Zeile) steht und beim Aufruf der Funktion automatisch ein Zeilenumbruch mitgesendet wird. Das Zeichen sehen wir im Computeralltag eigentlich nie, trotzdem werden dafür 2 BYTE EXTRA übertragen, die wir anschließend beim Auslesen der Daten in Processing mitbedenken müssen.

Zu guter letzt ist das delay(20); nach dem Senden nicht unwichtig. Da der Controller auf dem Arduino Daten viel schneller erzeugen kann, als sie gesendet werden können und damit kein Paket verloren geht, machen wir so eine kurze Pause.


DIE GEGENSTELLE: DATEN EMPFANGEN MIT PROCESSING

Hier noch ein kurzes Stück Quelltext mit dem man die vom Arduino übertragenen Daten in Processing auslesen kann.

/*
* AnalogDemo
* von Marcus <http://physical-computing.de>

* Dieser Code empfängt Daten von der seriellen Schnittstelle
*/

import processing.serial.*;  // Wichtig, damit Processing überhaupt mit dem seriellen Port arbeitet

int potentiometer = 0;  // Variable in der wir den Wert erfassen
int linefeed = 10; // Enter-Tase = Linefeed = ASCII-Code 10
int ret = 13; // 2. Zeichen für Zeilenwechsel

Serial port;  // Variable für die serielle Schnittstelle

void setup () {
size(200,200);
port = new Serial(this, Serial.list()[0], 9600); // Für Mac-User
// port = new Serial(this, Serial.list()[Serial.list().length-1], 9600); // Für PC-User
}

void draw() {
if(port.available() > 0) { // Überprüft, ob Daten empfangen wurden
String data = port.readStringUntil(linefeed); // Liest eine Zeile bis zum Zeilenumbruch
potentiometer = int(data); // Konvertiert den String in eine Zahl
}
println(potentiometer); // Daten zur Kontrolle ausgeben

fill(potentiometer);  // Helligkeit des Applets entsprechend der empfangenen Daten
rect(0,0,200,200);
}

Wie man Daten von Processing an Arduino schickt, besprechen wir in Teil 2 dieses Tutorials (in Kürze).

Mehr Power: MOS-FET

Oft reicht es nicht, eine Schaltung mit einem normalen Transistor zu verstärken. Hier kann man auf Relais oder MOS-FETs (spezielle Transistoren) zurückgreifen. Das Anschließen unterscheidet sich etwas zum normalen Transistor, ist jedoch auch nicht komplizierter. Die Beine des MOS-FET heißen Gate, Drain und Source. Das Gate wirkt wie die Basis beim Transistor und schaltet den Durchgang zwischen Drain und Source. Source wird mit dem GND verbunden und Drain kommt an den Verbraucher (Motor o.ä.).

Wie beim normalen Transistor muss ein Widerstand (1 bis 10 kOhm) zwischen dem digitalen Output des Arduino-Boards und dem Gate geschalten werden. Zusätzlich soll ein sehr starker Widerstand ( 100 bis 200 kOhm) Störströme am Gate eliminieren. Er wird direkt mit dem Gate und dem GND verbunden.

Ich empfehle hier mal den IRF 640 N, den es bei Conrad für ca. einen Euro gibt. Er kann 18 Ampere schalten.

Neue Teile für Fritzing

Hallo,

in einer “Nacht und Nebel”-Aktion sind bei uns ein paar neue Teile für die Fritzing-Software entstanden, die wir euch natürlich nicht vorenthalten wollen.

Die Teile entsprechen vermutlich noch nicht den offiziellen Richtlinien für Fritzing und haben auch noch keine Footprints für Eagle - aber für den Moment reichen sie aus um Schaltungen in Fritzing zu sketchen, wir werden also demnächst die hier noch fehlenden Fritzing-Dateien nachreichen.

Neue Teile für Fritzing

Hinweis zur Installation: In der Zip-Datei findet ihr eine Verzeichnis-Struktur die 1:1 übernommen werden sollte. Sucht zuerst das Verzeichnis in das ihr Fritzing entpackt habt. Dort findet ihr dann das Unterverzeichnis libraries/user in welches ihr das Zip-Archiv entpackt. Und schon sind beim nächsten Start von Fritzing die neuen Teile in der Bibliothek vorhanden.

Download: Neue Teile für Fritzing (alpha)

Update (09.06.2008): Neu hinzu gekommen sind jetzt das Batteriefach und das Peltier-Element. Das ZIP-File zum Download wurde aktualisiert.

Servos ansteuern

Hallo,

heute gibt es ein kurzes Tutorial zum Thema Servomotor. Dazu brauchen wir ein Arduino und natürlich einen kleinen Servomotor der mit 5V betrieben werden kann [z.B. 230500 - 62 von Conrad].

Zunächst aber nochmal kurz gesagt, was denn der Unterschied vom Servomotor zum Elektromotor ist. Ein normaler Elektromotor erzeugt schlicht und einfach eine Drehbewegung, wobei man die Drehrichtung meist durch die Polung einstellen kann. Der einfache Elektromotor kann sich beliebig oft drehen, allerdings ist es schwierig genaue Bewegungen zu erzeugen - man kann nicht einfach sagen: “Jetzt 3 Umdrehungen vorwärts und dann 2 Rückwärts”.
Der Servo funktioniert komplett anders, da man normalerweise nicht mehr als eine halbe Umdrehung mit der Achse machen kann, diese aber auf wenige Grad genau steuern kann. Dazu ist im Servo bereits eine Steuerlogik und ein Getriebe verbaut.

Das Stecken der Verbindungen ist relativ einfach und in der Grafik ist das Breadboard eigentlich nur zur besseren Visualisierung vorhanden.

Servo am Arduino

Da es in Fritzing zur Zeit leider noch keinen Servomotor gibt, kann ich euch das Sketch nicht zum Download bereit stellen. Ich weiß aber vom Fritzing-Team, dass da bald was passieren wird.

Nun gut, jetzt ist der Servo vermutlich angesteckt, aber wieso hat der eigentlich 3 Kabel? Damit wir den Servo so genau steuern können, ist es mit Ein- und Ausschalten nicht getan. Um genau zu sein, ist der Servo eigentlich immer eingeschaltet und über das dritte (gelbe) Kabel geben wir ihm das Signal auf welche Position er fahren soll.

Da dieses Signal nicht ganz so einfach erzeugt werden kann, ist die Programmierung für einen Servo leider auch etwas komplizierter - insbesondere wenn man ihn in komplexen Projekten mit anderen Teilen kombinieren muss.

Das Steuersignal besteht aus einem sehr kurzen Strompuls, wobei die Länge des Pulses bestimmt auf welche Position der Servo fahren soll. Dieses Pulssignal muss wiederum solange wiederholt werden, bis der Servo seine endgültige Stellung erreicht hat, es genügt also nicht nur ein einziger Puls.

Hier jedenfalls der Code:

/*
Servo Steuerung

by Tom Igoe
additions by Carlyn Maw
translation by Marcus Paeschke
Created 28 Jan. 2006
Updated 7 Jun. 2006
Translated 9 May 2008

Die Werte für den kürzesten Puls (minPulse) und den längsten Puls
(maxPulse) können je  nach Modell des eingesetzten Servos variieren.
Im Idealfall sollten die Pulse zwischen einer und zwei Millisekunden
lang sein, in der Praxis  haben sich aber auch Werte zwischen
500 und 2500 Mikrosekunden bewährt. Probiert selbst aus, welche
Werte am besten für euch funktionieren.

Dieser Code benutzt die Funktion millis() um die Zeit zwischen den
Pulsen zu bestimmen. Die Funktion erzeugt allerdings nach etwa 5 Tagen
Laufzeit einen Speicherüberlauf, d.h. die Zahl wird größer als sie in
der Variable abgespeichert werden kann. Solltet ihr ein Programm
schreiben, was entsprechend lange laufen muss, denkt bitte daran.
*/

int servoPin = 2;     // Steuerpin für den Servo
int minPulse = 500;   // Minimalposition des Servos
int maxPulse = 2500;  // Maximalposition des Servos
int pulse = 0;        // Aktueller Pulswert

long lastPulse = 0;   // Zeitpunkt des letzten Pulses
int refreshTime = 20; // Kurze Erfrischungszeit dazwischen

boolean updown = true; // Gehts jetzt Hoch oder Runter

void setup() {
pinMode(servoPin, OUTPUT);  // Servopin ist ein Ausgabepin
pulse = minPulse;           // Position des Servos startet auf Minimum
Serial.begin(9600);         // Serielle Verbindung zur Kontrolle
}

void loop() {
if(updown) {
pulse++;
if(pulse >= maxPulse) {
updown = false;
}
} else {
pulse--;
if(pulse <= minPulse) {
updown = true;
}
}

// Neuer Puls nach der eingestellten Pause
if (millis() - lastPulse >= refreshTime) {
digitalWrite(servoPin, HIGH);   // Puls beginnt
delayMicroseconds(pulse);       // Länge des Pulses bestimmt die neue Servoposition
digitalWrite(servoPin, LOW);    // Puls endet
lastPulse = millis();           // Speichert die aktuelle Zeit
}
}

Noch ein paar Bemerkungen am Rande:
Um so länger die Zeit zwischen den Pulsen ist, umso langsamer bewegt sich der Servo. Die minimale Zeit zwischen den Pulsen entspricht der maximalen Pulslänge.

Werden Servos überstrapaziert, z.B. durch zu extreme Pulswerte oder permanente Bewegung unter hoher Last können sie heiß laufen, was schnell zum Defekt führt.

Servos gehören zu den elektromagnetischen Bauteilen, die eine Rückkopplungsspannung - auch genannt Blowback - erzeugen, welche dem restlichen Stromkreis nicht besonders gut bekommt. Bei dem oben eingesetzten Miniservo gab es bisher keine Probleme, solltet ihr jedoch stärkere Servos, normale Elektromotoren oder Relais einsetzen, solltet ihr eine Diode benutzen um den Stromkreis zu schützen. Näheres dazu findet ihr im Beitrag über das Relais bzw. in einem zukünftigen Artikel.

Als kleine Hausaufgabe könnt ihr ja mal ein Potentiometer in die Schaltung integrieren, mit dem die Position des Servos steuern kann.