- Radeon RX 9060 XT: Ezt aztán jól meghúzták
- Atomenergiával dübörögnek tovább az Amazon adatközpontok, SMR-ek is jöhetnek
- Macron betiltatná az EU-ban a közösségi médiát a 15 év alattiaknak
- Az NVIDIA ipari AI-felhőt épít a németeknek, együtt az OpenAI és a Google
- Két új Ryzen közül választhatnak a kézikonzolok
-
PROHARDVER!
Arduino hardverrel és szoftverrel foglakozó téma. Minden mikrovezérlő ami arduinoval programozható, és minden arduino program, board, és hardverrel kapcsolatos kérdések helye.
Új hozzászólás Aktív témák
-
inf3rno
nagyúr
válasz
gyapo11
#1497
üzenetére
[link] Nagyjából az jön le, hogy RPI nagyon jó statikus tartalmak kiszolgálásában. Ha adtbázis meg komolyabb lekérdezések vannak, akkor meg hajlamos elfogyni a memória.
@s3toraph
Szerintem ennyi info alapján nem tudjuk pontosan megítélni, hogy mire kell tenni a webszerveredet. El kellene tervezned, hogy pontosan milyen lekérdezéseket fog támogatni a rendszer. Ezeket előre megírni teszt adatokkal, és tesztelni, hogy mekkora a memória igényük, cpu használatuk, stb. Utána te is meg fogod tudni mondani, hogy egy RPI a maga fél giga memóriájával alkalmas e a feladatra.
Nekem az jött le, hogy csak napi meg havi szintű adatsorok kellenek, azt statikus csv fájlokból is ki lehet szolgálni, nem kell hozzá sem adatbázis, sem szűrés vagy query. Egyszerűen minden szenzornak csinálsz egy mappát, amiben 1-1 fájlban egy adott nap mérései lesznek, plusz mentesz heti és havi összesítőkbe is adatot nagyobb időközönként. A vezérlésnél is az jött le, hogy semmi komolyabb dolog nem lesz benne. Szóval én nem érzem úgy, hogy a webszerver része ne lenne megvalósítható egy apró gépen, és ehhez külön szervergép kellene. Persze, ha komolyabb szűrés kell a logokban, és muszáj adatbázisba tenni az egészet, akkor az már más. Ebben az esetben érdemes lenne megpróbálni, hogy egy ilyen célra kihegyezett postgresql hogyan teljesít egy pc-n. Ugyanúgy memória használat, stb... terén. Én azt hallottam, hogy 128 mega ramon elfér egy linux mellett egy postgresql. Ezen kívül vannak kis méretű nosql adatbázisok is, de azok nem hiszem, hogy query-ben komolyat tudnának. Konkurrens kérés sem lesz a szerver felé sok, szóval ez is inkább azt támasztja alá, hogy nem kell komoly vas neki.
-
gyapo11
őstag
-
gyapo11
őstag
válasz
s3toraph
#1494
üzenetére
Úgy szeretném megoldani a dolgot, hogy önálló rendszer legyen. Ne a PC tároljon, számoljon, mert ahhoz üzemelnie kell. Önállóan működjön az eszköz.
Az a kérdés, mi az önálló működés. Ha a szenzorok kiolvasása, a feltételek szerinti beavatkozás, akkor önálló net nélkül is. Ha a megjelenítés is, akkor már jönnek a határok. Ha adatbázis is, akkor el se tudom képzelni. Sd-kártyára nyilván jó sok mérés elfér, de amíg abból egy szűrt megjelenítés lesz, ha egyáltalán ki tudja számolni, az egy fél óra. Pedig ebben még számolás sincs, csak végig kell olvasni az adatokat, és a feltételeknek megfelelőeket megjeleníteni.
A max amit el tudok képzelni működőnek az a routeren át egy serverre fölmásolni, nem tudom hogy kell ezt megírni, én még csak az egyszerű html oldal példákat láttam.
Ha egy hőfokot átszámolunk egy byte-ba, és 10 hőmérő van, 10 percenként mérünk, az napi 1440 byte. Egy év után ez 525600 byte, és ebből vagyunk kíváncsiak, hogy mikor volt valahol 17 foknál kevesebb, és Fahrenheitben kellene kijelezni. Ez sqlben kb 1 sor meg egy while a php scriptben, ami kinyomja táblázatos formában a weboldalra az eredményt, és mire fölengedjük az entert már ott van. Még a raspiről se tudok elképzelni elfogadható válaszidőt. -
gyapo11
őstag
válasz
inf3rno
#1493
üzenetére
Olyan az arduinonak a webserver mint amikor kiskanállal ásod ki az emésztőt. Ki lehet? Ki. De nem a kiskanál a megfelelő eszköz. És ha kicsit is köves a talaj, akkor már nem fog menni. A webserver is pillanatok alatt ki tudja nőni az arduinot. Amíg egy 10-20 soros html forrást kell generálni, addig még csak-csak, de utána kifullad. Egy pár szenzorig, egyszerű kijelzésig jó, ha komolyabb kell, akkor felejtős. Az meg, hogy a serverről fontokat, javascripteket, flasheket is beszív a böngésző végképp nem játszik. Az arduino egy mikrovezérlő, egychipes cucc az adott memóriákkal, ráadásul nem is assemblyben kódolunk rá kihasználva maximálisan a hw-t, ráadásul librarykat öntünk a nyakába, amit valaki összelapátolt valahogy működőre jó esetben.
Egy internet szolgáltatónál egy account php értelmezője kap mondjuk 1 GB ramot, és van mögötte egy linux meg egy desktop géphez hasonló teljesítményű processzoridő. Ezt szoktuk meg, hogy ez egy server, 0.02 sec oldalgenerálási idővel. Ennél még a raspi is lassúbb jóval, de az arduino meg csak álmodozhat ilyenekről.
Nem volt még a kezemben raspi, nem is láttam azon futó weboldalt, nyilván annak is megvannak a jóval tágabb határai, de profi kinézetet normális válaszidőkkel csak desktop gép sebességgel és memóriával lehet csinálni, vagy többel.Úgyhogy én továbbra is azt javaslom, hogy az arduinot csak végeszköznek használjátok, ami mér, beavatkozik, kapcsolatot tart leginkább soros porton.
-
Nagytoll
senior tag
Hello! Egy uno r3 másolatra seretnék bootloadert rakni usbasp-vel, drivert telepítettem, de az arduino IDE ezt a hibaüzenetet adja, mit rontok el?
windows 10 van most feltelepítve, ez gondot okozhat?
Hibaüzenet: Arduino: 1.6.5 (Windows 8.1), Board: "Arduino Uno"avrdude: warning: cannot set sck period. please check for usbasp firmware update.
Error while burning bootloader.
avrdude: error: programm enable: target doesn't answer. 1
avrdude: initialization failed, rc=-1
Double check connections and try again, or use -F to override
this check.
This report would have more information with
"Show verbose output during compilation"
enabled in File > Preferences. -
s3toraph
senior tag
válasz
inf3rno
#1490
üzenetére
A webböngészőben a kinyert adatokat lehetne megnézni, de pl. funkciókat lehetne ki-be kapcsolni is, pl. hogy szobánként ki-be lehetne kapcsolni a monitorozást. Tehát lenne vezérlés is.
Egyelőre PC-re kötve futna, aztán ha működik, netes elérést megvalósítása is jöhet, addig még majd kiderítem hogy hogyan lehet biztonságosan megoldani, legegyszerűbben.Persze én is úgy gondolom, hogy előbb működjön vezetékesen. Aztán majd meglátom, lesz-e továbbgondolva, meg tudom-e oldani.
Hardverben nagyon nagy az eltérés a pi javára, de azért kérdezgetek hogy nehogy ágyúval verébre eset legyen.
(#1492) gyapo11 :
Még nem nagyon érkeztem visszaolvasni a topicban, igyekszem.
Úgy szeretném megoldani a dolgot, hogy önálló rendszer legyen. Ne a PC tároljon, számoljon, mert ahhoz üzemelnie kell. Önállóan működjön az eszköz. Amitöl függni fog, az a router a netkapcsolat biztosítása miatt, de azt sosem kapcsolom ki. Ill. az esetleges áramkimaradások, de nálunk nem szokott lenni, valamint lehet hogy meg tudom majd azt is oldani, mondjuk power bank-rol.
Úgy látom, az adatbázis, számítási igények miatt a pi lenne a jó vonal nekem.
-
inf3rno
nagyúr
válasz
gyapo11
#1492
üzenetére
Akkor mégis igaz. Én nem hittem el, hogy tényleg csak kb memóriák vannak az arduinoban. Az rpi-ben 256 meg talán 512 mega is van. Ennyivel esélytelen szerintem webszervert futtatni. Egy nodejs is megeszik 64MB-ot. Én két 128 megás kütyün próbálok majd adatbázist meg webszervert fellőni, de abban is kételkedem, hogy elmegy e bármilyen normális adatbázis (nem sqlite) egy ilyen szerveren.
-
gyapo11
őstag
válasz
inf3rno
#1491
üzenetére
Megírtam egy led kapcsolgatós példa címét kb. egy hete, egy formot ad, lehet kapcsolgatni a három ledet, és már nem fért bele a nanoba, mert 2000 byte fölött volt a változók helyigénye. Lehet próbálkozni eepromba írni a weboldal szöveges részét, és onnan kiolvasni, esetleg sd-kártyát, de az is megeszik sok helyet.
Vagyis lehet server, de elég hamar elfogynak a helyek. Lehet megát használni, ott van két soros port és több mem, de én nem bíznám arduinora a feladatot, ha van esély a bővítési igényre. Az meg pláne gond, ha olyan az oldal, hogy többen is néznék egyszerre a netről. Titkosítás is elég számításigényes, nem arduinonak való. Raspit nem ismerem közelebbről, de ha videót lejátszik, meg linux fut rajta, akkor az már sokmindent meg tud oldani, teljesen más kategória.
A mérési adatok begyűjtésére és pc-nek átadásra tökéletes, olcsó, kis fogyasztás, egyszerűsége miatt átlátható és üzembiztos, akár egy rendszeres reset is megoldható, 2 sec múlva újra működik, könnyen és olcsón bővíthető a rendszer pl. rs485 busszal max 30 eszközig, 1000 m-ig. -
inf3rno
nagyúr
válasz
s3toraph
#1488
üzenetére
Én nem szoktam szerver üzemeltetéssel foglalkozni, ezért nem tudom, hogy mennyire biztonságos. Nekem sokkal kényelmesebb, ha más csinálja, én meg csak felteszem rá a kódomat. Annyit tudok, amikor dyndns-el próbálkoztam pár éve, akkor napi szinten próbálták feltörni a szervert. A kóddal kapcsolatban ha titkosítot az oldal, akkor egy basic http auth elég a beléptetéshez, és mivel csak GET-es kérések vannak, így kb nulla az esélye, hogy alkalmazáson keresztül feltörik. Azért szarvas hibákat ne kövess el, validáljad a bejövő paramétereket, meg ne tedd bele őket http header-be (aka header injection), ha az adott nyelv erre nincs felkészítve, és így tovább.
Szerintem ne szaladj annyira előre. Koncentrálj inkább arra, hogy vezetékesen meglegyen, aztán csak utána kezdj el foglalkozni azzal, hogy vezeték nélkül meg tudod e csinálni. A szakdogád szempontjából szerintem lényegtelen, hogy vezetékes e vagy sem, és most az számít, hogy időre meglegyen.
20 sec-re talán elég egy sima polling is, és nem kell sse vagy websockets, tesztelni kell, hogy mennyit bír a kütyü. Teljesen jó, ha mindent sd kártyára mentesz, és a kütyü csinálja a szervert is. Ha nem kell komoly funkcionalitás bele, ahogy írod, akkor felesleges külön adatbázis meg ilyesmi neki. Ha csak annyit csinálsz, hogy a fájlba mentesz, és a kliens oldalon parsolod a txt fájlokat és rajzolod ki a grafikonokat mondjuk d3.js-el, akkor menni fog arduinoval is. Ha nem csak napi és havi szintű lekérdezések vannak, hanem nagyon meg van bonyolítva a dolog, akkor kellhet egy adatbázis, de én úgy látom, hogy ekkora bonyolultságnál nincs szükséged rá, elég a fájlrendszer. Azt viszont nem tudom megítélni, hogy egy arduino elbír e egy log fájlt meg egy webszervert. Nekem eddig az jött le, hogy igen.
-
gyapo11
őstag
válasz
stopperos
#1487
üzenetére
Eléggé hasonló a feladat, mint a kazánvezérlős, csak talán több a szenzor, meg nem kell kapcsolgatni a kazánt, ami 2 sor az arduinonak. Ha DS18B20-ból 10 mehet egy buszra, és ez egy pint foglal, akkor ezzel megoldható a hőfokok beolvasása, marad még bőven port a páratartalomra. De néhány plusz arduino soros buszra kötésével ez sokat bővíthető, az egész utcát el tudja látni.
Tehát itt megint az adatok kezelése a feladat. Ezt nem lenne érdemes lokálisra korlátozni, legyen neten. Erre jó a blynk-féle külső serveres megoldás, valami IoT-s megoldást is láttam, ezekre valószínűleg lehet találni példát is arduinora. De net kezelés kell arduinora, ami már nem olyan egyszerű, hamar befullad, mert elfogynak különböző helyek, csak a nagyon egyszerű feladatokra alkalmas.
Ezért jöhet szóba a pc bevetése, ahova az arduino át tudja adni soros porton az adatokat, onnantól a pc föl tudja tölteni serverre, és már kint is van a neten. Itt fölmerül a frissítés gyakorisága, mert a pc-nek bekapcsoltnak kell lenni az adatkezeléshez. Gondolom egy raspi is jó, soros portot kezel, és wputtal föl tudja tolni serverre.
Feltöltés után a serveren futó php script betölti adatbázisba, innentől villámgyors lesz az adatok kezelése, megjelenítése.
A megjelenítés ha nem gyári programmal történik (pl. blynk), akkor php-html-javascript, lényeg, hogy böngészőben legyen látható. Vannak kész libraryk, pl. jquery, processing.js, raphael.js stb., ezekkel bármilyen képernyőkép előállítható, pl. lakás alaprajz, benne a hőfokok vagy műszerek képe, csak a fantázia szab határt. -
s3toraph
senior tag
válasz
inf3rno
#1486
üzenetére
Közben írtam a másik topicba, hosszú inkább csak linekelem.
Alapvetően az eszköz csatlakozhatna LAN-on is. Mobilitás miatt wi-fi jobb lenne, de ez majd eldől. Tápellátást adapterröl kapna, folyamatosan. Magukat az érzékelőket kellene majd vezeték nélkülivé tenni, hogy ha működik a rendszer, utána megszabaduljak a kábelezéstől. Ha egy lakáson belül az RF olcsóbb, és megbízható, akkor az is jó megoldás lehet. Az érzékelőkhöz nem tudom, hogyan lehet akár RF, akár más vezeték nélküli adó modult kapcsolni. Valamint, ezek tápellátása (külön az érzékelő, ill. érzékelő + modul) hogy oldható meg? Csak hálózati adapterrel? Mondjuk ha elemes megoldással (láttam ilyen 2 db ceruzaelemes telepet vagy mit, mint energia forrást) nem bír ki legalább 1 hetet, akkor marad az állandó hálózati tápellátás.
A linkelt hozzászólásomban lévő megoldás nem elég biztonságos?
Illetve, én úgy gondoltam, hogy maga a megjelenített weboldal is legyen tárolva az SD kártyán, és a böngészőben az adott dyndns-es url-re magát a weboldal felületét kapom meg, bejelentkezés után. A böngészőben amit látok hőmérsékleti adtok, azoknak 20mp-enként kellene frissülni, mindig az új aktuális mért átlagértékkel, hogy real time legyen. Ha diagramot akarok nézni, akkor meg kiválasztom az időintervallumot, és felrajzolja.
Ez így mennyire hangzik életképesnek?
+ (#1487) stopperos:
Hmm.... ezek szerint, az adatbázis és a számítások miatt, kevés egy arduino.
Kábeles a legbiztosabb, viszont ha kényelmi szempontokat és esztétikumot is nézek (mint otthoni rendszer, szerintem erre is figyelnem kellene), akkor jobb lenne vezeték nélküli. Vagy marad a kábelcsatorna, ami itt nincs. (Persze a vezeték nélküli drágább is, ami ellene szól).
Valamint, egy hőmérő szenzornak mekkora a max. megengedett kábelhossz, ahol még biztosan nem változik a jel "útközben", nem kell erősítés, és nem lesz lényeges késleltetés? -
inf3rno
nagyúr
válasz
s3toraph
#1485
üzenetére
Ha vezeték nélkülit akarsz, akkor mindenképp kalkulálj vele, hogy a wifi sokat fogyaszt. Inkább rádiósan érdemes megcsinálni, vagy csak néha-néha sync-elsz wifin keresztül egy központi adatbázissal. Szerintem a kütyüre csak egy sima event log-ot tegyél, ami kb így néz ki: timestamp, sensor-id, sensor-data. Ezeket bizonyos időközönként elküldöd az adatbázisnak, amiben egy központi event storage-t csinálsz. Oda szépen lemented az eseményeket, meg a szenzor jellemzőket. Tegyél esemény hozzáadásra adatbázist trigger-t, ami projekciókat hív meg. A projekciókkal transzformálod az eseményeket valami szolgáltatás specifikus formába, pl hogy mennyi volt a napi átlaghőmérséklet, vagy hányszor nyitották a hónapban az ajtókat, stb.. Ha új projekciót adsz hozzá, akkor az összes event-en végigmehetsz visszamenőleg, ha úgy gondolod. A lényeg, hogy a nyers szenzor adat benne legyen egy event storage-ben, onnantól meg már kedved szerint alakíthatod, hogy a webszolgáltatás miről mekkora részletességű infot ad.
Több dolgot is csinálhatsz. Ha netről látni szeretnéd az adatokat, akkor dyndns-el csinálhatsz egy otthoni HTTP szervert, amit majd állandóan csesztetni fognak a hackerek. Egy nodejs-nek azt mondják legalább 64MB memória kell, de szerintem apache + PHP is kb ugyanott lennél. SQL adatbázisnál valszeg postgresql-el tudnád megoldani a kevés memóriát. Sqlite is keveset foglal, de azzal nincs tapasztalatom, és amúgy sem igazán szeretem az olyan adatbázist, ami nem daemon-ként fut. Szóval ha webszervert és adatbázist akarsz, akkor legalább 256MB memória kell, és legalább 1.2GHz-es processzor, és ez tényleg valahol az alja lehet. Én most próbálok majd kihozni két 128MB, 0.8GHz-es gépből egy adatbázist és egy webszervert, de nem vagyok benne biztos, hogy az adatbázis részét meg tudom oldani ennyiből. Valszeg az is inkább csak event log lesz.
A másik lehetőség, hogy veszel egy domaint meg egy hosting-ot, aztán annak az adatbázisában csinálod meg az event storage-edet, amibe bizonyos időközönként az itthoni kütyüről feltöltöd az adatokat. Ez egy sima HTTP POST-al mehet, a lényeg, hogy jelszavas legyen. Ha lehet, akkor érdemes TLS titkosítani is és legalább valami ingyenes gagyi certificatet beállítani, különben bárki képes lesz feltolni adatot, ha olyan kedve van. Ha ez nem számít, akkor mindegy. Elvileg lehetséges beállítani úgy is, hogy csak bizonyos helyről fogadjon titkosított adatot a szerver, de ebbe nem folytam bele. Van olyan lehetőség is, hogy digitálisan aláírod az adatcsomagjaidat, aztán FTP-vel felteszed a szerver egy mappájába, ami webről nem hozzáférhető. Ha stimmel a digitális aláírás, akkor feldolgozod a fájlt, ha meg nem, akkor eldobod. Így még ha megszerzik az FTP jelszót, akkor sem tudnak mit csinálni, mert a szerver automatikusan törli a feltöltött fájljaikat.
Nagyjából ennyi, ha a kütyü lesz a webszerver meg az adatbázis is, akkor szerintem valami komolyabb rpi, ha meg csak adatot gyűjt, és sync-el a szerverrel, akkor meg arduino is elég lehet. Nekem legalábbis ez jött le, de nincs sok tapasztalatom ezekkel a kütyükket. Megtanulni szerintem egyiket sem lehet bonyolult. A költséghatékonyságot meg csak te tudod kiszámolni a fogyasztásból és az esetleges domain és szerver bérlésből.
-
s3toraph
senior tag
Sziasztok!
Építenék egy kis otthoni monitorozó rendszert, ehhez kérnék tanácsot. Kezdő vagyok a témában.
A terv az, hogy egy lakásban a helyiségek hőmérsékletét figyelem hőszenzorokkal. Ezen adatokat kellene real time megjeleníteni PC-n. Majd ezután továbbfejlesztve, adatbázisban eltárolni a begyűjtött adatokat (mindezt azért, hogy egy weboldalra feltöltve, neten is meg lehessen nézni bármikor bárhonnan, hol mennyi a hőmérséklet, ill. visszamenőleg grafikonon mondjuk egy hét távlatra, szobánként). Szobánként 1 vagy több hőmérő. Ezt mondjuk egy router és VPN segítségével megoldani.
Aztán még lehet hogy bővíteném, mondjuk páratartalom méréssel, ajtónyitás érzékelővel.
Fűtésszabályozás, bojlervezérlés, stb. nem lesz.Első körben kábelesen csatlakoznának az érzékelők. Ha ez működik, utána továbbfejleszteni vezeték nélküli megoldással, wi-fi vagy bluetooth.
Nem tudom, melyik vonalon induljak el, raspberry vagy arduino?
Melyiket könnyebb kezelni, megtanulni?
(MSP430G2-vel próbálkoztam de az nekem túl bonyolult.)
Úgy látom mindkettőhöz van elég sok magyar forrás (angolom még nem elég jó).Érdemes megvenni egy komolyabb boardot amin van eleve mondjuk wi-fi modul? Vagy elég egy közepes lap, és később shildek hozzá? Melyik a költséghatékonyabb?
-
#1478
lajbi30
csendes tag
nemethbuda
#1477
lajbi30
csendes tag
válasz
nemethbuda
#1477
üzenetére
Hali mindenki!
Megtudná nekem mondani valaki,hogy miért van az,hogy PC USB-rő tökéletesen működik az arduino,de kűlső tápról csak kínlódik. USB 5 volt-ról szépen felkapcsólnak a relék (4db),de külső tápról 2.relé után már csak búgnak és nem tudnak felkapcsólni. Lehet akár 12 volt is.
-
Gergosz2
veterán
válasz
lajbi30
#1468
üzenetére
De most kapcsolgat?
case 8:
set_relay(1, 0);
break;Ezt. 8 ugye azt jelenti, hogy 8 órakor az 1-es relét bekapcsolja. A set_relay(1, 0); úgy lett megírva, hogy az összes előtte lévő relét felnyomja. Szóval, set_relay(4, 0); esetén az első 4-et felnyomja, a set_relay(4, 1); pedig lenyomja.
Ha mind a nyolcat akaor kapcsolni akkor még adsz hozzá több case-t és megfelelően paraméterezed a set_relay() függvényt.
Azért ilyenre írtam, mert azt írtad, sorban akarod kapcsolgatni őket.
-
-
lajbi30
csendes tag
válasz
Gergosz2
#1461
üzenetére
Nagyok nagyok vagytok! Alakul! Tök izgulok
Beállítani nem tudom a pontos időt. Valamiért elfogadta a DS3231 library-t.
A kód is fel ment hiba nélkül, de a relék nem kapcsolnak.#include <DS3231.h>
#include <Wire.h>DS3231 Clock;
bool Century=false;
bool h12;
bool PM;
byte ADay, AHour, AMinute, ASecond, ABits;
bool ADy, A12h, Apm;
byte year, month, date, DoW, hour, minute, second;//EZEKET ÍRD ÁT, NEM TUDOM, HOGY HOVA VANNAK KÖTVE A RELÉK, MEG MI LEGYEN A NEVE!
int relPin1 = 6;
int relPin2 = 7;
int relPin3 = 8;
int relPin4 = 9;void setup()
{
Wire.begin();
pinMode(relPin1, OUTPUT);
pinMode(relPin2, OUTPUT);
pinMode(relPin3, OUTPUT);
pinMode(relPin4, OUTPUT);
}void loop()
{
int hour;
hour=Clock.getHour(h12, PM);if (hour >= 00 && hour < 23)
{
digitalWrite(relPin1, HIGH); // 1-es relé 8 és 16 óra között kapcsol be
}
else
{
digitalWrite(relPin1, LOW); // 16 és 8 óra között ki van kapcsolva
}if (hour >= 0 && hour <23)
{
digitalWrite(relPin2, HIGH);
}
else
{
digitalWrite(relPin2, LOW);
}if (hour >= 0 && hour < 23)
{
digitalWrite(relPin3, HIGH);
}
else
{
digitalWrite(relPin3, LOW);
}if (hour >= 0 && hour < 23)
{
digitalWrite(relPin4, HIGH);
}
else
{
digitalWrite(relPin4, LOW);
}}
-
lajbi30
csendes tag
válasz
Gergosz2
#1458
üzenetére
Arduino: 1.6.5 (Windows 7), Board: "Arduino Uno"
In file included from sketch_aug20b.ino:1:0:
D:\Games\arduino-1.6.5-r2\libraries\DS1307/DS1307.h:10:24: fatal error: WConstants.h: No such file or directory
#include <WConstants.h>
^
compilation terminated.
Hiba a fordítás során.This report would have more information with
"Show verbose output during compilation"
enabled in File > Preferences. -
dave0825
őstag
válasz
lajbi30
#1456
üzenetére
Na, akkor szerintem a legegyszerűbb, ha így indulsz el:
Töltsd le ezt a library-t, és másold be oda, ahova az Arduino-t telepítetted (alapesetben C:\Program Files (x86)\Arduino\), ott a libraries mappába, kicsomagolva mappástól, tehát a DS3231_TEST mappát. Ezután indítsd újra az Arduino programot (vagyis zárd be, és nyisd meg újra), és a Fájl-->Minták között megtalálod a DS3231_TEST programot, állítsd be a setup()-on belül a mostani időt, majd töltsd rá a programot (számolj rá egy 10-15mp-et a mostani időre, míg rátölti, és azt állítsd be).
Ezután nyiss egy új sketch-et, és ezt írd bele (természetesen a relék nevét te írd át, az gondolom menni fog, nem tudom, hogy mire szeretnéd, vagy hogy csináltad). Szerintem így jónak kell lennie, de azért más is nézze át, nem akarom tönkretenni semmidet.
Úgy csináltam, hogy 8 és 16 óra között (8-kor már be, egészen 15:59:59-ig) kapcsol be az 1-es relé (relPin1)majd 16 és 8 óra között pedig kikapcsolva van, a 2-es relé 9 és 17 között be, 17 és 9 között ki, és így tovább 4 reléig (ha működik így, akkor kiegészítve a többi reléddel már neked is menni fog ez alapján).
Amúgy azért írtam, hogy szerintem összekeveredtél, mert most azt írtad, hogy az 1-es 8-kor be, 21-kor le, 2-es 9-kor be és 20-kor le...Korábban meg azt, hogy az 1-es 8-kor be, 16-kor le, 2-es 9-kor be, 17-kor pedig le...Tehát így 8 órával eltolva. Most legutóbb meg valahogy vagy elírtad, vagy már máshogy szeretnéd...(#1458) Gergosz2: nekem ds3231-em van, viszont ds1207-es library-val is ment nekem (ha jól emlékszem, vagy neten láttam valakinél, hogy nem azt használt hozzá, ami a library-ban volt), ezért gondoltam
-
dave0825
őstag
válasz
Gergosz2
#1453
üzenetére
Szerintem de, csak már összekeveredett.
(#1448) zka67: nem, dehogyis, ezt csak lajbi30-nak mutattam, hogy beállítja így, és utána, amikor rátölti a kész programot, akkor már ezt nem kell beleírnia.
Én beállítottam, és a hosszú, kész programomban természetesen kikommenteltem, hogy ne állítsa be minden indításnál. Azért ez az idő van amúgy bent, mert utoljára talán akkor állítottam be. -
-
dave0825
őstag
válasz
lajbi30
#1445
üzenetére
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()
{
} -
lajbi30
csendes tag
válasz
Gergosz2
#1444
üzenetére
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);
} -
lajbi30
csendes tag
válasz
gyapo11
#1438
üzenetére
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 csatornavoid 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);
}}
-
gyapo11
őstag
válasz
Pubszon
#1436
üzenetére
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. -
Pubszon
veterán
Ü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? -
Gergosz2
veterán
válasz
gyapo11
#1432
üzenetére
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]
-
gyapo11
őstag
válasz
Gergosz2
#1429
üzenetére
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.
-
lajbi30
csendes tag
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 )***********
-
dave0825
őstag
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. -
#1426
gyapo11
őstag
DougButabi
#1425
gyapo11
őstag
válasz
DougButabi
#1425
üzenetére
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.
-
#1425
DougButabi
tag
gyapo11
#1424
DougButabi
tag
válasz
gyapo11
#1424
üzenetére
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.
-
gyapo11
őstag
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. -
gyapo11
őstag
válasz
stopperos
#1420
üzenetére
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). -
tvamos
nagyúr
válasz
gyapo11
#1413
üzenetére
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.
-
stopperos
senior tag
válasz
gyapo11
#1410
üzenetére
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.
-
gyapo11
őstag
válasz
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. 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. -
softguner
csendes tag
válasz
gyapo11
#1416
üzenetére
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.
-
gyapo11
őstag
válasz
softguner
#1414
üzenetére
É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.
-
-
softguner
csendes tag
válasz
gyapo11
#1413
üzenetére
É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
-
gyapo11
őstag
válasz
softguner
#1412
üzenetére
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. -
softguner
csendes tag
válasz
gyapo11
#1409
üzenetére
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.
-
#1408
Danex
addikt
DougButabi
#1407
Danex
addikt
válasz
DougButabi
#1407
üzenetére
É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á.
-
#1407
DougButabi
tag
gyapo11
#1404
DougButabi
tag
válasz
gyapo11
#1404
üzenetére
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. -
#1404
gyapo11
őstag
DougButabi
#1402
gyapo11
őstag
válasz
DougButabi
#1402
üzenetére
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. -
gyapo11
őstag
-
#1402
DougButabi
tag
gyapo11
#1399
DougButabi
tag
válasz
gyapo11
#1399
üzenetére
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.
-
Danex
addikt
válasz
gyapo11
#1399
üzenetére
Ú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.
. Valakinek van ötlete?
windows 10 van most feltelepítve, ez gondot okozhat?
{
O_TEMPERATURE) {
), 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.
Új hozzászólás Aktív témák
Hirdetés
ekkold
- HP Elitebook 840 G3 laptop (15,6FHD/I5-G8/8GB/256SSD/Magyar/Win11)
- AMD Ryzen 5 5500 - GTX 1080Ti 11Gb - MSI B450 Max
- HP Zbook 15 G3 laptop (15,6FHD/I7-G6/16GB/256SSD/AMD2GB/MagyarVilágítós/Win11)
- Apple iPhone 13 128GB, Kártyafüggetlen, 1 Év Garanciával
- Apple iPhone 13 Pro 128GB, Kártyafüggetlen, 1 Év Garanciával
- Samsung Galaxy S23 Plus 256 GB Kártyafüggetlen 1Év Garanciával
- ÁRGARANCIA!Épített KomPhone i5 14600KF 32/64GB DDR5 RAM RTX 5070Ti 16GB GAMER PC termékbeszámítással
- Használt Intel procik - Core 2 - Dual Core
- SAMSUNG DDR4 REG ECC 32GB 2666MHz RDIMM szerver RAM modulok, nettó 15740Ft+ÁFA, 1 év gar., több db
- Telefon felváráslás!! iPhone 15/iPhone 15 Plus/iPhone 15 Pro/iPhone 15 Pro Max
Állásajánlatok
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest
Cég: CAMERA-PRO Hungary Kft
Város: Budapest