Arduino: Ein Spannungssensor und der Serielle Plotter

Ich bastle mir gerade eine USV für eienen Raspberry CarPC. Eigentlich kein Problem: Der Raspberry hängt am Dauerplus. Nebenbei wird das Zündungsplus überwacht. Wenn dieses wegbricht muss der Raspberry herunter gefahren werden. Wie gesagt kein Problem, aber …

Bei den Tests in der Werkstatt fährt der Raspberry immer mal wieder unmotiviert herunter. Der Grund war auch schnell gefunden: Um etwas erschwerte Bedingungen zu schaffen, hatte ich hier ein kleines Ladegerät als Spannungsquelle verwendet. Dieses liefert offenbar eine zwar gleichgerichtete aber überhaupt nicht geglättete Spannung. Irgendwann misst die Überwachung des Zündungsplus dann eben auch zufällig mal einen Nulldurchlauf. Den Wert kann man zwar problemlos softwaremäßig glätten indem man mehrere Werte mittelt. Ich wollte aber doch mal genauer wissen, was aus diesem Ladegerät heraus kommt.

Dafür eignet sich ganz wunderbar der sowieso vorhandene Spannungssensor und der Serielle Plotter in der neuen Arduino-IDE

Anschluss des Spannungssensors

Voltage Sensor

Voltage Sensor

Diese Spannungssensoren sind im Prinzip ganz simple Spannungsteiler. Sie besitzen meist drei Anschlüsse, nämlich GND, VCC und SIG. GND wird mit GND des Arduino verbunden, VCC kommt an 5V und die analoge Signalleitung habe ich auf A1 gelegt.

Auf der anderen Seite verbindet man die beiden Pole der Spannungsquelle mit den entsprechenden Anschlüssen am Spannungssensor.

Arduino Software

Ein erster Versuch einfach das Signal auszulesen und dann direkt seriell auszugeben ergab zwei Erkenntnisse:

  1. die Spannung schwankt zwischen knapp über null und ca. 16 Volt
  2. die Messungen erfolgen zu langsam um genaueres sagen zu können

Hier der Sopurcecode:


--- schnipp -------------------------------------
int analogInput = A1;

void setup(){
   pinMode(analogInput, INPUT);
   Serial.begin(9600);
}

void loop(){
  Serial.println(analogRead(analogInput));
  delay(20);
}
--- schnapp -------------------------------------

und hier das Ergebnis im seriellen Plotter:

OK, zweiter Versuch: hier werden die Daten zunächst in einen Buffer geschrieben und erst anschließend an die serielle Schnittstelle weiter gegeben:

Sourcecode:


--- schnipp -------------------------------------
#define BUFSIZE 512
int analogInput = A1;

int buf[BUFSIZE];
int *p = buf;
int *p_end = p+BUFSIZE;

void setup(){
   pinMode(analogInput, INPUT);
   Serial.begin(9600);
}

void loop(){
  p=buf;
  while(p<p_end) *p++ = analogRead(analogInput);

  p=buf;
  while(p<p_end)
  { Serial.println(*p++);
  }
  delay(5000);
}
--- schnapp -------------------------------------

und hier der Plot der Daten:

Das einlesen der 512 Werte in den Buffer dauert auf meinem Arduino Nano exakt 57 Millisekunden. Bei 50 Hz müssten also etwa 5,7 Halbwellen sichtbar sein. Und das scheint hier auch der Fall zu sein. Man kann den Arduino also sogar als Oszilloskop verwenden.

Eine Arduino-Virtual-Wall für den IRobot Roomba

Einige unserer Türschwellen sind nicht voll Roomba-kompatibel. Der Staubsauger fährt in einer Richtung hinüber, kommt aber nicht wieder zurück weil sich dort ein etwas steilerer Absatz befindet der den Bumper auslöst. Die Schwelle wirkt sozusagen als Roomba-Ventil. Da bleibt einem nur die Türen geschlossen zu halten oder der Bau einer (virtuellen) Wand.

Eine virtuelle Wand ist ein einfaches Infrarot-Signal, dass dem Roomba mitteilt, dass es an dieser Stelle nicht weiter geht. Er verhält sich dann so als würde er an einer Hardware-Wand entlang fahren.

Benötigte Bauteile

Virtuellen Wände kann man natürlich käuflich erwerben (zum Beispiel drüben bei Amazon). Ich hatte die benötigten Teile für eine Arduino-Virtual-Wall in meiner Bastelkiste rumliegen, also habe ich mir mal so eine Wand selbst gebaut. Folgende Teile habe ich für den Prototyp verwendet:

  • 1 Arduino (hier Arduino Nano)
  • 1 Infrarot LED (hier TSAL5100)
  • 1 Widerstand (hier 39 Ohm)

Alles in allem kosten diese Bauteile so ca. 5 Euro.

Die TSAL5100 Infrarot-LED hat seine Peak-Wellenlänge bei 940 nm. Das scheint für den Roomba optimal zu passen. Der Abstrahlwinkel beträgt ± 10 Grad. Gefühlt scheint mir das etwas viel zu sein. In einem Abstand von 3 Metern hat der “Strahl” bei 20 Grad Abstrahlwinkel schon einen Durchmesser von gut einem Meter. Entsprechend abgeschwächt ist das Signal, das beim Roomba ankommt. Trotzdem erkennt er das Signal bei dieser Entfernung noch sicher.

Schaltplan

Naja, einen Schaltplan benötigt man für meine Virtual Wall eingetlich nicht. Ich habe trotzdem mal schnell einen gezeichnet. Meine Virtual Wall soll die Arduino-IRremote Library verwenden. Diese Library verwendet standardmäßig den Pin D3 des Arduino. Von D3 führt der Weg also über den Vorwiderstand (39 Ohm) weiter zur IR-LED und zurück zu einem der GND-Pins des Arduino.

Software

Die Software muss wie auch bei “normalen” Fernbedienungen ein 38kHz Träger-Signal erzeugen. Dieses Signal wird mit 1kHz moduliert. Das heißt die 38kHz Pulse werden in jeder Millisekunde ein- bzw. ausgeschaltet. Das ist mit dem Arduino leicht zu realisieren. Noch einfacher geht es mit der Arduino-IRremote-Library:


#include <IRremote.h>

IRsend irsend; // IRemote initialisieren (Pin 3)

void setup()
{ irsend.enableIROut(38); // 38 kHz Träger
}

void loop()
{ irsend.mark(1000); // 1 ms Mark
  irsend.space(1000); // 1 ms Space
}

Und hier noch kurz ein Zeitraffer-Video der virtuellen Wand im Einsatz: Die IR-LED befindet sich links etwa in der Mitte. Ich hatte die Schaltung etwas mit dem Gel-Akku abgeschirmt, damit der Roomba sie nicht überfährt. Der Infrarot-Strahl zeigt in Richtung untere rechte Ecke des Videos. Die Entfernung zwischen LED und gegenüber liegender Wand beträgt gut 3 Meter.

Nun muss das Ganze nur noch zusammen gelötet und in einem kleinen Gehäuse verstaut werden. Der IR-Empfänger sitzt vorn oben auf dem Gehäuse des Roomba. Deshalb darf die IR-LED nicht zu tief aufgestellt werden. Ansonsten schattet der Roomba selbst das Signal ab, wenn er dicht an der Virtual Wall vorbei fährt.

Werbung:

Siehe auch:

Weblinks

MYOG: Eine Rahmentasche fürs Fahrrad

Ich bin gerne auf ungewöhnliche Situationen eingerichtet. Neben meinem normalen Mini-EDC (Every Day Carry) brauche ich für kleinere Fahrradtouren ein paar zusätzliche Dinge wie zum Beispiel eine Regenjacke, Fahrad-Handschuhe usw. Bisher habe ich so etwas in meinem Korb herum gefahren. Da ich inzwischen aber eine eigene Nähmaschine besitze lag es auf der Hand, mir endlich mal eine vernünftige Tasche für diese Dinge anzufertigen. Und wo ist am Fahrrad Platz für eine zusätzliche Tasche? Natürlich mitten im Rahmen:

Natürlich ist die Idee nicht neu. Am Ende dieses Artikels habe ich einige Links zu anderen selbst genähten Rahmentaschen angefügt. Die haben mir bei meinem Projekt sehr geholfen!

Schablone

Schablone für meine Rahmentasche

Zunächst einmal muss geklärt werden, welche Form und Größe die Rahmentasche haben soll. Ich habe mir dafür eine Schablone angefertigt, die genau in den Rahmen meines Fahrrads passt. Um nicht mit der Kurbel und den vorderen Zahnrädern in Konflikt zu geraten habe ich unten ein wenig Platz gelassen.

Es ist sicher sinnvoll gleich auf der Schablone zu markieren, an welchen Stellen später die Halteschlaufen angebracht werden sollen. Allerdings ist es bei meiner Tasche im Laufe der Produktion noch zu ein paar Änderungen gekommen.

Als nächstes müssen die Materialien zusammen gesucht werden. Man benötigt den Stoff, einen (möglichst wasserdichten) Reißverschluss, Klettband und zwei kleine Stücke Gurtband. Natürlich braucht man auch noch eine vernünftige Schere, Kreide und eine Nähmaschine.

Ich habe einen Stoff namens “Breaker” von der Firma aktivstoffe.de verwendet. Dabei handelt es sich um ein wasserdichtes Polyestergewebe mit PVC-Beschichtung. Es scheint recht strapazierfähig zu sein und vor allem ist es nicht besonders teuer. (Ich bin immerhin Nähanfänger, da kann es schon mal zu Totalausfällen kommen)

Ausschneiden der Teile

Der Zuschnitt der Teile gestaltet sich recht einfach, Man muss nur darauf achten, dass die Teile größer ausgeschnitten werden, weil man eine Saumzugabe benötigt. Wie auf dem Foto zu erkennen ist habe ich die tatsächliche Größe der Teile mit Kreide markiert.

Man benötigt zwei Seitenteile, und ein umlaufendes Teil für die schmale Stirnseite. Eine Seite wird geteilt, um später den Reißverschluss einnähen zu können.Die kleinen Stoffstreifen am oberen Bildrand habe ich gar nicht verwendet. Sie waren gedacht, um aus optischen Gründen das Klettband abzudecken. Ich fand dann aber, dass die Tasche auch so ganz gut aussieht. Die kleinen Teile die am Reißberschluss liegen dienen als Abschluss beim Einnähen desselben.

Reißverschluss

Reißverschluss

Als nächstes wird der Reißverschluss eingenäht. Das ist mit Worten etwas schwierig zu erklären. Deshalb verweise ich auf das Video, dass ich unten verlinkt habe (ca. ab Minute 3:04). Das fertige Seitenteil soll etwa so aussehen wie auf dem Foto und es muss die gleiche Größe haben wie das andere Seitenteil.

Zuletzt werden die beiden Seitenteile mit dem schmalen umlaufenden Streifen verbunden. Dabei muss natürlich darauf geachtet werden, dass die Seiten, die später außen liegen sollen beim Zusammennähen noch innen liegen. Das Ganze ist etwas kompliziert, weil jetzt auch die Klettband-Laschen mit eingenäht werden müssen. Am Besten man markiert genau deren Position und schreibt auch gleich dabei, ob der Filz- oder der Hakenteil dort hin gehört. (Ich musste übrigens an dieser Stelle zwei mal den Nahttrenner bemühen). An dieser Stelle nerft es sehr, dass die Klettbandlaschen jetzt noch alle nach innen zeigen – sie backen ständig wild zusammen.

Nachdem die Tasche ganz zusammen genäht ist, wird sie durch die Reißverschlussöffnung umgekrempelt und kann sofort getestet werden.

Rahmentasche

Weblinks:

Netzsack

Nein, Netzsack ist nicht das Schimpfwort für Leute, die zu viel im Internet surfen ;-)

Netzsack

Netzsack aus einem Raschelsack

Auf mehrtägigen Trekking-Touren kommt es nicht selten vor, dass man Schmutzwäsche wie zum Beispiel nasse Socken außerhalb des Rucksacks trocknen möchte. Dafür ist ein Netzsack (Meshsack) sehr hilfreich. Wenn man gerade keine Socken trocknen muss, dann sorgt der Netzsack eben im Rucksack für Ordnung.

Solche Netzsäcke kann man käuflich erwerben. Gelegentlich bekommt man sie auch als Zubehör zu anderen Ausrüstungsgegenständen (z.B. als Aufbewahrungssack eines Rucksacks) mitgeliefert.

Oder man schneidert sich so einen Netzsack selbst. Ich habe jetzt mal einen 5 kg Kartoffelsack (Raschelsack) umgeschneidert. Das Ergebnis spricht für sich. Der neue Netzsack scheint ziemlich gut für solche Aufgaben geeignet zu sein. Er ist sehr stabil und im Gegensatz zum Aufbewahrungssack meines Rucksacks (110 Gramm) wiegt der Kartoffelsack inklusive Kordel gerade einmal 12 Gramm.

Kordel

Paracord als Kordel

Die Herstellung ist einfach. Man besorgt sich fünf Kilo Kartoffeln in einem Raschelsack. Die Kartoffeln verspeist man umgehend. Der Sack wird gegebenenfalls gewaschen. Das obere Ende wird sauber abgeschnitten und dann wird der Rand so umgesäumt, dass man eine Kordel durch den Saum ziehen kann. Als Kordel habe ich den Mantel eines Stücks Paracord verwendet.

Ich hatte die Naht sicherheitshalber doppelt mit einen Zickzack-Stich über zwei aufeinander gelegte waagerechte Stege des Netzgewebes gezogen. Für ein paar nasse Socken hätte wohl auch eine einzelne Naht ausgereicht ;-)

Werbung:

Ein paar Grundlagen zum Bau einer Barndoor Montierung

Sterne

Sterne ohne Nachführung

Nachts ist es ziemlich dunkel. Wenn man Sterne oder andere astronomische Objekte fotografieren möchte, dann muss man sie länger belichten. Da gibt es allerdings ein Problem. Die Erde bewegt sich offenbar tatsächlich. Statt knallscharfer Sterne bekommt man bei langer Belichtungszeit nämlich lange Striche.

Kein Problem, dafür gibt es Montierungen, die die Bewegung der Sterne ausgleichen. Eine von diesen Montierungen kann man auch als mittelmäßig begabter Hobby-Bastler leicht selber bauen, nämlich die Barndoor Monierung

Die Barndoor-Montierung (auch Scotch Mount) besteht aus zwei Brettern, die über ein Scharnier miteinander verbunden sind. Wenn wir nun eines der Bretter fest mit der Erde verbinden und auf dem anderen Brett die Kamera befestigen, dann müssen wir nur noch das Scharnier exaktgenau parallel zur Erdachse ausrichten und wir können die Drehung der Erde leicht durch langsames “aufklappen” der Bretter ausgleichen.

Nagut, man braucht dafür wackelfreie Scharniere und man muss ganz genau wissen, wie schnell sich die Erde dreht oder anders ausgedrückt wie schnell sich die astronomischen Objekte scheinbar am Himmel bewegen..

Bei der Sonne ist es einfach. Die steht alle 24 Stunden wieder (etwa) an der gleichen Stelle. Sie bewegt sich also (scheinbar) um 15° pro Stunde (360°/24) oder um 0,25° pro Minute (360°/24/60).

Bei den Sternen ist es etwas komplizierter, denn die Erde dreht sich ja nicht nur um sich selbst, sondern auch noch (rückwärts) um die Sonne. Sie dreht sich also pro Jahr nicht etwa 365,25 mal um sich selbst sondern 366,25 (genau 366,2422) mal. Die Sterne sind daher nicht nach genau 24 Stunden wieder an der gleichen Stelle am Himmel, sondern schon nach 23,9345 Stunden (23 Stunden, 56 Minuten und 4,099 Sekunden) oder 1436.068 Minuten. Näheres siehe zum Beispiel im Wikipedia Artikel Siderischer Tag)

Gut, zurück zu unseren Aufnahmen des Sternenhimmels. Wenn wir keine Striche sondern punktförmige Sterne aufnehmen wollen, dann müssen wir die Kamera pro Minute um exaktgenau 0,25068450797 Grad (360° / 1436.068 Minuten) nachführen.

Weblinks:

Schrittmotor 28BYJ48 am Arduino

Seit einiger Zeit werden bei Ebay kleine Getriebe-Schrittmotoren vom Typ 28BYJ48 mitsamt einem ULN2003 Treibermodul aus China für unter drei Euro angeboten. Ohne zusätzliche Versandkosten! Keine Ahnung, wie sich das rechnet. Das gleiche Paket aus Schrittmotor und Treibermodul gibt es aber auch bei inländischen Anbietern für unter fünf Euro. (Zum Beispiel hier über Amazon).

28BYJ48, ULN2003, Arduino

28BYJ48, ULN2003, Arduino

Getriebe Übersetzung

Diese keinen Schrittmotoren werden offenbar eigentlich eingesetzt, um Steuerungsklappen in Klimaanlagen hin und her zu bewegen. Den Herstellern war es also egal, welche Übersetzung das Getriebe ganz genau hat. Zumindest bei meinem Modell stimmt die angegebene Übersetzung von 1:64 nicht genau. Es hat ebenfalls die hier berechnete Übersetzung von 1:63,68395. Das bedeutet, dass nicht 4096 Steps pro Umdrehung nötig sind, sondern nur 4075,772… Steps. Für viele Anwendungen ist das wohl egal, aber wenn der Motor fortlaufend in eine Richtung drehen soll (z.B. als Sekundenzeiger einer Uhr), muss dieser Umstand berücksichtigt werden.

Anschluss an den Arduino

ULN2003

ULN2003

Ich habe hier die digitalen Pins 8, 9, 10,11 des Arduino zum Anschluss des Motor-Treibers verwendet. Für die ersten Versuche reichte die Versorgung aus dem USB-Port. Für ernstzunehmende Anwendungen ist natürlich eine externe Quelle nötig.

Der Jumper auf dem Schrittmotor-Treiber (rechts neben dem VCC-Pin) muss gesteckt bleiben. Wenn ich es richtig verstehe, dann kann man durch entfernen dieses Jumpers die Stromversorgung zum Motor unterbrechen.

Betrieb am Arduino

Ich habe gar nicht versucht die Arduino Stepper-Library zu verwenden. Offenbar gab (gibt?) es mit der bei diesem Motor Probleme. Außerdem wollte ich genauer verstehen, wie man mit so einem Schrittmotor umgeht.Prinzipiell habe ich bei meinen Versuchen auf die Lösung von Benutzer celem im Arduino Forum aufgebaut.

Laut Datenblatt soll der Motor in folgender Sequenz angesteuert werden:

In 1 In 2 In 3 In 4
0 0 0 1
0 0 1 1
0 0 1 0
0 1 1 0
0 1 0 0
1 1 0 0
1 0 0 0
1 0 0 1

Ein einfacher Sketch zum Testen sieht zum Beispiel so aus:

const int motorPin1 = 8;  // Blue   - In 1
const int motorPin2 = 9;  // Pink   - In 2
const int motorPin3 = 10; // Yellow - In 3
const int motorPin4 = 11; // Orange - In 4
                          // Red    - pin 5 (VCC)

unsigned int lowSpeed  = 10000; // Notabene: nicht über 16000
unsigned int highSpeed =  1000;

void setup() {
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{ unsigned long n = millis() / 3000; // 3 Sekunden

  switch(n % 8)
  { case 0: stop();               break;
    case 1: rechtsrum(lowSpeed);  break;
    case 2: stop();               break;
    case 3: linksrum(lowSpeed);   break;
    case 4: stop();               break;
    case 5: rechtsrum(highSpeed); break;
    case 6: stop();               break;
    case 7: linksrum(highSpeed);  break;
  }
}

void rechtsrum(unsigned int motorSpeed)
{ // 1
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 2
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 3
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 4
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 5
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 6
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 7
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 8
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);
}

void linksrum(unsigned int motorSpeed)
{ // 1
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 2
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 3
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 4
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 5
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 6
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delayMicroseconds(motorSpeed);

  // 7
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delayMicroseconds(motorSpeed);

  // 8
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delayMicroseconds(motorSpeed);
}

void stop()
{ digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
}

Werbung:

Weblinks:

Gabellichtschranke TCST1103 am Arduino

Für ein kleines Projekt benötige ich zwei Endabschalter. Dafür habe ich mir ein paar Gabel-Lichtschranken vom Typ TCST1103 besorgt. Das entsprechende Datenblatt gibt es zum Beispiel bei Vishay. Damit ich beim nächsten Mal nicht wieder ewig herum suchen muss, wie man das Teil am Arduino betreibt, hier eine kleine Anleitung:

TCST1103 am Arduino

TCST1103 am Arduino

Auf der kleinen Lichtschranke ist die Infrarot-LED mit dem Buchstaben E (Emitter) bezeichnet. Der Fototransistor ist entsprechend mit D (Detector) bezeichnet.

Im Prinzip habe ich die Schaltung aus dem Datenblatt verwendet. Allerdings habe ich als Vorwiderstand für die LED (bei 5V Versorgungsspannung) einen 220 Ohm Vorwiderstand verwendet. Beim zweiten Widerstand (vom Fototransistor zur Masse) habe ich etwas herum probiert. Der Wert war relativ unkritisch. 10K lieferte zum Beispiel sehr zuverlässige Ergebnisse.
Weblinks:

Werbung:

Hier noch der verwendete Arduino-Sketch:

/*
 * Testing TCST1103 on analog port 0
 *
 * Author:
 *   Heiner Otterstedt
 * 
 * Weblinks:
 *   http://www.hobby-werkstatt-blog.de
 * 
 */

int sensorPin = A0;
int ledPin = 13;
int sensorValue = 0;

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

void loop()
{ sensorValue = analogRead(sensorPin);
  Serial.println(sensorValue);
  if(sensorValue > 512) digitalWrite(ledPin, HIGH);
  else                  digitalWrite(ledPin, LOW);
  delay(200);
}

Amboss selbst gebaut

Zufällig las ich gerade bei Instructables einen Artikel über den Selbstbau eines Amboss aus einer Eisenbahnschiene. Da fiel mir ein, dass ich so etwas ähnliches vor gut dreißig Jahren auch mal gebaut habe. Da bei meiner Amboss-Version wohl keine ausführliche Anleitung nötig ist, um sie nachzubauen hier nur ein Foto:

Selbst gebauter Amboss

Aus einer Eisenbahnschiene selbst gebauter Amboss

Gut, man sieht ihm an, dass ein Amboss nicht unbedingt ein Werkzeug ist, dass ich täglich verwende, aber er hat mir über die Zeit schon häufig hilfreich zur Seite gestanden. Unter anderem ist auf diesem Amboss die Pflanzschaufel entstanden, die ich immer noch fast täglich benutze.

Siehe auch:

Weblinks:

Modifikation strafbar

Wenn bei mir irgendein Gerät nicht so arbeitet wie ich es erwarte, dann nehme ich es mir vor und baue es so zurecht, wie ich es gerne haben möchte. Und dabei ist mir vollkommen schnuppe, was der ursprüngliche Hertsteller des Geräts davon hält. Vollkommen schnuppe! Ist ja auch kaum vorstellbar, dass zum Beispiel der Hersteller meiner Tischbohrmaschine gerichtlich gegen mich vorgeht, weil ich seine Bohrmaschine entsprechend meinen Bedürfnissen verändert habe.

Wirklich?

Wie das Make Blog vor ein paar Tagen unter den Titel “Sony’s War on Makers, Hackers, and Innovators” berichtet, geht Sony in den Vereinigten Staaten gerade mit heftigsten juristischen Mitteln gegen Leute vor, die auf ihrer Playstation 3 Linux installieren wollen. Naja, was die Gerichtsbarkeit betrifft ist dort drüben in den USA bekanntlich so manches möglich. Da sind wir hier zum Glück vernünftiger.

Wirklich?

Sony Computer Entertainment hat es tatsächlich geschafft einen deutschen Richter davon zu überzeugen, dass es eine Straftat ist, die eigene Playstation zu erkunden und die Ergebnisse zu veröffentlichen. Gestern wurde durch richterlichen Beschluss die erste Wohnung eines Playstation-Besitzers durchsucht und sein Equipment beschlagnahmt.

Arduino IDE unter OpenSuse-Linux installieren

Um die Arduino-IDE unter OpenSuse installieren zu können müssen eine Reihe von Abhängigkeiten erfüllt sein. Diese Abhängigkeiten kann man natürlich relativ leicht händisch auflösen – einfacher geht es aber, wenn man das OpenSuse Arduino-Repsitory benutzt. Hier eine Minianleitung zur Installation an der Konsole (das Gleiche funktioniert natürlich auch mit Yast). In der Konsole gibt man als root folgende 4 Befehle ein:

  • zypper ar http://download.opensuse.org/repositories/home:/kwk:/arduino/openSUSE_11.3 arduino
  • zypper ar http://download.opensuse.org/repositories/CrossToolchain:/avr/openSUSE_11.3 cross-avr
  • zypper ref
  • zypper in arduino

Wer das Ganze lieber mit der Hand macht – bei mir (Suse 11.3, 64 Bit,  Gnome, …) mussten folgende Pakete installiert werden, um zuletzt die Arduino-IDE installieren zu können:

  • uisp-20050207suse-144.1.x86_64
  • gcc45-gij-4.5.0_20100604-1.9.x86_64
  • cross-avr-gcc-4.3.3_20100125-28.10.x86_64
  • cross-avr-binutils-2.19.1-33.5.x86_64
  • avrdude-5.10-44.9.x86_64
  • java-1_6_0-sun-1.6.0.u23-0.2.1.x86_64
  • gcc-gij-4.5-4.2.x86_64
  • rxtx-java-2.2pre2-4.6.x86_64
  • avr-libc-1.7.0-3.5.noarch
  • java-1_5_0-gcj-compat-1.5.0.0-114.1.x86_64
  • arduino-0022-6.1.x86_64

Siehe auch: