Elektronische Lampensteuerung selberbauen

Alles klar, danke.
Nehme doch diese KSQ. Und baue damit eine P7 Aurora um.

Hat zufällig noch jemand eine Lampensteuerung übrig, die er loswerden möchte? Ich würde sie dankend abnehmen.:daumen:
 
Die obige KSQ sollte gehen, aber effizient ist sie nur, wenn die Ledspannung knapp unter der Akkuspannung ist, da die Differenzleistung in Wärme umgewandelt wird.

Sorry für die dumme Verständnisfrage zu obigem:

Die Seoul P7 soll mit 3.6 Volt betrieben werden. Konstantsromquellen wollen aber oft wesentlich höhere Spannungen sehen, z.B. die aus dem letzten Posting 5.5 bis 15 Volt.
Bedeutet das nicht, dass zB. vier NiMh oder NiCd Akkus in Reihe die optimale Akku Konfiguration sind und besser nicht 7.8, 8,4 Volt oder noch mehr, wie momentan oft zu sehen sind?
 
Im Normalfall ist es bei KSQs so, dass ihr Wirkungsgrad immer schlechter wird, je weiter Eingangs- und Ausgangsspannung auseinander sind.

KSQs brauchen aber eine Arbeitsspannung (Drop), um richtig arbeiten zu können.
Beträgt der Drop ca. 1V und du willst eine P7 betreiben (eher 4V nötig) brauchst du mindestens 5V am Akku.

Die beste und einfachste Lösung ist es hier, einfach einen BP941 zu nehmen (der zwischen 8,4 und 6V liefert).
 
Ah ... danke für die Erklärung. Also ist die optimale Akkuspannung knapp oberhalb der Arbeitsspannung der KSQ für die jeweilige LED Spannung.
 
Denke dran, dass die Spannung von Led + Drop auch mit leerem Akku erreicht werden sollte.

Ein 3.7V-Lion-Akku geht z.B. bis auf 2.8V runter.
 
Hi,

ich habe aus meinem letzten Projekt noch 6 Lampensteuerungen da, die ich selber nicht mehr benötige.

Es handelt sich um die aktuellste Version (v16 mit Attiny84 Controller) der Ein-Tasten-Steuerung.
Fertig aufgebaut, mit 2 Ausgängen.

Für meine T6 habe ich eine modifizierte Software erstellt, die um eine Temperatursteuerung erweitert ist. Soll- und Shutdown-Temperatur sind einstellbar.
Auf Wunsch kann ich die Steuerung mit dieser Modifikation programmieren.


Zudem habe ich noch 3 Zwei-Tasten-Steuerungen gefunden.


Die Daten zu den Steuerungen findet ihr über den Link ("Anleitung") in meiner Signatur.

Lampenbeispiele sind in meiner Fotogallerie.

Bei Interesse bitte eine Mail oder PM an mich.
 
Zuletzt bearbeitet:
@MaikRutsche: hast du meine pm erhalten?
hätte gern die letzte version der lampensteuerung mit einem taster.
grüße sascha
 
Für diejenigen, die selber die Software der Steuerung angepasst und modifiziert haben, kann ich bei Bedarf meine neue Version zu Verfügung stellen.

Bei meinem letzten Projekt hatte ich mir nämlich ein paar Erweiterungen eingebaut, die ich gerne zur Verfügung stelle:

AVR-Bootloader über One-Wire.
Damit kann man die Software auch im eingebauten Zustand aktualisieren.
Dazu muss man lediglich ein Kabel der an der Steuerung anlöten und nach außen legen.
Gleichzeitig können über diese Leitung auch wärend des Betriebs Speicher ausgelesen werden und Daten übertragen werden. Dazu ist "nur" ein einfacher RS232-TTL-Wandler erforderlich.

Optionale Temperaturregelung - Ausgang 1
- KTY11-5 (1970Ohm @25°C) am Pin PA7, Pullup mit 4.7K.
- Regelung ab 50°C
- Zwischen 50 und 70°C wird gemittelt über 25 Sekunden kontinuierlich geregelt.
- Werden die 70°C innerhalb von 30 Sekunden erreicht, wird auf Stufe 1 geschalten und wenn nötig abgeschalten. Falls die Regelung zu langsam ist, überhitzt die Lampe nicht.
- Alle Stufen sind geregelt - Dimstufe 1, 2 und 3
- Statusleuchte blinkt, wenn geregelt wird
- Erkennung des Sensors. Ist kein Sensor angeschlossen, wird nicht geregelt.

Die neue Software bedingt allerdings einen größeren Controller: ATTINY84


Messungen an meiner T6 (25W)
Sensor unter dem Ledträger: http://img175.imageshack.us/i/cimg4204.jpg/

Im Raum:
Raumtemperatur 27°C, maximale Leistung, 100%
Nach ~2 Minuten setzt die Regelung ein.
Nach ~5 Minuten liegt die gemessene Temperatur bei etwa 55°C, Lampenleistung ~5W
Gehäusetemperatur 42°C

Draußen, im Stand:
Temperatur 30°C, maximale Leistung, 100%
Nach 5 Minuten setzt die Regelung ein
Nach ~10 Minuten ist die Regelung stabil. Lampenleistung ~10W

Draußen wärend der Fahrt:
Lampe bleibt bei 100%


MfG

Tobias
 
Zuletzt bearbeitet:
Ui ... schön von Dir zu lesen und dass Dein Projekt nicht einschläft! =)

Gerade bei diesem Wetter wirklich nicht uninteressant und ich hätte brennendes Interesse. Hab immer noch zwei Platinen übrig. =)
 
Habe vor einigen Wochen hier aus dem Forum eine gebrauchte V3 Platine erstanden, war eine 1 Kanal Ausführung. Diese ist jetzt umgebaut auf 2 Kanal FET und als ich die Platine so nackt vor mir hatte mit der alten V0.13 hatte konnte ich die Finger nicht vom AVR lassen ;-)
Hier nun das Ergebnis welches ich AVR Programmiergerätbesitzer und Bastlern nicht vorenthalten möchte.
Eine angepasste V0.16 mit Fadeover Funktion.
Heisst, wenn an den 2 Kanälen Lampen angeschlossen sind kann zwischen den 2 Lampen umgeschaltet werden (normalerweise Stufe 2=L1:100%,L2:0% und dann Stufe 3=L1:0%,L2:100%) ohne dass es beim Wechsel dunkel wird :)
Die Änderungen sind in pwm.c vorgenommen, eine angepasst Version 0.16 findet sich hier: http://tuxedo.ath.cx/temp/pwm.c

Es Bedarf für diese Änderung andere Funktionen rauszuschmeissen und FADEOVER zu definieren (in controller.h), bei mir sieht das so aus:
Code:
        #undef PWM2_AUTODETECT 
        #undef PWM2_ENABLED_DEFAULT 
        #define PWM2_ENABLED_DEFAULT 1 
        #undef PROG_PWM_CS_ENABLED 
        #define FADEOVER
Die Änderungen in pwm.c sind in pwmRefreshSingleOutput
Code:
void pwmRefreshSingleOutput(volatile uint8_t *pwmRegister, uint8_t sollValue) 
{ 
    uint8_t istValue = *pwmRegister; 
#ifdef FADEOVER 
    if (istValue > sollValue) { 
        //dunkler stellen 
        //if ((istValue - sollValue) > 30) { 
        if ((istValue > 150) && (sollValue == 0x00)) { 
            istValue -= 2; 
        } 
        else 
        { 
            istValue = sollValue; 
        }             
    } 
    else 
    { 
        //heller stellen 
        if (istValue < 30) { 
            istValue += 1;  
        } 
        else 
        { 
            istValue = sollValue; 
        } 
    } 
#else 
    if ((istValue > sollValue) || (istValue > 30)) { 
        //Soll kleiner als Ist, oder Ist hat einen Wert von 30 überschritten 
        //dann Sollwert direkt setzen 
        istValue = sollValue; 
    } 
    else 
    { 
        //Softstart 
        istValue += 1;  
    } 
 
#endif     
     
    //istValue ins PWM Register schreiben 
    *pwmRegister = istValue; 
}
und in pwmRefreshOutputs
Code:
void pwmRefreshOutputs(void) 
{ 
    //Interrupts aus... 
    //Sicherung der Interrupts ist egal, es werden eh nur welche für den Timer genutzt 
    cli(); 
     
    //Lokale Variablen... 
    uint8_t pwm1Soll             = pwmOutput.pwm1Soll; 
    uint8_t pwm2Soll             = pwmOutput.pwm2Soll; 
    uint8_t pwm1ProgVoltage     = pwmOutput.pwm1ProgVoltage; 
    uint8_t pwm2ProgVoltage     = pwmOutput.pwm2ProgVoltage; 
     
    uint8_t pwm1Mode = pwmTable[0]; 
    uint8_t pwm2Mode = pwmTable[1]; 
     
    //Ausgang 1 
    #ifdef FADEOVER 
        //PWM Register erst abschalten wenn der andere Kanal den Sollwert erreicht hat 
        if ((0x00 == pwm1Soll) && (PWM2_REG == pwm2Soll))                          { PWM1_REG = 0x00; } else 
    #else 
        if (0x00 == pwm1Soll)                          { PWM1_REG = 0x00; } else 
    #endif 
    if (PWM_MODE_KONST_RATIO         == pwm1Mode) { PWM1_REG = pwm1Soll; } else 
    if (PWM_MODE_KONST_RATIO_INV    == pwm1Mode) { PWM1_REG = pwm1Soll; } else 
    if (PWM_MODE_KONST_VOLT         == pwm1Mode) { PWM1_REG = pwmGetRegulateOutputValue(pwm1Soll, pwm1ProgVoltage); } else  
    if (PWM_MODE_KONST_RATIO_SOFT     == pwm1Mode) { pwmRefreshSingleOutput(&PWM1_REG, pwm1Soll); } else 
    if (PWM_MODE_KONST_VOLT_SOFT     == pwm1Mode) { pwmRefreshSingleOutput(&PWM1_REG, pwmGetRegulateOutputValue(pwm1Soll, pwm1ProgVoltage)); }  
     
    //Ausgang2 
    #ifdef FADEOVER 
        //PWM Register erst abschalten wenn der andere Kanal den Sollwert erreicht hat 
        if ((0x00 == pwm2Soll) && (PWM1_REG == pwm1Soll))                          { PWM2_REG = 0x00; } else 
    #else 
        if (0x00 == pwm2Soll)                          { PWM2_REG = 0x00; } else 
    #endif 
    if (PWM_MODE_KONST_RATIO         == pwm2Mode) { PWM2_REG = pwm2Soll; } else 
    if (PWM_MODE_KONST_RATIO_INV    == pwm2Mode) { PWM2_REG = pwm2Soll; } else 
    if (PWM_MODE_KONST_VOLT         == pwm2Mode) { PWM2_REG = pwmGetRegulateOutputValue(pwm2Soll, pwm2ProgVoltage); } else 
    if (PWM_MODE_KONST_RATIO_SOFT     == pwm2Mode) { pwmRefreshSingleOutput(&PWM2_REG, pwm2Soll); } else 
    if (PWM_MODE_KONST_VOLT_SOFT     == pwm2Mode) { pwmRefreshSingleOutput(&PWM2_REG, pwmGetRegulateOutputValue(pwm2Soll, pwm2ProgVoltage)); }  
 
    //Interrupts wieder an 
    sei(); 
}
Habe die Änderungen nicht lange studiert, kann sein dass noch was vergessen wurde. Mit Konstantspannung und Konstantverhältnis funktioniert es bis jetzt zu meiner Zufriedenheit :)
 
Nach 7 Jahren ein neuer Beitrag ;)

Ich habe alle Dokumente mal zu GitHub hochgeladen.

Die Entwicklung der Platinen und der Firmware hat mir sehr viel Spaß gemacht.
Das ganze Gebastel war sicherlich auch einer der Punkte warum ich mihc beruflich in die Richtign bewegt habe, wo ich jetzt bin...

Vor allem die praktischen Erfahrungen waren sehr interessant.
Heute würde ich wohl nicht mehr so viel Aufwand betrieben um so viele Funktionen in den kleinen AtTiny zu pressen.
Aber es hat doch gezeigt, wie viel eine ordentliche Code-Optimierung bringen kann.
Da waren einige Klimmzüge notwendig ;)

Aufgrund der Entwicklung der Led-Lampen sind die Halogen-Spots inzwischen etwas aus der Mode gekommen.
Wenngleich die Lichtfarbe und Ausleuchtung der klassischen Osram IRC mit 24° meiner Meinung von vielen aktuellen Lampen nicht erreicht werden.

Hier der Link
https://github.com/tengelmann/Lampensteuerung

Viel Spaß damit!
 
Echt interssant und schön das zu lesen....war eine schöne Zeit bevor die LED-Technik alles andere verdrängt hat. Was wurde damals noch gebastelt, echt schade drum.
Ich finde nach wie vor die CDM-R 70W sehr gut von der Ausleuchtung und Lichtfarbe her...
 
Das ist wirklich ein alter Thread.

Ich finde auch, dass die Osram IRC 35W (50W ?) betrieben an 4s LiPo sich eigenlich immer noch nicht verstecken muss.

das aber nur am Rande, ich habe leider ein Kopie von der Kopie der Piko bei Amazon gekauft, und zwar diese:

https://www.amazon.de/Taschenlampe-...509715100&sr=8-1&keywords=winwintom+8000lumen

Ich denke es ist eine billige Kopie der Yinding. Ich bin einer Empfehlung hier gefolgt, aber OK, dank Amazon ist aber das Geld wieder auf meinem Konto.

Intern ist die Lampe ein Witz, von Wärmeableitung kann keine Rede sein. Ich denke beide Lampensteuerungen sind den Hitzetod gestorben.

Die LEDs an sich funzen aber noch bei direktem Anschluss einer Stromquelle.

Meine Frage nun, gibt es so etwas wie fertig kaufbare KSQ / Treiber für sowas? Ich würde das Ganze dann in das Kabel verfrachten. Mir reichen 2 - 3 Stufen locker (50 - 100%, oder 30 - 60 - 100 %), Akkus etw ist vorhanden.

Notfalls mache ich einen separaten Thread auf.

Danke, Tony
 
Die IRCs sind sicherlich nicht schlecht (habe ich selbst auch). Allerdings ist die Haltbarkeit (Erschütterungen) und
Laufzeit deutlich geringer. Darum würde ich nicht mehr auf LED verzichten.
 
Die IRCs sind sicherlich nicht schlecht (habe ich selbst auch). Allerdings ist die Haltbarkeit (Erschütterungen) und
Laufzeit deutlich geringer. Darum würde ich nicht mehr auf LED verzichten.
Hatte ich nie Probleme damit. Die Leuchtmittel haben ja quasi nix gekostet. Das Licht war wirklich 1a, da kommt man mit den China LEDs nicht ran. Problem war immer die kurze Laufzeit, drum bin ich irgendwann auf die DX P7-Lampe umgestiegen. Heute, wo man dank E-Bikes billig an hochwertige 18650er LiIon mit hoher Kapazität rankommen kann, wär ne IRC-Lampe mal echt wieder überlegenswert.

Danke an @MaikRutsche für die Steuerung, ich hab immer noch zwei funktionierende an IRC-Gehäusen dran, eine war sogar mal im Zweikanalbetrieb mit nem LED-Spot an der zweiten Leitung. Heute mache ich keine Nightrides mehr im Wald und lass dem Wild seine Ruhe, aber es waren tolle Zeiten mir den Lampen.

Werd mir den Code auf Github bei Gelegenheit mal anschauen, nochmal ein :daumen: fürs veröffentlichen.
 

Ähnliche Themen

Zurück
Oben Unten