Úgy, hogy a blynk normál esetben áll az arduino-ból ami a netre van kötve és áll az okostelefonos alkalmazásból.

Telefonon van egy négyzetrácsos területed amire különböző "funkciókat" rakhatsz ki, pl villogót, LCD kijelzőt, gombokat, bizonyos eseményekre felugró ablakot vagy email-t kérhetsz.

És igazából ennyi, a válaszidő félmásodperc alatt van és egész gyakori a frissítési ráta is.

gyapo11:
DTH22-esről olvastam mindenhol, hogy azt használják, erre gondoltam. Hőmérő+pára három szobába + nappali + kültér.

Persze értem én, hogy úgy a szép, hogy áramszünet esetén is működjön, legalábbis mentse az adatokat, de nem érzem annyira kritikusnak. Példáddal élve, nem tudja, hogy fűtött már 5 percet, és kellene még 55-öt újraindítás után, de tudja, hogy hány fok van, hány fokot szeretnék most, és két óra múlva, így mehet a program tovább. Legrosszabb esetben kicsit túlfűt egy ciklust 1 fokkal, szóval esetleg második körben gondolkodok majd ilyesmiben.

Blynk-et Dannex fórumtárs ajánlotta, annyira nem ismerem, de azért majd ránézek.

Stopperos:

Az ajánlott szenzornak utána fogok nézni.

Természetesen én sem azt tervezem, hogy összedobok egy programot, és már cserélem is a falon a termosztátot. Első fázisban lesz a falon egy mindenféle adatot mutató kütyü, + hőmérséklet logolás. Esetleg valahogy megpróbálom eltárolni mikor kapcsol be meg ki a kazán. Abból tanulva tudnám kialakítani az optimális vezérlésemet.

Webszerveres vezérlésre nem arra gondoltam, hogy az arduino intézi a felületet, csupán a legalacsonyabb szintű dolgokat csinálná. Mérések, amiket le lehetne kérdezni, tárolná a vezérléshez szükséges paramétereket, és ki be kapcsolná a kazánt.

És egy tablet pedig biztosítaná a felhasználói felületet, kiolvasná a mérési adatokat, és a fűtési paramétereket, és ezen keresztül lehetne megváltoztatni őket.

Ja, hogy nem az arduino generálja a weboldal forrását, hanem kiteszik ezt a feladatot külső serverre. Nincs net, nincs verzérlés. Itt nálunk a sötét vidéken még elég gyakran előfordul ilyesmi, és házvezérlésnél nem bíznám rá a netre, legyen csak routeren belül.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

A DHT22 adatlapja 20 m-t ír, van felhúzó ellenállás, jó lehet lakásba.
Azt, hogy mennyit kell fűteni nem időmérésre megy, hanem hőfokra. Olyan feladatnál gond az idő elvesztése, ahol időre megy. Pl. melegvízzel feltöltött puffer keringetése x ideig, keringető szivattyú leállítása kazán kikapcsolása után x idővel, kazán kikapcsolása és bekapcsolása között x idő várakozás minimum. De a keringetési feladatokat lehet hőmérsékletre is, és akkor az idő kiesett, szóval a megfelelő programozással is sokmindent meg lehet oldani. Viszont teljesülő feltételeket kell programozni, hogy ne fordulhasson elő a megfelelő hőfokot nem elérve a folyamatos szivattyúzás. Pl. a puffer induló hőfoka 30, a program elkezdi keringetni és vár egy 10 fokos hűlést, de azt nem éri el, ezért egész nap megy. Tehát jól kell meghatározni az értékeket.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Ez sem probléma, hisz úgy készítették a Blynk-et, hogy saját szervert is létrehozhatsz

Dht22 1 m után már nem volt stabil nekem. Illetve ott minden szenzort be kell kötni az arduinora külön-külön. A ds18b20 esetén pedig egy kábelen akár 10 szenzor is lehet.

"What is Linux? I only joined because of the the penguin..." - meanwhile in the linux community. http://9gag.com/gag/arpZGOy

Az én fűtésem makk egyszerű, be lehet kapcsolnia kazánt meg ki,a nappali hőmérsékletének a függvényében.
Jelenleg egy elég okos termosztátom van, amit lehet programozni. Azért itt is van szerepe az időnek, mert ugyebár ha délben akarok 22 fokot, akkor nem 12:00-kor kell bekapcsolni a kazánt, hanem ki kell számolni, mennyivel előtte, mennyi időt kell fűteni.

Szóval erre fogok lőni, nem bonyolítom,

stopperos:
Viszont ez a szenzor nem tud csak hőmérsékletet nézni, páratartalom nincs. (tudom tudom, ez az én hülyeségem, adatmániám) De azért rendelek ebből is párat holnap.

apropó, ha már itt tartunk, mi az amit feltétlenül meg kell vennem hozzá: eddig amit kinéztem ebay-en
uno + enc28j60 ethernet shield + rtc + breadboard tesztelni + kábelek. + relé
jön még egy rakat szenzor, csak úgy próbálgatni, csak nem akarok semmit kihagyni, ami miatt majd később kellene várakozni a projektnek.

Én személy szerint a W5100-at ajánlanám, neten amik vannak hálózatos példák azok szinte mind a W5100-hoz íródtak, az enc28j60-al egy csomót szenvedtem mire megfelelő kódokat találtam hozzá.

Az már jó, főleg ha tableten is tud futni a server, mert itt az lesz a felület. A routeren server beüzemelés nem megy mindenkinek, külön pc-t járatni csak ezért meg nem kifizetődő.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

És a 18B20 buszról mit lehet tudni, milyen távon stabil?

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

+1

Az ethernet shiled is alapból ez van.

[ Szerkesztve ]

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Abszolút egyet értek gyapo11-el. Ha már szerver akkor menjen minden szenzor egy Rpi-re. Minden megoldott, a wifi az ethernet. És a raspbian alá lehet egy lamp-et lökni. No meg azért van pár szabad GPIO. Ha a végén kevés lenne, akkor egy pro mini 8M 3,3 V-osat be lehet rakni mellé, és soroson átlökni a plusz szenzor adatokat. Végtelenségig lehet skálázni. Ja és egy kis webcamos otthonőrt is belet rakni mellé, vagy esetleg Wifis IP camokat.

[ Szerkesztve ]

A szenzorok adatai alapján a vezérlést szívesebben bíznám az arduinora, mint egy raspire. Minél bonyolultabb egy elektronika, annál valószínűbben hibásodik meg.
Az egy másik kérdés, hogy hol akarom megjeleníteni az adatokat, milyen felületen akarom bevinni az arduinoba a változásokat, határértékeket, időpontokat.
A legkézenfekvőbb a pc, ezzel programozni is tudom. Jó a tablet vagy okosteló, ekkor kell az arduinonak generálni a html oldalt.
Ha server, akkor a netes megoldás jó, de kell a net, saját server jó, de akkor eszi az áramot. Raspi nem olyan sokat, de ott meg a linuxhoz kell érteni. Egy régebbi notebook meg alhat kb. 1 W-ot fogyasztva, pár másodperc alatt föléled, és egy fullos oprendszer monitorral együtt esetleg olcsóbban mint a raspi 2+monitor+billentyű.
Szóval mindig van valami, ami miatt egy másik megoldás jobb.
Az biztos bosszantó, ha egy hőmérséklet megnézéséhez be kell bootolni valamit (pc, raspi), és várni kell 10 másodperceket, hogy megjelenjen az adat. Routert nem kell, de nincs kijelzés. Tablet, okosteló jó, mert az arduino rögtön mutatja, netes server jó, mert az is. Raspi vagy notebook csak akkor, ha folyamatosn megy alvásban és gyorsan föléled.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Én abszolút málna párti vagyok, mert olcsó és ha valakinek a debian nem jön át, akkor ott a WinIOT Core. Egyetlen egy nagy hátránya van, ha sok szenzor van rajta, akkor képes seggre ülni ha gyenge a tápellátás. Szerintem egy fokkal sem megbízhatatlanabb mint egy Uno, de hát ízlések és pofonok. Arról nem is beszélve, hogy ha valaki otthon van Java-ban (sajnos én nem), az nagyon meredek lakásvezérléseket tud összehozni.

Nyílván ha az ember csak webes termosztátot akar készíteni, akkor a legkézenfekvőbb egy ethernet shield, mert az sd kártyán egy pofás honlaphoz eférnek a tartalmi elemek. Nekem ezzel csak az a bajom, hogy itt ennyiben meg is állt a történet, nem skálázható tovább. Ok tudom hogy soros kommunikációval annyi arduinot kötünk össze "amennyit akarunk", de ez szerintem akkor is csak Basic megoldás, egy elektromos termosztát, nem pedig egy lakásvezérlés alapja.

Viszont itt a jön "de" rész. Ha csak termosztát kell, akkor a málna drága és körülményes. Én abból indulok ki, hogy az ember legalábbis én úgy működök, hogy ha valami kész mindig eszembe jut valami, hogy húú basszus még ezt is össze kellene hozni Ezért vagyok málna párti mert ott van is rá lehetőség.

Rátérve az áramellátásra. Itt egy jó példa a málnához. [Málna pc 100% napelemmel]
A megjelenítésre, meg itt is alkalmas a tablet, vagy bármi, mert az apache alatt olyan honlapot csinálunk amilyet akarunk. Innentől kezdve meg nem is kell külön megjelenítő. Plusz a stabilitásra ott a példa, hogy a napelemes málna már évek óta üzemel.

Nah most jól bepromóztam a Raspberryt az Arduino topicban

Jó a málna is de ahogy te is írtad sok esetben indokolatlanul nagy beruházás lenne. De amikor ez ember egy olyan MCU-s projektet tervez és valósít meg, ahol a végén imndent egy Nyákon szeretne látni ott meg van lőve Pi-vel.

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Én elég nagy különbséget látok az arduino és a raspi között. Az egyik egy mikrovezérlő pár alkatrésszel és kivezetésekkel, a másik egy számítógép. A megbízhatóságuk között nagyságrendek vannak. Nem mintha egy mikrovezérlő nem tudna megfeküdni vagy nem lehetne hibás, de az már eléggé kiderült volna.

Gondoljunk csak a windowsra, olyan nagy, olyan sok hiba van benne és annyira bonyolult, hogy ha nem csinál meg valamit, akkor csak megrándítjuk a vállunkat és újrabootolunk. Vagyis ha egy rendszer elkezd nőni, akkor egyre többet tud, de egyre megbízhatatlanabbul.

Ipari pc-k talán el tudják érni az ipari alkalmazáshoz szükséges szintet, de az nagyon más árkategória. Nekem tetszenek az SBC-k, mehet rajta dos, windows, linux, kinek mi jön be, de még egy házvezérlést se mernék rábízni. Viszont kiváló megjelenítő és beavatkozó felületet adhat. És már jönnek a nagyobb pendrive méretű gépek teljes windows kompatibilitással. Még kicsit drágák, de lesz az olcsóbb is.

Szóval elosztott intelligenciával érdemes ezeket megoldani, egyszerűbb de biztosabb eszköz a végeken, iparban pl. ipari plc-k, és valamilyen számítógép az ember és végek közötti kommunikációra. A raspi végeknek fölöslegesen erős és bonyolult, valami más való neki, pl. multimédia központ a tv-hez, mosógép vezérlés, bár talán arra is elég az arduino, játékrobothoz vezérlő stb., aminél nem olyan nagy gond ha kicsit összekavarodnak a bitek, mert anyu bekapcsolta a porszívót vagy vakuzott egyet.

Azt jól látod, hogy az arduino kicsi a megjelenítéshez, hanglejátszáshoz stb., belefér sok minden, de nem arra való, és ha elfogy a hely, akkor szívás van. Persze itt csak egy kazán meg x szenzor van, ezt még simán elbírja, főleg ha nem kell csicsa weblapot is generálnia.

Abban is egyetértek, hogy a raspi annyira jól sikerült hobby eszköz, hogy egy életen át el lehet vele játszani. Ilyen linux, olyan driver, ilyen konfig, namég ezt is, meg akkor már ezt is, és még azt is. Nekem kiesett a linux miatt, a wint meg majd meglátjuk milyen lesz rajta.

Nekem is sikerült egy-két idegen eszközt behozni, de legalább el tudjuk helyezni az arduinot a skálán.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Az egyik egy mikrovezérlő pár alkatrésszel és kivezetésekkel, a másik egy számítógép.

Na gyakorlatilag megfogtad a lényeget, valami ilyesmi megfogalmazást kerestem én is.

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

A lényeg hogy a véleményeknek van közös metszete, még ha nem is teljesen fedik egymást.

A WinIOT a málnára, nekem nem nagyon tetszik, "parancssoros Windows? WTF? " szerintem amúgy is gyalázat erre az eszközre a Win. No és igen, ha egy nyákon akarom látni az eszközt, akkor a málna erre alkalmatlan.

Ha lehetne kívánni oprendszert raspire, az dos-win311 lenne, mondjuk egy basic meg egy pascal fordítóval, ami elér minden portot, tud ablakozni, rajzolni, képernyőre írni, médiafile-t lejátszani. Az egész lenne vagy 20 MB, egy 2 GB-os sd 1 %-a. Meg mellé pc-re egy grafikus felületen folyamatábrából basic vagy pascal forrást generáló program.
Ez utóbbi jól jönne a mostani helyzetben is, bánom is én milyen oprendszer fut rajta, csak tudnám programozni.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

A DS18B20 szenzornál az a lényeg, hogy hálózatba lehet kötni. Én fogtam egy 3 eres vezetéket (VCC, DATA, GND) és rápakoltam 4 szenzort, és a legtávolabbi 5m távolságra volt. Ennél több is belefér. Én ezekkel mérném a hőmérsékletet, mert 0,5 fok pontosak.

DHT22-nél 1 szenzor 1 input-ot elhasznál, nem lehet hálózatba kötni. 1m után már nem volt stabil, és megnőtt a kiolvasási hiba. Nagyon érzékeny az időzítésekre. Páratartalmat elég 1 helyen mérni, arra jó a DHT22, de hőmérsékletet nem bíznék rá. Max referencia.

Én amúgy elsőre raspberry-vel csináltam meg sok dolgot, erről írtam is a logouton. Utána kísérleteztem arduino-val is hőmérséklet mérés terén. Végül csak a lézerek vezérlését csináltam meg belőle a laborban, mert a hálózati részből több is kellett, mint amit az enc28j60-nal meg tudtam csinálni. Monitorozásra így maradt a pi.

[ Szerkesztve ]

"What is Linux? I only joined because of the the penguin..." - meanwhile in the linux community. http://9gag.com/gag/arpZGOy

A szenzorok adatai alapján a vezérlést szívesebben bíznám az arduinora, mint egy raspire.
Jogos lehet, de én akkor sem vacakolnék az ethernet shielddel, meg arduinos kijelzőkkel. Feldobnék egy áRPi-t, touch LCD-vel, nem olyan nagy költség, és nem kell tabletet, meg telefont előszedegetni, ha valamit meg akarsz nézni.

(#1419) gyapo11 válasza softguner (#1418) üzenetére
Ha lehetne kívánni oprendszert raspire, az dos-win311 lenne, mondjuk egy basic meg egy pascal fordítóval, ami elér minden portot, tud ablakozni, rajzolni, képernyőre írni, médiafile-t lejátszani.
Rémálom... Kurbli az S Mercire, meg kézi szívató...

Inkább azt csinálnám, hogy összedobnék egy sw/hw dokumentált Raspberry-s projektet a szenzor kezelésre, és megpróbálnám az Arduino-s vezérlőket hozzáragasztgatni.

[ Szerkesztve ]

"Mindig a rossz győz, és a jó elnyeri méltó büntetését." Voga János

A buszra köthetőség nagyon kényelmes.
Azért a DHT22-vel se kell rögtön feladni, viszont madzagolni mindenképpen egyenként kell, és az arduino előtt valami címezhető szelektorral beolvasni. 3 pin címzésre, egy beolvasásra és 4 pinnel megvan 8 szenzor. De lehet, hogy kitennék két vagy három pro minit, azokra a szenzorokat, és az összes arduinot egy rs485 buszra. A lekérdezésre van is már megírt library, egy csomó plusz funkcióval (www.github.com/takyka/ArduIO).

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Rémálom... Kurbli az S Mercire, meg kézi szívató...

Úgy tűnhet, de barkácsolgatós emberekből hányan rittyentenek egy programot javaban vagy visual akármiben és hányan basicben vagy pascalban? Nem tudom most mit tanítanak a fiataloknak. Az objektumorientált programozási nyelvek nem azonos tanulási időt és programozási képességet igényelnek az egyszerű procedurális nyelvekkel. Egy nap alatt el lehet jutni a működő programhoz akár basiccel akár pascallal, a processzornak meg olyan mindegy, hogy miben írták, sőt minél alacsonyabb szintű a nyelv, annál jobban ki lehet használni a processzort, nem fut fölösleges köröket. A méretről nem is beszélve, mert amikor 1 MB egy "hello world" program, az nemigen fér be az arduinoba.
És mivel ez nem ipari technológia, csak ahhoz hasonló játék, pont az lenne a cél, hogy minél nagyobb tömegek tudják használni. Az arduino nyelve is hasonló szintű. Az androidos telókra ugye javaban kell programot írni, és nem látni programozó tömegeket, pedig a nyelv ingyenes, mindenki a playt böngészi, hogy hátha egy java tudor képes volt már összerakni valamit, ami jó lenne neki. Föltettem egy pascal értelmező appot a telóra, és a régi programjaim simán futnak, persze a hw függő dolgokat (grafikát, érintést, portokat) is bele kellene tenni. És azonnal százezrek tudnának a telóra natív programokat írni.
Itt van ez a fűtés példa. Most ugye bele kell passzírozni valami html oldal generálást az arduinoba, pedig ha androidra is lehetne könnyen natív programot írni, akkor elkérne a hálózaton egyetlen ethernet frame-et az arduinotol, és olyan gyönyörűen jelenítené meg, hogy csak. Ez már c64-gyel is egyszerű feladat volt 30 éve.
De ez a javaval nincs megoldva, valószínűleg a googlenak nem volt célja, hogy mindenki tudja programozni az androidos eszközeit.
Vagyis jó dolog a Merci, de ha nem tudjuk vezetni, akkor nem sokat ér, és inkább legyen szervo nélküli kormány meg fék, mint hogy ne tudjam kezelni.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Hát megmondom őszintén, nekem, pont az lenne a tervem, hogy az adatokat csak lekérdezem az arduino-ról, és gyönyörűen megjelenítem androidon.

Valami ilyesmi!
Vagy ez így alapvetően hibás elképzelés?

Persze lelkesedésemet még mindig határtalan hozzánemértésem táplálja, szóval ez csak a terv.

Ha megy a java, akkor hajrá.
Ha böngészőből nyitod meg az arduino ip-címét, akkor az arduino által generált html oldalt látod, mivel az arduino kicsi a php értelmezőhöz.
Tehát ha php-t akarsz betölteni, akkor php-t futtató server kell, gondolom a blynk is ilyen. De ehhez nem szükséges a java. És a blynk programozói meg tudták írni, hogy elkérik az adatot az arduinotól, és onnantól szép weboldalt generálnak a behúzgált elemekkel a megkapott adatokkal. Hogy server vagy kliens oldalon, az most mindegy.

A java programozásnak ott lenne jelentősége, ha a tableten vagy más android eszközön te magad akarod megírni a megjelenítést mindenféle server nélkül, és az arduinonak csak az adatokat kell küldenie ethernet csomagokkal, de akár BT-on vagy bárhogy. 10 szenzor, meg még 5 adat a kazánról legyen 25 byte, egy infra leden is kivillogja egy pillanat alatt.

Amit még lehet próbálni, az a javascript. Ezt a böngésző futtatja, és szép látványos megjelenést lehet vele rajzolni. Az arduinonak össze kell rakni az összes adatot egybe, ezt belerakni a generált html oldalba mondjuk egy form hidden mezőben, innen a javascript megkapja. Ez se túl könnyű nyelv, debugolás nehézkes. Viszont sok kész library van hozzá, és nem kell az arduinoról betölteni, mutathat a link máshova is a neten, ahonnan betöltődik. Viszont így ehhez is kell net.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Nos, vettem ma 2-2db kondit azokból, amiket írtál, és párhuzamosan az infra vevő táp lábaira kb az infrától 1 centi közelségben ráforrasztottam 1-1-et mindegyikből, ahogy mondtad. Az eredmény bámulatos: ugyanúgy semmit nem csinál, ha külön tápról használom...Bedugom usb-vel, megy (viszont már olyat is csinál, hogy 1. gombnyomást érzékeli, a többit nem, csak ha kihúzom-bedugom a tápot, de ezt betudom program hibának, bár érdekes, mert eddig sosem csinált ilyet, mármint amíg programoztam, csak múltkor kezdte el, mikor próbálgattam a buck-okat, meg fesz.szintet lejjebb vettem, akkor kezdte el, és most is csinálja.). Vagy lehet, hogy kezd behalni az infrám?! Pár hete, mikor elég kánikula volt, elfelejtettem 1-2 percig letakarni kint a napon az infrát, előfordulhat, hogy attól hülyült meg? Azt tudom, hogy a nap nem tesz jót neki.
Benne van már jó pár ezer forintomban a projekt, úgyhogy nem szívesen önteném le benzinnel, és gyújtanám meg az egészet, pedig már gondoltam rá.

(#1416) gyapo11: vagy vakuzott egyet, ez tetszett.

(#1424) gyapo11: én 3 éve még C-ben "tanultam" programozni egyetemen (az anyagot ledarálta a tanár, mindenki csak pislogott egész félévben ), 1 és 2 évvel ezelőtt pedig ASIC tantárgyam volt, VHDL nyelven, elvileg Pascal alapú, de azt meg eléggé félvállról vette a tanár és a hallgatók is.

Huawei P30 // Suzuki DL650XT '15 <-- Kawasaki Z750 '07 <-- Aprilia RS 125 '99

Hali! egy kis segítség kellene!
Időre szeretném kapcsólni a reléket egy RTC-vel,de nem értek a programozáshoz.
Hogy lehetne ezt megvalósitani?

/* YourDuino Example: 8-channel Solid State Relay Board
This board is "active high".
terry@yourduino.com */

/*-----( Import needed libraries )-----*/
/*-----( Declare Constants )-----*/
#define RELAY_ON 1
#define RELAY_OFF 0

#define Relay_1 2 // Arduino Digital I/O pin number
#define Relay_2 3
#define Relay_3 4
#define Relay_4 5
#define Relay_5 6
#define Relay_6 7
#define Relay_7 8
#define Relay_8 9
/*-----( Declare objects )-----*/
/*-----( Declare Variables )-----*/
int waittime; // Delay between changes
void setup() /****** SETUP: RUNS ONCE ******/
{
waittime = 1000;
//-------( Initialize Pins so relays are inactive at reset)----
digitalWrite(Relay_1, RELAY_OFF);
digitalWrite(Relay_2, RELAY_OFF);
digitalWrite(Relay_3, RELAY_OFF);
digitalWrite(Relay_4, RELAY_OFF);
digitalWrite(Relay_5, RELAY_OFF);
digitalWrite(Relay_6, RELAY_OFF);
digitalWrite(Relay_7, RELAY_OFF);
digitalWrite(Relay_8, RELAY_OFF);

//---( THEN set pins as outputs )----
pinMode(Relay_1, OUTPUT);
pinMode(Relay_2, OUTPUT);
pinMode(Relay_3, OUTPUT);
pinMode(Relay_4, OUTPUT);
pinMode(Relay_5, OUTPUT);
pinMode(Relay_6, OUTPUT);
pinMode(Relay_7, OUTPUT);
pinMode(Relay_8, OUTPUT);
delay(4000); //Check that all relays are inactive at Reset

}//--(end setup )---

void loop() /****** LOOP: RUNS CONSTANTLY ******/
{
//---( Turn all 8 relays ON in sequence)---
digitalWrite(Relay_1, RELAY_ON);// set the Relay ON
delay(waittime); // wait for a second
digitalWrite(Relay_2, RELAY_ON);// set the Relay ON
delay(waittime); // wait for a second
digitalWrite(Relay_3, RELAY_ON);// set the Relay ON
delay(waittime); // wait for a second
digitalWrite(Relay_4, RELAY_ON);// set the Relay ON
delay(waittime);
digitalWrite(Relay_5, RELAY_ON);// set the Relay ON
delay(waittime); // wait for a second
digitalWrite(Relay_6, RELAY_ON);// set the Relay ON
delay(waittime); // wait for a second
digitalWrite(Relay_7, RELAY_ON);// set the Relay ON
delay(waittime); // wait for a second
digitalWrite(Relay_8, RELAY_ON);// set the Relay ON
delay(waittime * 4); // wait see all relays ON

//---( Turn all 8 relays OFF in sequence)---
digitalWrite(Relay_1, RELAY_OFF);// set the Relay OFF
delay(waittime); // wait for a second
digitalWrite(Relay_2, RELAY_OFF);// set the Relay OFF
delay(waittime); // wait for a second
digitalWrite(Relay_3, RELAY_OFF);// set the Relay OFF
delay(waittime); // wait for a second
digitalWrite(Relay_4, RELAY_OFF);// set the Relay OFF
delay(waittime);
digitalWrite(Relay_5, RELAY_OFF);// set the Relay OFF
delay(waittime); // wait for a second
digitalWrite(Relay_6, RELAY_OFF);// set the Relay OFF
delay(waittime); // wait for a second
digitalWrite(Relay_7, RELAY_OFF);// set the Relay OFF
delay(waittime); // wait for a second
digitalWrite(Relay_8, RELAY_OFF);// set the Relay OFF
delay(waittime * 4); // wait see all relays OFF

}//--(end main loop )---

//*********( THE END )***********

az időre kapcsolás mit jelent? Megadott pillanatban azaz X óra Y perc és Z másodperckor, vagy megadott időközönként?

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Mivel rtc-vel méri az időt, szerintem év-hónap-nap-óra-perc-másodpercre akarja kapcsolgatni. Többféle módszer is lehetséges, nem tudom melyik a legcélszerűbb. Amit én próbáltam 3231-gyel, ott byte-okba olvasta be az adatokat, és kiírta. Vagy át kell számolni másodpercbe, és a megcélzott időponthoz hasonlítgatni, vagy az időpontot kell byte-okban tárolni, és ahhoz komparálni a pillanatnyi időt, vagy timert futtatni kiszámolva a hátralevő időt, vagy az rtc alarmját használni, és minden alarm után a következő eseményt beleírni.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Hali!

Minden relét külön szeretnék kapcsolni. 8:00-kor az 1-es. 9:00-kor a 2-es.10:00-kor a 3-as.stb.
Majd a lekapcsolás 16:00-kor az 1-es. 17:00-kor a 2-es.stb

Így azért jóval egyszerűbb. Figyelni kell a 8 órát, ha megvan, akkor indul egy ciklus 1-től 8-ig, ami a millist használva óránként bekapcsolja a következőt, utána másik ciklus óránként kikapcsolja.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

millis() sem kell, elég ha csak szó szerint az órát figyeli. Amúgy ezek az RTC-k elég pontosak, amit én használok másfél év alatt egy másodpercet sem késett talán.

De persze itt is programozója választja a megoldást. Én ilyet használok, ezen elvileg egy EEPROM is van amit akármire használhat az ember. Hozzá pedig ezt a library-t használom: [link]

[ Szerkesztve ]

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Alább megadtam a kódot, de nem tudom, hogy hova mit írjak és mit állítsak be. Ebben kéne valami segítség.

Igen! Én is inkább az órát használnám,nem a millist

[ Szerkesztve ]

Üdv.
Megjött az ESP8266-os wifi modulom, viszont nem tudok vele boldogulni.
Összekötöttem (remélem jól), de bármilyen kód is van az arduinon, a wifi az egy AP-ként működik, még csatlakozni is tudok hozzá.
Mit csináljak, hogy tudjon csatlakozni a routerhez, hogy aztán kapcsolatba tudjak léni vele neten keresztül?

ASRock X79 Extreme6, i7 4930K, 32GB DDR3, GTX 1080 G1, Corsair RM750x...

Nem tudom mivel próbáltad, nekem egy librarym van, abban ezek a példák vannak:
Enable_Access_Point
Light_Station_Client_Arduino_Uno
Light_Station_Server_IPST_SE
Once_TCP_Client
Once_TCP_Server
Simple_TCP_Client
Simple_TCP_Server
WiFi_Connection
WiFi_Connection_Loop
Ha ilyeneket nem próbáltál és nem találod a neten, akkor fölteszem valahova.
Meg érdemes megnézni ezt, itt ledeket kapcsolgat telóval vezérelve.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Ez a link csak megával működik a két serial miatt, hiába tettem bele a softwareserialt, akkor meg a változók nem fértek bele a nanoba.

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

Hali!
Meg tudná mondani valaki,hol a hiba?
Időre szeretném be és kikapcsolni a reléket,de nem akar összejönni. Feltölti,de egyből bekapcsol a relé és nem kapcsol le.

#include <Wire.h>

int hour;
int minute;
int second;
int relPin1 = 6; // 1-es csatorna
int relPin2 = 7; // 2-es csatorna
int relPin3 = 8; // 3-as csatorna
int relPin4 = 9; // 4-es csatorna

void setup()
{
Serial.begin(9600);
Wire.begin();
digitalWrite(relPin1, LOW);
pinMode(relPin1,OUTPUT);
digitalWrite(relPin2, LOW);
pinMode(relPin2,OUTPUT);
digitalWrite(relPin3, LOW);
pinMode(relPin3,OUTPUT);
digitalWrite(relPin4, LOW);
pinMode(relPin4,OUTPUT);
}

void loop()
{

Wire.beginTransmission(104);
Wire.write(0x00);
Wire.endTransmission();
Wire.requestFrom(104, 6);
second = Wire.read();
minute = Wire.read();
hour = Wire.read();

hour=hour/16 * 10 + hour % 16;
minute=minute/16 * 10 + minute % 16;
second=second/16 * 10 + second % 16;

Serial.print(hour);
Serial.print(":");
if (minute < 10) { Serial.print("0"); }
Serial.print(minute);
Serial.print(":");
if (second < 10) { Serial.print("0"); }
Serial.print(second);
Serial.print("\n");
delay(1000);

// Vilagitás (be) and (ki) ha 10:10 kor szeretned bekapcsolni, akkor 10x60+10=610, ezt ird be, hasonló az eljárás, a kikapcsolási idővel

if (0*60+20=80 and 0*60+21=81)
{
digitalWrite (relPin1, HIGH);
}
else
{
digitalWrite (relPin1, LOW);
}
if (23*60+55>540 and 23*60+56<1140)
{
digitalWrite (relPin2, HIGH);
}
else
{
digitalWrite (relPin2, LOW);
}

}

[ Szerkesztve ]

Ekkora programot már nem nagyon tudok fejben lekövetni, de az ifben mintha lenne hiba:
if (0*60+20=80 and 0*60+21=81)

ezt így írnám:
if (0*60+20==80 && 0*60+21==81)

menyország -> mennyország, akadáj -> akadály, jótálás -> jótállás, Iphoneal > Iphone-nal, kisuly > kisujj, csővet > csövet

ment PM!

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Ezt a libraryt nem próbáltam, jó lenne ha el küldenéd nekem vagy felraknád valahova.
Köszi.

ASRock X79 Extreme6, i7 4930K, 32GB DDR3, GTX 1080 G1, Corsair RM750x...

Köszi a segítséget,de nem akar jó lenni.
Be tudom állítani az órát ez már megy De nem tudom még összeollozni sem úgy,hogy az jó legyen.

a relék pinjei 2,3,4,5,6,7,8,9 . De arra írod át amire akarod, a relays tömbben.

[ Szerkesztve ]

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Ilyen apróságokat megoldok,ezzel nincsen gond.
Ezzel a kóddal tudom beállítani az órát. Ez alapján DS3232 az RTC,de hiába írom át a te kódodban,hibát ír ki.

#include <SoftI2C.h>
#include <DS3232RTC.h>
#include <avr/pgmspace.h>
#include <string.h>

SoftI2C i2c(A4, A5);
DS3232RTC rtc(i2c);
char buffer[64];
size_t buflen;

const char *days[] = {
"Mon, ", "Tue, ", "Wed, ", "Thu, ", "Fri, ", "Sat, ", "Sun, "
};

const char *months[] = {
" Jan ", " Feb ", " Mar ", " Apr ", " May ", " Jun ",
" Jul ", " Aug ", " Sep ", " Oct ", " Nov ", " Dec "
};

static uint8_t monthLengths[] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};

inline bool isLeapYear(unsigned int year)
{
if ((year % 100) == 0)
return (year % 400) == 0;
else
return (year % 4) == 0;
}

inline uint8_t monthLength(const RTCDate *date)
{
if (date->month != 2 || !isLeapYear(date->year))
return monthLengths[date->month - 1];
else
return 29;
}

void setup() {
Serial.begin(9600);
buflen = 0;
cmdHelp(0);
}

void loop() {
if (Serial.available()) {
// Process serial input for commands from the host.
int ch = Serial.read();
if (ch == 0x0A || ch == 0x0D) {
// End of the current command. Blank lines are ignored.
if (buflen > 0) {
buffer[buflen] = '\0';
buflen = 0;
processCommand(buffer);
}
} else if (ch == 0x08) {
// Backspace over the last character.
if (buflen > 0)
--buflen;
} else if (buflen < (sizeof(buffer) - 1)) {
// Add the character to the buffer after forcing to upper case.
if (ch >= 'a' && ch <= 'z')
buffer[buflen++] = ch - 'a' + 'A';
else
buffer[buflen++] = ch;
}
}
}

void printDec2(int value)
{
Serial.print((char)('0' + (value / 10)));
Serial.print((char)('0' + (value % 10)));
}

void printProgString(PGM_P str)
{
for (; {
char ch = (char)(pgm_read_byte(str));
if (ch == '\0')
break;
Serial.print(ch);
++str;
}
}

byte readField(const char *args, int &posn, int maxValue)
{
int value = -1;
if (args[posn] == ':' && posn != 0)
++posn;
while (args[posn] >= '0' && args[posn] <= '9') {
if (value == -1)
value = 0;
value = (value * 10) + (args[posn++] - '0');
if (value > 99)
return 99;
}
if (value == -1 || value > maxValue)
return 99;
else
return value;
}

// "TIME" command.
void cmdTime(const char *args)
{
RTCTime time;
if (*args != '\0') {
// Set the current time.
int posn = 0;
time.hour = readField(args, posn, 23);
time.minute = readField(args, posn, 59);
if (args[posn] != '\0')
time.second = readField(args, posn, 59);
else
time.second = 0;
if (time.hour == 99 || time.minute == 99 || time.second == 99) {
Serial.println("Invalid time format; use HH:MM:SS");
return;
}
rtc.writeTime(&time);
Serial.print("Time has been set to: ");
}

// Read the current time.
rtc.readTime(&time);
printDec2(time.hour);
Serial.print(':');
printDec2(time.minute);
Serial.print(':');
printDec2(time.second);
Serial.println();
}

// "DATE" command.
void cmdDate(const char *args)
{
RTCDate date;
if (*args != '\0') {
// Set the current date.
unsigned long value = 0;
while (*args >= '0' && *args <= '9')
value = value * 10 + (*args++ - '0');
if (value < 20000000 || value >= 21000000) {
Serial.println("Year must be between 2000 and 2099");
return;
}
date.day = (byte)(value % 100);
date.month = (byte)((value / 100) % 100);
date.year = (unsigned int)(value / 10000);
if (date.month < 1 || date.month > 12) {
Serial.println("Month must be between 1 and 12");
return;
}
uint8_t len = monthLength(&date);
if (date.day < 1 || date.day > len) {
Serial.print("Day must be between 1 and ");
Serial.println(len, DEC);
return;
}
rtc.writeDate(&date);
Serial.print("Date has been set to: ");
}

// Read the current date.
rtc.readDate(&date);
Serial.print(days[RTC::dayOfWeek(&date) - 1]);
Serial.print(date.day, DEC);
Serial.print(months[date.month - 1]);
Serial.println(date.year, DEC);
}

// "TEMP" command.
void cmdTemp(const char *args)
{
int temp = rtc.readTemperature();
if (temp != RTC:O_TEMPERATURE) {
Serial.print(temp / 4.0);
Serial.println(" degrees celcius");
} else {
Serial.println("Temperature is not available");
}
}

void printAlarm(byte alarmNum, const RTCAlarm *alarm)
{
Serial.print("Alarm ");
Serial.print(alarmNum + 1, DEC);
Serial.print(": ");
if (alarm->flags & 0x01) {
printDec2(alarm->hour);
Serial.print(':');
printDec2(alarm->minute);
Serial.println();
} else {
Serial.println("Off");
}
}

// "ALARMS" command.
void cmdAlarms(const char *args)
{
RTCAlarm alarm;
for (byte alarmNum = 0; alarmNum < RTC::ALARM_COUNT; ++alarmNum) {
rtc.readAlarm(alarmNum, &alarm);
printAlarm(alarmNum, &alarm);
}
}

const char s_ON[] PROGMEM = "ON";
const char s_OFF[] PROGMEM = "OFF";

// "ALARM" command.
void cmdAlarm(const char *args)
{
RTCAlarm alarm;
int posn = 0;
byte alarmNum = readField(args, posn, RTC::ALARM_COUNT);
if (!alarmNum || alarmNum == 99) {
Serial.print("Alarm number must be between 1 and ");
Serial.println(RTC::ALARM_COUNT, DEC);
return;
}
--alarmNum;
while (args[posn] == ' ' || args[posn] == '\t')
++posn;
if (args[posn] != '\0') {
// Set the alarm to a new value.
if (matchString(s_ON, args + posn, strlen(args + posn))) {
rtc.readAlarm(alarmNum, &alarm);
alarm.flags = 1;
} else if (matchString(s_OFF, args + posn, strlen(args + posn))) {
rtc.readAlarm(alarmNum, &alarm);
alarm.flags = 0;
} else {
alarm.hour = readField(args, posn, 23);
alarm.minute = readField(args, posn, 59);
if (alarm.hour == 99 || alarm.minute == 99) {
Serial.println("Invalid alarm time format; use HH:MM");
return;
}
alarm.flags = 1;
}
rtc.writeAlarm(alarmNum, &alarm);
}

// Print the current state of the alarm.
rtc.readAlarm(alarmNum, &alarm);
printAlarm(alarmNum, &alarm);
}

// "NVRAM" command.
void cmdNvram(const char *args)
{
static const char hexchars[] = "0123456789ABCDEF";
int count = rtc.byteCount();
for (int offset = 0; offset < count; ++offset) {
if ((offset % 16) == 0) {
if (offset)
Serial.println();
Serial.print(hexchars[(offset >> 12) & 0x0F]);
Serial.print(hexchars[(offset >> 8) & 0x0F]);
Serial.print(hexchars[(offset >> 4) & 0x0F]);
Serial.print(hexchars[offset & 0x0F]);
Serial.print(':');
Serial.print(' ');
}
byte value = rtc.readByte(offset);
Serial.print(hexchars[(value >> 4) & 0x0F]);
Serial.print(hexchars[value & 0x0F]);
Serial.print(' ');
}
Serial.println();
}

// List of all commands that are understood by the sketch.
typedef void (*commandFunc)(const char *args);
typedef struct
{
PGM_P name;
commandFunc func;
PGM_P desc;
PGM_P args;
} command_t;
const char s_cmdTime[] PROGMEM = "TIME";
const char s_cmdTimeDesc[] PROGMEM =
"Read or write the current time";
const char s_cmdTimeArgs[] PROGMEM = "[HH:MM:SS]";
const char s_cmdDate[] PROGMEM = "DATE";
const char s_cmdDateDesc[] PROGMEM =
"Read or write the current date";
const char s_cmdDateArgs[] PROGMEM = "[YYYYMMDD]";
const char s_cmdTemp[] PROGMEM = "TEMP";
const char s_cmdTempDesc[] PROGMEM =
"Read the current temperature";
const char s_cmdAlarms[] PROGMEM = "ALARMS";
const char s_cmdAlarmsDesc[] PROGMEM =
"Print the status of all alarms";
const char s_cmdAlarm[] PROGMEM = "ALARM";
const char s_cmdAlarmDesc[] PROGMEM =
"Read or write a specific alarm";
const char s_cmdAlarmArgs[] PROGMEM = "NUM [HH:MM|ON|OFF]";
const char s_cmdNvram[] PROGMEM = "NVRAM";
const char s_cmdNvramDesc[] PROGMEM =
"Print the contents of NVRAM, excluding alarms";
const char s_cmdHelp[] PROGMEM = "HELP";
const char s_cmdHelpDesc[] PROGMEM =
"Prints this help message";
const command_t commands[] PROGMEM = {
{s_cmdTime, cmdTime, s_cmdTimeDesc, s_cmdTimeArgs},
{s_cmdDate, cmdDate, s_cmdDateDesc, s_cmdDateArgs},
{s_cmdTemp, cmdTemp, s_cmdTempDesc, 0},
{s_cmdAlarms, cmdAlarms, s_cmdAlarmsDesc, 0},
{s_cmdAlarm, cmdAlarm, s_cmdAlarmDesc, s_cmdAlarmArgs},
{s_cmdNvram, cmdNvram, s_cmdNvramDesc, 0},
{s_cmdHelp, cmdHelp, s_cmdHelpDesc, 0},
{0, 0}
};

// "HELP" command.
void cmdHelp(const char *)
{
int index = 0;
for (; {
PGM_P name = (PGM_P)(pgm_read_word(&(commands[index].name)));
if (!name)
break;
PGM_P desc = (PGM_P)(pgm_read_word(&(commands[index].desc)));
PGM_P args = (PGM_P)(pgm_read_word(&(commands[index].args)));
printProgString(name);
if (args) {
Serial.print(' ');
printProgString(args);
}
Serial.println();
Serial.print(" ");
printProgString(desc);
Serial.println();
++index;
}
}

// Match a data-space string where the name comes from PROGMEM.
bool matchString(PGM_P name, const char *str, int len)
{
for (; {
char ch1 = (char)(pgm_read_byte(name));
if (ch1 == '\0')
return len == 0;
else if (len == 0)
break;
if (ch1 >= 'a' && ch1 <= 'z')
ch1 = ch1 - 'a' + 'A';
char ch2 = *str;
if (ch2 >= 'a' && ch2 <= 'z')
ch2 = ch2 - 'a' + 'A';
if (ch1 != ch2)
break;
++name;
++str;
--len;
}
return false;
}

// Process commands from the host.
void processCommand(const char *buf)
{
// Skip white space at the start of the command.
while (*buf == ' ' || *buf == '\t')
++buf;
if (*buf == '\0')
return; // Ignore blank lines.

// Extract the command portion of the line.
const char *cmd = buf;
int len = 0;
for (; {
char ch = *buf;
if (ch == '\0' || ch == ' ' || ch == '\t')
break;
++buf;
++len;
}

// Skip white space after the command name and before the arguments.
while (*buf == ' ' || *buf == '\t')
++buf;

// Find the command and execute it.
int index = 0;
for (; {
PGM_P name = (PGM_P)(pgm_read_word(&(commands[index].name)));
if (!name)
break;
if (matchString(name, cmd, len)) {
commandFunc func =
(commandFunc)(pgm_read_word(&(commands[index].func)));
(*func)(buf);
return;
}
++index;
}

// Unknown command.
Serial.println("Unknown command, valid commands are:");
cmdHelp(0);
}

Te ezzel állítod be az órát az RTC-n?
Nekem ennyi a beállítás:

#include <DS3231.h>
#include <Wire.h>

DS3231 Clock;
bool h12;
bool PM;

void setup()
{
Wire.begin();

Clock.setSecond(20);//Set the second
Clock.setMinute(00);//Set the minute
Clock.setHour(22); //Set the hour
Clock.setDoW(2); //Set the day of the week
Clock.setDate(7); //Set the date of the month
Clock.setMonth(7); //Set the month of the year
Clock.setYear(15); //Set the year (Last two digits of the year)
}

void loop()
{
}

Huawei P30 // Suzuki DL650XT '15 <-- Kawasaki Z750 '07 <-- Aprilia RS 125 '99

de ő 3232-t használ . Amúgy 3231-en tényleg csak ennyi, én is azt használom.

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

Ez aztán az órabeállítás
Ez komoly? Minden indításkor 2015-07-07 22:00:20 lesz az idő?

elvileg ennyi: [link]

Sajnos ezt tesztelni nem tudtam, mert nincs DS3232-m. D3232 library-t meg ezt használtam hozzá : [link]

Time header kell hozzá !

[ Szerkesztve ]

Nokia 6030 Hardcore User // I Panic Restaurant by Taito

IGEN!!!
Ezzel megy! De most nézegetem és lehet ,hogy DS1307 az óra modul.
Igazából 4 db relét szeretnék időre vezérelni(be és kikapcsolni),de csak szívok vele.