Die Solar-Kugelbahn

April 2011
Die Solar-Kugelbahn
Idee:





Bau einer Kugelbahn mit elektrischem Aufzug
Solarzellen auf der Kugelbahn sollen den Aufzug mit
Energie versorgen
Energie soll in Kondensatoren zwischengespeichert
werden und bei Erreichen einer bestimmten Spannung
soll der Motor in Betrieb gesetzt werden
Die Kugelbahn soll nicht in der Sonne stehen, sondern
auch mit wenig Streulicht des Himmels zurechtkommen
(Platz am Fenster)
mit Hilfe der Mikrocontroller-Plattform "arduino" soll
einen ganzen Tag lang die Spannung und die
Stromstärke der Solarzellen gemessen und diese
Messwerte auf einer SD-Karte gespeichert werden, so
dass man eine Auswertung mit Excel machen kann. Auf
der SD-Karte soll auch gespeichert werden, wann und
wie oft die Kugel die Bahn herunterläuft
Siehe auch auf youtube:
http://www.youtube.com/watch?v=NDcqNYjmlyA
(hier im Sonnenschein, damit es schneller geht)
wesentliche Komponenten:
 Kugelbahn (Selbstbau aus Kiefernholz-Winkelprofilen)
 Aufzug (aus dem Kugelbahn-Set vom Versandhandel "pearl", Förderhöhe: 25cm)
 Motor des Aufzugs (Solargetriebemotor)
 Solarzellen (aus Mini-LED-Schlüssel-Taschenlampen (ebay) )
 Kondensatoren zur Speicherung der elektrischen Energie
 eine Schaltung, die die Kondensatoren mit dem Motor verbindet, wenn die Kondensatorspannung
genügend groß ist (eine solche Schaltung heißt "solar engine")
 zum Messen: arduino uno mit data-logging-shield (www.adafruit.com) und einem Operationsverstärker
Die Solarmodule:
Die Solarmodule habe ich aus Mini-Solar-Taschenlampen ("Mini LED Taschenlampe Solar Flashlight Key Ring")
ausgebaut, die es bei ebay für etwa 1 bis 2 Euro gibt (Man braucht etwas Geduld für die Lieferung aus Hongkong!).
In einer Entfernung von 30cm von einer 40-Watt-Glühbirne (matt) bringt ein solches Solarmodul etwa 4,5V
Leerlaufspannung und etwa 0,025 mA Kurzschlussstromstärke, also etwa 25 Mikroampere.
In einer Entfernung von 1,40m von der 40-Watt-Glübirne beträgt die Kurzschlussstromstärke noch etwa 1,5
Mikroampere.
Eine solche Mini-Taschenlampe enthält zudem eine aufladbare Batterie, 3 helle weiße LEDs, einen kleinen Schalter
und eine Diode.
Das rechte Foto zeigt die beiden Anschlüsse, die Diode ist dabei schon in Reihe geschaltet.
Vorsicht: Solarmodul beim Löten nicht zu stark erhitzen, sonst lösen sich die Kontakte von der Glasplatte!
Weitere Daten zum Solarmodul findet man unter: http://www.instructables.com/id/Solar-Spinner
Diode
Der Solar-Getriebemotor (RF 300 mit Getriebe):
(ein feines Motörchen mit Messing-Zahnräder,
erhältlich bei www.ellmitron.de für 8-9 Euro)
Die Schaltung (Solar-Engine von Miller):
6 - Solarmodule (etwa 5V Leerlaufspannung, parallel geschaltet)
1 - Solar-Motor RF 300 mit Getriebe
1 - Transistor PN2222
1 - Spanungsdetektor 1381-C (Panasonic, erhältlich bei www.solarbotics.com)
1 - Siliziumdiode (1N914)
1 - Speicherkondensator C1: (mehrere Elkos parallel mit insgesamt 10 000µF bis 60 000µF)
1 - Timer-Kondensator C2: Elko 1µF bis 5µF
weitere Infos zur Miller-Solar-Engine: http://www.solarbotics.com/assets/documentation/miller_solarengine.pdf
Die Performance des Systems
Die Kugelbahn steht unter einem schrägen Dachfenster und
wird zu keiner Zeit von der Sonne direkt beschienen.
Der Lift wird an einem bewölkten Tag öfter in Betrieb gesetzt
als an einem Tag mit klarem Himmel, da die Wolken
offensichtlich das Licht besser streuen.
An einem leicht bewölkten Tag rollt die Kugel etwa 70 Mal die
Bahn herunter. Der Lift muss dazu die Kugel etwa 25cm
hochtransportieren.
Der Motor muss etwa 10 Mal in Betrieb gesetzt werden, damit
die Kugel von unten nach oben transportiert wird, jeweils etwa
2,5cm. Es sind also etwa 10 Aufladevorgänge bis zum nächsten
Kugellauf nötig.
Die Kondensatoren werden jeweils bis 2,5V aufgeladen, dann
schaltet die Solar-Engine durch und die Spannung an den
Kondensatoren fällt nach ein paar Sekunden auf 1,5V zurück.
Jetzt beginnt der Aufladevorgang wieder von vorne.
Solche Aufladevorgänge finden etwa 700 Mal am Tag statt.
Die Solarzellenstromstärke ist ein gutes Maß für die Helligkeit:
Bei großer Helligkeit (leicht bewölkter Himmel) beträgt die Ladestromstärke durch die Solarzelle etwa 2000µA =
2mA und ein Aufladevorgang dauert etwa 35 Sekunden.
Bei geringer Beleuchtung (nachts, Solarmodule 1,4m von einer matten 40W-Grühbirne entfernt) beträgt die
Ladestromstärke der Solarzelle noch 5 bis 10 µA und ein Aufladevorgang dauert etwa 3 Stunden !
Die gleiche Ladestromstärke von 5 bis 10µA erreicht man, wenn man vor den 6 Solarmodulen ein Teelicht aufstellt,
das von der Mitte der Reihe etwa 7cm entfernt ist.
Die Diagramme zeigen die wesentlichen Daten (Kugelbahn steht am Dachfenster, C2 = 3,2µF):
 Die x-Achse zeigt die Zeit in Minuten, ab 6.00 Uhr morgens (am 28.3.2011, leicht bewölkt)
 Die grüne Kurve zeigt die Solarzellenstromstärke (=Ladestromstärke) in µA
 Die blaue Kurve zeigt die Spannung an der Solar-Engine (=Spannung an den Kondensatoren) in mV
 Die rote Kurve zeigt jeweils einen Peak nach unten, wenn die Kugel den Aufzug verlässt und ein Kugellauf
beginnt
Der ganze Tag
Die ersten vier Stunden
90 Minuten am Spätnachmittag
5 Minuten morgens um 8.00 Uhr
Man erkennt, dass die Kondensatorspannung zwischen 1,5V und 2,5V schwankt.
Bei geringer Ladestromstärke dauern die Aufladevorgänge länger und die Zeit zwischen zwei Kugelläufen verlängert
sich ebenfalls. Es finden etwa 70 Kugelläufe und etwa 700 Aufladungen statt. Nach etwa 820 Minuten ist die
Helligkeit so gering, dass die Ladestromstärke unter 5µA fällt und die Kondensatorspannung langsam abnimmt.
Ist die Kondensatorspannung noch klein, also der Kondensator noch wenig geladen, ist die Ladestromstärke größer
im Vergleich zu später, wo der Kondensator schon stärker aufgeladen ist. Deshalb ergibt sich auch für die
Stromstärke eine Zickzack-Linie. Die Schwankungen der Stromstärke sind aber gering.
Die beiden folgenden Diagramme zeigen Spannung und Stromstärke bei sehr geringer Beleuchtung (nachts, im
Abstand von 1,4 Meter zu einer matten 40-W-Glühbirne)
Man sieht, die Stromstärke nimmt beim Ladevorgang
von etwa 10µA auf etwa 5µA ab. Der Ladevorgang
dauert etwa 3 Stunden.
Auszug aus einer Logdatei, die vom Mikrocontroller arduino auf die SD-Karte geschrieben wird:
millis,time,voltage,way,current,brightness,number,number_between,
2036290, 6:0:2, 1310, 2900, 6, 30, 0, 0
2039280, 6:0:5, 1310, 2900, 6, 30, 0, 0
2042269, 6:0:8, 1304, 2900, 7, 30, 0, 0
2045258, 6:0:11, 1305, 2900, 6, 31, 0, 0
2048248, 6:0:14, 1310, 2900, 6, 31, 0, 0
2051237, 6:0:17, 1310, 2900, 6, 31, 0, 0
2054227, 6:0:20, 1309, 2900, 7, 31, 0, 0
2057233, 6:0:23, 1310, 2900, 6, 31, 0, 0
2060223, 6:0:26, 1315, 2900, 6, 32, 0, 0
2063212, 6:0:29, 1315, 2900, 6, 32, 0, 0
2066207, 6:0:32, 1310, 2900, 6, 32, 0, 0
2069197, 6:0:35, 1314, 2900, 7, 32, 0, 0
2072186, 6:0:38, 1309, 2900, 7, 32, 0, 0
2075176, 6:0:41, 1309, 2900, 7, 32, 0, 0
2078166, 6:0:44, 1309, 2900, 7, 33, 0, 0
2081156, 6:0:47, 1310, 2900, 6, 33, 0, 0
2084145, 6:0:50, 1319, 2900, 7, 33, 0, 0
2087135, 6:0:53, 1314, 2900, 7, 33, 0, 0
2090124, 6:0:56, 1313, 2900, 8, 33, 0, 0
2093114, 6:0:59, 1304, 2900, 7, 34, 0, 0
2096103, 6:1:2, 1314, 2900, 7, 34, 0, 0
2099093, 6:1:5, 1314, 2900, 7, 34, 0, 0
2102087, 6:1:8, 1314, 2900, 7, 34, 0, 0
2105077, 6:1:11, 1319, 2900, 7, 34, 0, 0
2108066, 6:1:14, 1319, 2900, 7, 34, 0, 0
2111056, 6:1:17, 1319, 2900, 7, 35, 0, 0
2114046, 6:1:20, 1313, 2900, 8, 35, 0, 0
2117036, 6:1:23, 1313, 2900, 8, 35, 0, 0
Es wurden etwa alle 3 Sekunden folgende Werte in die Logdatei geschrieben:
 "millis" gibt die Zahl der Millisekunden an, die seit dem letzten Start des arduino vergangen sind
 "time" gibt die Uhrzeit an (Stunden:Minuten:Sekunden)
 "voltage" gibt die Kondensatorspannung in mV an
 "way" ist 2900, nur beim Verlassen des Aufzugs wird der Wert auf 2650 gesetzt (Peak)
 "current" ist die Ladestromstärke in µA
 "brightness": hier wird zusätzlich die Helligkeit mit einem LDR gemessen, willkürliche Einheit
 "number" zählt die Aufladungen
 "number_between" zählt die Aufladungen zwischen zwei Kugelläufen
Der Schaltplan zur Messung der Daten:
Die Solarmodulstromstärke wird am Shunt gemessen. Der Wert des Shunts von 1 kOhm ist sehr groß, aber ich
wollte vor allem bei kleinen Stromstärken von 2µA bis 20µA gut messen können, so dass die Spannung am Shunt
nicht zu klein sein darf. Bei "großen" Stromstärken von etwa 2000µA geht natürlich viel Spannung an diesem
großen Widerstand verloren, aber die Solar-Engine arbeitet auch dann gut. Der dem Shunt nachgeschaltete 100Ohm-Widerstand kann zur Kontrolle durch das Multimeter ersetzt werden, das einen Innenwiderstand von etwa
100 Ohm für die Strommessung besitzt.
Bis etwa 325µA wird die Stromstärke über den Operationsverstärker LM358 ausgewertet (Analog-Eingang 2), ab
325 µA wird die Shunt-Spannung direkt am Analog-Eingang 3 ausgewertet.
Analog-Eingang 1 liest die Spannung am Solarmodul ein (Im sketch wird diese Spannung um die Spannung am
Shunt und am 100-Ohm-Widerstand vermindert, so dass man die Spannung an der Solar-Engine erhält).
Analog-Eingang 0 wertet den LDR aus.
Am Digital-Eingang 5 ist eine Kontaktschiene angeschlossen, die sich in der obersten Laufrinne der Kugelbahn
befindet: Links und rechts der Laufrille sind zwei Alu-Streifen angebracht, die beim Durchlaufen der Kugel leitend
verbunden werden. Dann ist der Digital-Eingang 5 auf hohem Potenzial.
Der arduino-sketch
/* sketch zum Datensammeln über die Solarkugelbahn
Es wird alle drei Sekunden die Solarzellenstromstärke
und die Solar-Engine-Spannung = Kondensatorspannung
gemessen, und mittels data logging shield auf eine
SD-Karte geschrieben */
#include <SdFat.h>
#include <Wire.h>
#include "RTClib.h"
#define redLEDpin 2
#define greenLEDpin 3
RTC_DS1307 RTC;
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;
int zaehler = 1;
boolean Durchgang = false;
int voltage;
int brightness;
long stromstaerke;
long strom2;
int pop_alle = 0;
int pop_dazwischen = 0;
boolean klein = true;
void setup(void)
{
Serial.begin(9600);
Serial.print(22,BYTE);
Serial.print(12,BYTE);
delay(5);
if (!card.init()) while(1);
if (!volume.init(card)) while(1);
if (!root.openRoot(volume)) while(1);
// create a new file
char name[] = "LOGGER00.CSV";
for (int i = 0; i < 100; i++)
{
name[6] = i/10 + '0';
name[7] = i%10 + '0';
if (file.open(root, name, O_CREAT | O_EXCL | O_WRITE)) break;
}
Serial.print(name);
delay(3000);
if (!file.isOpen()) while(1);
file.writeError = 0;
Wire.begin();
if (!RTC.begin())
{
file.println("RTC failed");
}
DateTime now;
now = RTC.now();
file.print("millis,time,voltage,way,current,brightness,number,number_between, ");
file.print(now.day(), DEC);
file.print(".");
file.print(now.month(), DEC);
file.print(".");
file.println(now.year(), DEC);
pinMode(redLEDpin, OUTPUT);
pinMode(greenLEDpin, OUTPUT);
pinMode(5, INPUT);
delay(5);
Serial.print(13,BYTE);
Serial.print(13,BYTE);
}
void loop(void)
{
if (digitalRead(5)==1)
{
Durchgang = true;
digitalWrite(greenLEDpin, HIGH);
}
if (zaehler == 12)
{
DateTime now;
now = RTC.now();
digitalWrite(redLEDpin, HIGH);
uint32_t m = millis();
file.writeError = 0;
file.print(m);
file.print(", ");
stromstaerke = 0;
// shunt = 1 kOhm
strom2 = 0;
for (int k = 0;k<20;k++)
{
stromstaerke = analogRead(2)+stromstaerke;
strom2 = analogRead(3)+strom2;
delay(1);
}
stromstaerke = (int) (stromstaerke/20.0*0.498+1.04);
strom2 = (int) (strom2/20.0*4.934+9.84);
if (strom2 > 325) stromstaerke = strom2;
analogRead(1);
delay(10);
voltage = (int) (analogRead(1)*4.86-stromstaerke*1.1); //1000 Shunt + 100 Multimeter
analogRead(0);
delay(10);
brightness = analogRead(0);
if ((voltage > 2200) && klein)
{
pop_alle++;
pop_dazwischen++;
klein = false;
}
if (voltage < 1600)
{
klein = true;
}
file.print(now.hour(), DEC);
file.print(":");
file.print(now.minute(), DEC);
file.print(":");
file.print(now.second(), DEC);
file.print(", ");
file.print(voltage);
file.print(", ");
if (Durchgang)
{
file.print(2650);
pop_dazwischen = 0;
}
else
{
file.print(2900);
}
file.print(", ");
file.print(stromstaerke);
file.print(", ");
file.print(brightness);
file.print(", ");
file.print(pop_alle);
file.print(", ");
file.print(pop_dazwischen);
file.println();
Serial.print(12,BYTE);
delay(5);
Serial.print(stromstaerke);
Serial.print("muA ");
Serial.print(brightness);
Serial.print("lx");
Serial.print(13,BYTE);
Serial.print(voltage);
Serial.print("mV ");
Serial.print(pop_dazwischen);
Serial.print("/");
Serial.print(pop_alle);
digitalWrite(redLEDpin, LOW);
if (voltage < 2100)
{
digitalWrite(greenLEDpin, HIGH);
if (!file.sync())
{
digitalWrite(redLEDpin, HIGH);
digitalWrite(greenLEDpin, HIGH);
while(1);
}
}
}
if (file.writeError)
{
digitalWrite(redLEDpin, HIGH);
digitalWrite(greenLEDpin, HIGH);
while(1);
}
zaehler = zaehler++;
delay(242);
if (zaehler == 13 )
{
zaehler =1;
Durchgang = false;
digitalWrite(greenLEDpin, LOW);
}
}
Es wird etwa 4 Mal pro Sekunde überprüft, ob die Kugel gerade in der obersten Laufrille unterwegs ist und die
beiden Alu-Streifen leitend verbindet.
Die gemessenen Werte werden alle drei Sekunden auf die SD-Karte geschrieben und ans serielle LCD-Display
ausgegeben.
Synchronisiert wird nur bei niedriger Spannung, so dass der Beginn eines Kugellaufes auf jeden Fall erfasst wird.
Zählen der Kugelläufe:
Zum Schluss habe ich noch einen digitalen Zähler ("digitaler
Handzähler", ebay, etwa 6 Euro) dazu gefügt, um die Zahl der
Kugelläufe zu erfassen. Ich habe die Kontakte des Druckknopfes des
Zählers nach außen geführt und mit einem starren Drahtbügel und
einem Federstahl-Drahtbügel verbunden. Der Kontakt ist geschlossen.
Kommt die Kugel, so wird der Kontakt kurz geöffnet und der Zähler
zählt um 1 weiter.
Messungen am System:
Amperemeter
Voltmeter
serielles
LCD-Display von
parallax
Operationsverstärker zur
Messung kleiner
Stromstärken
mit dem arduino
SD-Karte
arduino mit
data-logging-shield