Kontroler Lampy LED DIY - parainstrukcja budowy

[Tester]

Witam ,

W watku o samodzielnej budowie lampy LED Tomasz dokladnie opisal zasady budowy takiej lampy. Omawiajac ten watek z Icebergiem stwierdzilismy ze przydalby się do takiej lampy prosty kontroler typu „wschod – zachod”. Przebiegly Iceberg podpuscil mnie i zdeklarowalem się ze taki kontroler zbuduje Nieco pozniej okazalo się ze Iceberg kupil BP a ja zostalem z zamowionymi czesciami więc chcac nie chcac temat musialem doprowadzic do konca. Stad ten watek...

Przekopujac poklady Internetu trafilem na platforme Arduino i na autora projektu Reef LED Controller. Sympatyczny Wloch dal mi pozwolenie na uzycie jego rysunkow i kodu (link do strony projektu ReefLedController) oraz do watku na RC

Jako ze platforma Arduino daje dość szerokie mozliwosci, moim zamiarem jest przedstawienie budowy prostego kontrolera o nastepujacych mozliwosciach:

• rozjasnianie i sciemnianie (Wschod - Zachod) oparte na zegarze
• kontrola swiatla nocnego
• kontrola wiatrakow
• odczyt temperatury wody oraz lampy LED

Ze wzgedu jednak na to ze jestem absolutnym lajkonikiem jeśli chodzi o elektronike i programowanie, postanowilem sam przechodzic poszczególne etapy ewolucji kontrolera co mi da pewnosc ze jeśli ja sam to zbuduje dzialajacy kontroler to Wy nie będziecie mieli absolutnie zadnych problemow z samodzielna konstrukcja. Watek wiec będzie ewoluowal razem z moim wlasnym projektem.

Terminologia na start

ARDUINO – maly programowalny komputer do wykonywania zaprogramowanych dzialan. Posiada kilka wejsc (np. wejscia srodowiskowe takie jak temperatura, pH...) i kilka wyjsc (obsluga sprzetu) Czyli np jeśli na wejsciu temperatura jest taka a taka to na wyjsciu wlaczy się wentylator.

SKETCH – to inaczej program, wsad, kod – czyli zbior instrukcji według których pracuje komputer

TRANZYSTOR – w naszym projekcie okreslmy go jako „wlacznik” - podobny do tego na scianie który wlacza swiatlo. W naszym projekcie arduino będzie kontrolowalo ten wlacznik

PWM - Pulse-Width Modulation - bardzo szybkie wlaczanie i wylaczanie sygnalu. Tak szybkie ze nie widoczne dla naszego oka. Im większe są przerwy w dostawie pradu tym LED swieci ciemniej (VDRek – dzieki za sesje w Milowce )

POTENCJOMETR – taka galka jak w radio - reguluje napiecie dochodzace do urzadzenia.

PRZEKAZNIK – inny typ wlacznika. Jako ze arduino zasilane jest napieciem 5V/12V to przekazniki sluza nam do obslugi urzadzen 240V

SHIELD – w zargonie „arduinowcow” plytka elektroniczna kompatybilna z glownym komputerem. Takie plytki są „wyspecjalizowane” w pewnych funkcjach np. bluetooth, ethernet, SD Card i można je laczyc na zasadzie modulow.

Co nam będzie potrzebne?

Na tym etapie potrzebujemy tylko:

Srodowisko programowe ARDUINO z podstawowymi bibliotekami – do sciagniecia tutaj (85MB)

aaa i bylbym zapomnial. Oryginalne biblioteki LiquidCristal.h i wire.h sa chyba stare bo na nich kompilacja programu sie krzaczyla. Tu sa odpowiednie. Nalezy skopiowac (ewentualni podmienic) w folderze "Library" tam gdzie zainstalowaliscie pakiet arduino

LiquidCristal.h

wire.h

Plytka glowna ARDUINO – jest w kilkunastu wersjach może być UNO, DUEMILANOVE, MEGA, DIECIMILA – jakakolwiek z wejsciem USB

Wyswietlacz LCD 20x4 lub 16x2 lub inny oparty na chipie HD44780 (przyciski nie sa konieczne)

DS1307RTC – zegar czasu rzeczywistego

Tranzystor NPN 2N2222 – ile? Jeden na kazdy kanał – w naszym przypadku potrzebujemy dwie sztuki

Rezystor 1K – jeden na kazdy tranzystor

Przewod USB (z jednej strony wtyczka plaska z drugiej "kwadratowa")

Do tego lutownice, cyne, drut izolowany, plytke montazowa typu BreadBoard (nie koniecznie ale bardzo przydatna zwłaszcza na początku) , dwie rece ( koniecznie dwie lewe bo ja takie mam )

Do pozniejszej rozbudowy projektu warto zdobyc:

DS18B20 – sensor temperatury (2sztuki)

5V/240V – przekazniki (4sztuki)

Ja kupilem zestaw startowy na ebayu – LINK

za 49$ który w zasadzie daje więcej niż potrzebujemy. Oczywiscie elementy można kupowac osobno. Mozliwe ze wyjdzie taniej bo w moim zestawie było mnostwo dodatkowych elementow. Osobno musialem dokupic RTC...

Do roboty...

Zaczynamy od najprostrzej wersji kontrolera która prawdopodobnie dla wielu nanorafek będzie wystarczajaca. Na tym etapie komputerek będzie sterowal dwoma kanalami (niebieskim i bialym)

i wlaczal swiatlo o okreslonej porze.

Montujemy wszystko według schematow:

RYSUNEK 1

RYSUNEK 2

RYSUNEK 3

Oto moje dzielo w calosci . Nie mam diod ani driverow wiec tak do konca w calosci nie jest ale mysle ze podlaczenie do drivera wedlug postu Tomasza to juz drobnostka

To niestety nie koniec... bo bedzie sporo moich uwag...

CDN...

Jako ze bez oprogramowania nawet najlepszy komputer jest martwy oto oryginalny sketch. Natomiast w nastepnym poscie jest najbardziej aktualny sketch. Zeby nie bylo pomylek to cala zawartosc nastepnego postu nalezy skompilowac i wrzucic programatorem do procesor. Wkrotce przetlumacze uwagi w kodzie na polski i zaznacze te elementy programowalne

Sketch oryginalny oryginalny.txt

[Tester]

#define DS1307_I2C_ADDRESS 0x68 // address used for clock

#include "Wire.h" // library used

#include <LiquidCrystal.h> // library used

/* ******************************************************************************************************************** */

/* * * */

/* * R E L A Y P A R T * */

/* * S I M P L E O N A N D O F F F E A T U R E * */

/* * * */

/* ******************************************************************************************************************** */

const int relayPin1 = 2; // arduino pin (non pwm) used for relay 1

const int relayPin2 = 8; // arduino pin (non pwm) used for relay 2

int relayState1 = LOW;

int relayState2 = LOW;

long previousMillis1 = 0;

long previousMillis2 = 0;

long interval1 = 30000; // how many milliseconds to turn it on and off for RELAY1

long interval2 = 50000; // how many milliseconds to turn it on and off for RELAY2

/* ******************************************************************************************************************** */

/* * * */

/* * L E D D I M M I N G P A R T * */

/* * F A D E S I N A N D O U T * */

/* * * */

/* ******************************************************************************************************************** */

/* ********************************************************************************* */

/* * * */

/* * UWAGA : czas wschodu jest rowny czasowi zachodu jak w naturze . * */

/* * * */

/* ********************************************************************************* */

int ontime = 10 ; // o ktorej godzinie zacznie rozswietlac sie swiatlo niebieskie?

int minuta = 30; // w ktorej minucie zacznie rozswietlac sie swiatlo niebieskie ?

int blueramptime = 60 ; // przez ile minut bedzie sie rozswietlalo swiatlo niebieskie?

int whiteramptime = 180 ; // gdy niebieskie na maxa przez ile ma sie rozswietlac swiatlo biale?

int photoperiod = 240 ; // gdy biale na maxa jak przez ile minut maja swiecic na maxa oba kanaly?

int blue = 3; // ktory PIN PWM jest uzywnay do kanalu niebieskiego?

int white = 11; // ktory PIN PWM jest uzywnay do kanalu bialego?

//w przykladowym wpisie niebieskie swiatlo wlaczy sie o 10:30 i bedzie sie rozswietlalo przez 60 minut

//nastepnie przez 3 godziny (160 minut) bedzie sie rozswietlalo swiatlo biale

// oba kanaly beda swiecic na maxa przez 4 godziny (240 minut)

int bluemin = 0 ;

int whitemin = 0 ;

/* ********************************************************************************* */

/* * * */

/* * the line below is needed if you are using meanwell ELN60-48D, for analog * */

/* * these are the values in 10% increments * */

/* * [11] is not the arduino pin but the number of steps used from 0 to 255 * */

/* * * */

/* ********************************************************************************* */

int bluepercent[11] = { 0, 1, 2, 5, 8 ,12, 18, 27, 44, 80, 255 };

int whitepercent[11] = { 0, 1, 2, 5, 8 ,12, 18, 27, 44, 80, 255 };

/* ********************************************************************************* */

/* * * */

/* * the line below is needed if you are using meanwell ELN60-48P, for pwm * */

/* * these are the values in 10% increments * */

/* * [11] is not the arduino pin but the number of steps used from 0 to 255 * */

/* * just remove // sign below for the blue and white * */

/* * and add // sign above for the blue and white * */

/* * * */

/* ********************************************************************************* */

//int bluepercent[11] = { 0, 26, 52, 78, 103, 128, 154, 180, 205, 230, 255 };

//int whitepercent[11] = { 0, 26, 52, 78, 103, 128, 154, 180, 205, 230, 255 };

// int pwm_one = 10; // extra pwm pin for future use (spare)

// int pwm_one = 9; // extra pwm pin for future use (spare)

/* ********************************************************************************* */

/* * * */

/* * originally arduino pins 8, 9, 4, 5, 6, 7 are used, * */

/* * I have to use different arduino non pwm pins, so I can reserved the pwm * */

/* * pins for other use. * */

/* * * */

/* ********************************************************************************* */

LiquidCrystal lcd(12, 13, 4, 5, 6, 7);

/* ******************************************************************************************************************** */

/* * * */

/* * R T C C L O C K D S 1 3 0 7 * */

/* * * */

/* ******************************************************************************************************************** */

byte decToBcd(byte val) // Convert normal decimal numbers to binary coded decimal

{

return ( (val/10*16) + (val%10) );

}

byte bcdToDec(byte val) // Convert binary coded decimal to normal decimal numbers

{

return ( (val/16*10) + (val%16) );

}

// 1) Sets the date and time on the ds1307

// 2) Starts the clock

// 3) Sets hour mode to 24 hour clock

// Assumes you're passing in valid numbers

void setDateDs1307(byte second, // 0-59

byte minute, // 0-59

byte hour, // 1-23

byte dayOfWeek, // 1-7

byte dayOfMonth, // 1-28/29/30/31

byte month, // 1-12

byte year) // 0-99

{

Wire.beginTransmission(DS1307_I2C_ADDRESS);

Wire.send(0);

Wire.send(decToBcd(second)); // 0 to bit 7 starts the clock

Wire.send(decToBcd(minute));

Wire.send(decToBcd(hour)); // If you want 12 hour am/pm you need to set

// bit 6 (also need to change readDateDs1307)

Wire.send(decToBcd(dayOfWeek));

Wire.send(decToBcd(dayOfMonth));

Wire.send(decToBcd(month));

Wire.send(decToBcd(year));

Wire.endTransmission();

}

// Gets the date and time from the ds1307

void getDateDs1307(byte *second,

byte *minute,

byte *hour,

byte *dayOfWeek,

byte *dayOfMonth,

byte *month,

byte *year)

{

// Reset the register pointer

Wire.beginTransmission(DS1307_I2C_ADDRESS);

Wire.send(0);

Wire.endTransmission();

Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

// A few of these need masks because certain bits are control bits

*second = bcdToDec(Wire.receive() & 0x7f);

*minute = bcdToDec(Wire.receive());

*hour = bcdToDec(Wire.receive() & 0x3f); // Need to change this if 12 hour am/pm

*dayOfWeek = bcdToDec(Wire.receive());

*dayOfMonth = bcdToDec(Wire.receive());

*month = bcdToDec(Wire.receive());

*year = bcdToDec(Wire.receive());

}

/* ******************************************************************************************************************** */

/* * * */

/* * D E F I N E : O N E S E C O N D * */

/* * * */

/* ******************************************************************************************************************** */

void onesecond() //function that runs once per second while program is running

{

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);

lcd.setCursor(0, 0);

if(hour>0)

{

if(hour<=12)

{

lcd.print(hour, DEC);

}

else

{

lcd.print(hour-12, DEC);

}

}

else

{

lcd.print("12");

}

lcd.print(":");

if (minute < 10) {

lcd.print("0");

}

lcd.print(minute, DEC);

lcd.print(":");

if (second < 10) {

lcd.print("0");

}

lcd.print(second, DEC);

if(hour<12)

{

lcd.print("am");

}

else

{

lcd.print("pm");

}

lcd.print(" ");

delay(1000);

}

/* ******************************************************************************************************************** */

/* * * */

/* * D E F I N E : R E L A Y 1 * */

/* * * */

/* ******************************************************************************************************************** */

void relay1() //FUNCTION TO TURN ON AND OFF RELAY 1.

{

unsigned long currentMillis = millis();

if(currentMillis - previousMillis1 > interval1)

{

previousMillis1 = currentMillis;

if (relayState1 == LOW)

relayState1 = HIGH;

else

relayState1 = LOW;

digitalWrite(relayPin1, relayState1);

}

}

/* ******************************************************************************************************************** */

/* * * */

/* * D E F I N E : R E L A Y 2 * */

/* * * */

/* ******************************************************************************************************************** */

void relay2()

{

unsigned long currentMillis2 = millis();

if(currentMillis2 - previousMillis2 > interval2)

{

previousMillis2 = currentMillis2;

if (relayState2 == LOW)

relayState2 = HIGH;

else

relayState2 = LOW;

digitalWrite(relayPin2, relayState2);

}

}

/* ******************************************************************************************************************** */

/* * * */

/* * S E T U P * */

/* * * */

/* ******************************************************************************************************************** */

void setup() {

pinMode(relayPin1, OUTPUT); // set the digital pin as output:

pinMode(relayPin2, OUTPUT); // set the digital pin as output:

/* ******************************************************************************************************************** */

/* * * */

/* * S E T U P - D I S P L A Y * */

/* * * */

/* ******************************************************************************************************************** */

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

Wire.begin();

second = 00;

minute = 29;

hour = 10;

dayOfWeek = 6; // Sunday is 0

dayOfMonth = 26;

month = 2;

year = 11;

/* ********************************************************************************* */

/* * * */

/* * this is where you set your time... * */

/* * 1) change the second, minute, hour, etc above * */

/* * 2) remove // below * */

/* * 3) and load this sketch to your arduino * */

/* * 4) after loading the sketch, put the // back again * */

/* * 5) and load this sketch again to your arduino, and save * */

/* * * */

/* ********************************************************************************* */

//setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);

analogWrite(blue, bluemin);

analogWrite(white, whitemin);

lcd.begin(16, 2); // set up the LCD's number of rows and columns:

// lcd.print("12:00 80.6"); // Print a message to the LCD.

// lcd.print(char(223));

lcd.setCursor(0, 1);

lcd.print("blue:");

lcd.print(33*bluemin/85);

lcd.setCursor(8, 1);

lcd.print("white:");

lcd.print(33*whitemin/85);

}

/* ******************************************************************************************************************** */

/* * * */

/* * L O O P * */

/* * * */

/* ******************************************************************************************************************** */

void loop()

{

onesecond();

relay2();

relay1();

/* ******************************************************************************************************************** */

/* * * */

/* * L O O P - D I M F U N C T I O N * */

/* * * */

/* ******************************************************************************************************************** */

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);

int daybyminute = ((hour * 60) + minute); //converts time of day to a single value in minutes

int bluerampup;

if (daybyminute >= ((ontime*60) + minuta))

bluerampup = (((ontime*60) + minuta + blueramptime) - daybyminute);

else

bluerampup = blueramptime;

int whiterampup;

if (daybyminute >= (ontime*60 + blueramptime + minuta))

whiterampup = (((ontime*60) + minuta + blueramptime + whiteramptime) - daybyminute);

else

whiterampup = whiteramptime;

int whiterampdown;

if (((ontime * 60) + minuta + photoperiod + blueramptime + whiteramptime) <= daybyminute)

whiterampdown = (((ontime*60) + minuta + photoperiod + blueramptime + 2*whiteramptime) - daybyminute);

else

whiterampdown = whiteramptime;

int bluerampdown;

if (((ontime * 60) + minuta + photoperiod + blueramptime + 2*whiteramptime) <= daybyminute)

bluerampdown = (((ontime*60) + minuta + photoperiod + 2*blueramptime + 2*whiteramptime) - daybyminute);

else

bluerampdown = blueramptime;

/* ******************************************************************************************************************** */

/* * * */

/* * L O O P - F A D E I N * */

/* * * */

/* ******************************************************************************************************************** */

if (daybyminute >= (ontime*60)+ minuta)

{

if (daybyminute <= ((ontime*60) + minuta + blueramptime + (whiteramptime/10*9))) //if time is in range of fade in, start fading in + (whiteramptime/10*9)

{

// fade blue LEDs in from min to max.

for (int i = 1; i <= 10; i++) // setting ib value for 10% increment. Start with 0%

{

analogWrite(blue, bluepercent);

lcd.setCursor(5, 1);

lcd.print(i);

lcd.print(" ");

int countdown = ((bluerampup*60)/10); // calculates seconds to next step

while (countdown>0)

{

onesecond(); // updates clock once per second

countdown--;

relay2();

relay1();

}

}

// fade white LEDs in from min to max.

for (int i = 1; i <= 10; i++) // setting i value for 10% increment. Start with 0%

{

analogWrite(white, whitepercent);

lcd.setCursor(14, 1);

lcd.print(i);

lcd.print(" ");

int countdown = ((whiterampup*60)/10); // calculates seconds to next step

while (countdown>0)

{

onesecond(); // updates clock once per second

countdown--;

relay2();

relay1();

}

}

}

}

/* ******************************************************************************************************************** */

/* * * */

/* * L O O P - M A X V A L U E * */

/* * * */

/* ******************************************************************************************************************** */

if (daybyminute >= ((ontime * 60) + minuta + blueramptime + whiteramptime))

{

if ( daybyminute < ((ontime * 60) + minuta + blueramptime + whiteramptime + photoperiod)) // if time is in range of photoperiod, turn lights on to maximum fade value

{

analogWrite(blue, 255);

lcd.setCursor(5, 1);

lcd.print(10);

lcd.print(" ");

analogWrite(white, 255);

lcd.setCursor(14, 1);

lcd.print(10);

lcd.print(" ");

}

}

/* ******************************************************************************************************************** */

/* * * */

/* * L O O P - F A D E O U T * */

/* * * */

/* ******************************************************************************************************************** */

if (((ontime * 60) + minuta + photoperiod + blueramptime + whiteramptime) <= daybyminute)

{

if (((ontime * 60) + minuta + photoperiod + whiteramptime + 2*blueramptime + (blueramptime/10*9)) >= daybyminute)

{

// fade white LEDs out from max to min in increments of 1 point:

for (int i = 10; i >= 0; i--) // setting i value for 10% increment. Start with 10%

{

analogWrite(blue, 255);

lcd.setCursor(5, 1);

lcd.print(10);

lcd.print(" ");

analogWrite(white, whitepercent);

lcd.setCursor(14, 1);

lcd.print(i);

lcd.print(" ");

int countdown = ((whiterampdown*60)/10); // calculates seconds to next step

while (countdown>0)

{

onesecond(); // updates clock once per second

countdown--;

relay2();

relay1();

}

}

// fade blue LEDs out from max to min in increments of 1 point:

for (int i = 10; i >= 0; i--) // setting i value for 10% increment. Start with 10%

{

analogWrite(blue, bluepercent);

lcd.setCursor(5, 1);

lcd.print(i);

lcd.print(" ");

int countdown = ((bluerampdown*60)/10); // calculates seconds to next step

while (countdown>0)

{

onesecond(); // updates clock once per second

countdown--;

relay2();

relay1();

}

}

}

}

} // END LOOP

[Tester]

Uwagi :

1 - pierwsza sprawa ze jestem absolutnie zielony w temacie programowania, LEDow, driverow etc. Bardzo prosilbym o aktywny udzial w watku forumowych specjalistow bo na niewiele pytan bede umial odpowiedziec.

2 - kontroler byl stworzony oryginalnie do obslugi driverow Meanwell ELN60-48D lub 48P. Nie jestem pewien czy bedzie dzialal z innymi driverami. Moze to nie ma znaczenia.

3- wyswietlacz ktory zastosowalem ma ograniczony rozmiar 2x16 znakow. Do pozniejszych rozwiazan np podawanie temperatury trzeba bedzei go podmienic na 4x20.

4-programowanie odbywa sie za pomoca PCeta - jest to bezposrednia ingerencja w kod. Nie jest to moze najlatwiejsze ale z drugiej strony jak czesto zmieniamy godzine wlaczania czy wylaczania lampy

5- na wyswietlaczy, wartosc natezenia swiatla jest podawana skokowo co 10%. Oznacza to ze np wartosc 5 to 50% a 10 to 100% swiatla

6- kurcze wiem ze mozna inaczej i zapewne lepiej, ale zapewniam ze w prostych konstrukcjach lapm to bedzie dzialalo.

7- potencjometry na rynunku 3 nie sa konieczne. Daja nam tylko mozliwosc recznej kontroli kanalu niebieskiego i bialego. Maja kontrole nadrzedna w stosunku do sygnalu z kontrolera. Jesli ktos chce zrobic wersje prosta (bez potencjometrow) nalezy wykonac polaczenia wedlug rysunku 2

8- istnieje mozliwosc ze wyswietlacz ktory kupicie nie bedzie mial plytkie kompatybilnej z arduino i bedzie mial inne wyprowadzenie pinow. Oto schemat polaczenia "golego" wyswietlacza: (rysunek w przygotowaniu)

9- pierwsza poprawka kodu - dodalem wpisy dajace mozliwosc wlaczania lampy o niepelnych godzinach (w kodzie oryginalnym wlaczanie nastepowalo tylko o pelnych godzinach)

10-okazalo sie ze w tak zwanym miedzyczasie arduino doczekalo sie nowego kompilatora, ktory ma jakies zgrzyty ze starymi bibliotekami. Dlatego do nowego kodu zaczalem uzywac kompilator w wersji 0022 - do sciagniecia tutaj

.....

[chodi]

Masakra jak mozna skomplikowac tak proste urzadzenie hehe ale dzialaj Bartek dzielnie arduino no najmniej bolesny start w rodzine avr

[lubusikk]

hehe teraz przypomniało mi się dlaczego tak bardzo nie lubię programowania w C...

jedna kwestia , którą mogę na wstępie zaproponować , ds1307 ma wyjście swq , na którym to to wiele łatwiej robić przerwania do sterowania wschodów i zachodów , po odpowiednim skonfigurowaniu wewnętrznych rejestrów , na tym wyjściu , które na marginesie jest typu oc , można uzyskać przebieg prostokątny o częstotliwości 1Hz ..

[rekin]

tu macie sklep gdzie można w/w części kupić

Arduino

[Tester]

jedna kwestia , którą mogę na wstępie zaproponować , ds1307 ma wyjście swq , na którym to to wiele łatwiej robić przerwania do sterowania wschodów i zachodów , po odpowiednim skonfigurowaniu wewnętrznych rejestrów , na tym wyjściu , które na marginesie jest typu oc , można uzyskać przebieg prostokątny o częstotliwości 1Hz ..

LOL - a Ty mnie czasami nie obrazasz??? Nie mam pojecia o czym piszesz.

[pasek]

tu macie sklep gdzie można w/w części kupić

Arduino

Może się nie znam ale loccutus robi to znacznie taniej- jesli się mylę poprawcie, tylko że teraz USA jest cacy a POLSKA beeeee....

[lubusikk]

jeżeli nie potrzebujesz bluetootha to się mylisz

LOL - a Ty mnie czasami nie obrazasz??? Nie mam pojecia o czym piszesz.

hihi sorki ale prosciej nie umiem

[chodi]

To ja sprobuje prosciej

Kolega lubusik chcial zasugerowac wykorzystanie kosci rtc do generowania przerwania. Uwalniajac w ten sposob cenne bo nieliczne wewnetrzne timery procesora ktore to pozniej mozna spozytkowac w innym celu

[pasek]

To ja sprobuje prosciej

Kolega lubusik chcial zasugerowac wykorzystanie kosci rtc do generowania przerwania. Uwalniajac w ten sposob cenne bo nieliczne wewnetrzne timery procesora ktore to pozniej mozna spozytkowac w innym celu

Ja i tak nie mam pojęcia o co chodzi :thumbsup:

[lubusikk]

dzięki takiemu prostemu "mykowi" możemy zredukować powyższy kod o co najmniej połowę. gdyż dzięki temu nie używamy wewnętrznego timera , a wszystkie zmiany i np odczyty godziny z układu dokonywane są co sekundę...

[szwagier]

Ciekawy projekt szczegolnie dla tych co nie maja wiekszego pojecia o elektronice.

Czy mozna tym sterowac inne drivery ? Np. MR2007Vxx ?

Lubusik: czy istnieje mozliwosc zakupienia twojego sterownika w wersji gotowej lub przynajmniej PCB i kodu programu ?

Mam prawie skonczona lampe i brakuje mi tylko sterownika i obudowy ktora musze zaprojektowac w zaleznosci od zastosowanego sterownika.

[morswin]

Taki oto sterownik już zmajstrowałem, posiada wszystkie funkcje wymienione na początku a koszt części to z grubsza 50-60 zł. Sterownik jest praktycznie skończony dorobić by trzeba tylko zapis ustawień do pamięci nieulotnej eeprom. Jutro mogę wrzucić filmik jak to w miarę działa Jeżeli znajdzie się ktoś chętny to udostępnię materiały potrzebne do budowy aby można było potestować na porządniej lampie bo ja swojej jeszcze nie mam:)

[Tester]

po calym dniu walki z problemami zwiazanymi z kompilacja nowego kodu mam nowy duzo bardziej zlozony kontroler. Obecnie kombinuje jak zrobic zeby pokazywal temperature w stopniach Celsjusza (EDIT: Juz mam w stopniach Celsjusza )

co potrafi?

-wschod/zachod swiatla niebieskiego i bialego

-pomiar temperatury wody

-pomiar temperatury LEDow

-kontrola wentylatorow

-swiatlo w refugium

[morswin]

Obiecany filmik:

http://www.youtube.com/watch?v=3pDWIFnOTuk&feature=youtu.be

[Tester]

Opanowalem sprawe termometru. Dziala tak jak powinien. Natomiast dochodze do wniosku ze wersja softu z obsluga wiatrakow, temperatury czy refugium bardzie kwalifikuje kontroler jako prosty komputer akwarystyczny. Dlatego chyba nie ma sensu montowac go w lampie ze wzgledu na ilosc kabli ktora by z niej wychodzila

[kaspy]

... i w tym momencie zaczynasz się zastanawiać czy aby nie warto kupić drugiego Arduino. Jeden do lampy, drugi pod szafkę. To jest jak nałóg. :-)

[Tester]

Nieee, traktuje to raczej jako eksperyment bo i tak wszystkim steruje profilux. W watku chcialem tylko wykazac jak prosto jest zrobic maly kontroler swiatla. Do malych zbiornikow idealne rozwiazanie

[mariuszduch]

To może mógłbyś zrobić sterownik do pomp boyu wm3 żeby zabujało wodą w baniaku

Ps : powaga!

[morswin]

Na jakie napięcie są te pompy?

[Tester]

obiecany rysunek ze schematem podlaczenia wyswietlacza 20x4

[mariuszduch]

Na jakie napięcie są te pompy?

DC 24 v

nie zaśmiecajmy koledze wątku,założyłem nowy temat

Tester sorka za offtop

[TomekSz]

Kurcze, przez ten wątek zaczałęm robic lampe led do sumpa z kontrolerem na arduino

Cos czuje, ze zalapalem bakcyla i bedzie ciezko sie uwolnic.

EDIT

Szukam buga... moze ktos pomoze

Podlaczylem dwa potencjometry pod analogi arduino. Mapuje z nich wartosci na wyjscia PWM i podaje na drivery led dwoch kanalow. Wszystko dziala pieknie ale...

Jak podlacze do arduino zegar zeby odpalac wlaczanie i wylaczanie o okreslonej godzinie to po pewnym czasie uklad sie zawiesza. Nie czyta analogow.

Odnosze wrazenie, ze program jest zawieszany przez funkcje

DateTime now = RTC.now();

Probowalem juz na dwoch zegarach i ciagle to samo. Moze komus przychodzi cos do glowy ?

Edytowane 26 Listopada 2012 przez TomekSz (wyświetl historię edycji)

[polecki]

I jak tam panowie jakieś postępy w budowie ?