- Hat év támogatást csomagolt fém házba a OnePlus Nord 4
- Google Pixel topik
- Poco X5 Pro - ránézésre jó
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Beárazták az projektoros Ulefone-t
- iPhone topik
- Samsung Galaxy A56 - megbízható középszerűség
- eSIM, a kártyamentes szabadság
- Milyen okostelefont vegyek?
- Apple Watch Sport - ez is csak egy okosóra
-
Mobilarena
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
-
Tankblock
aktív tag
Hello
Timert tegyél hozzá. mert így looponként fogsz váltani.
unsigned long timer = 0;
az if feltételét egészítsd ki millis()-timer > X ahol X lehet játszani
az ifben meg timer = millis();
így a változás csak X enként van követve.
Szerk: Annyire nem is volt rossz az ötletem : [link]
-
A javaslatotokra átírtam erre a kódot:
int led = 13;
int button = 4;
boolean buttonOn = false;
void setup() {
pinMode(led, OUTPUT);
pinMode(button, INPUT_PULLUP);
}
void loop() {
if (digitalRead(button) == LOW) {
buttonOn = !buttonOn;
}
if (buttonOn) {
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
}viszont most sem jó. Már nem villog, viszont véletlenszerűen kapcsolódik fel-le gombnyomáskor. Tehát megnyomom vagy felkapcsol vagy nem, 2., 3. alkalomra felkapcsol, majd megnyomom lehet lekapcsol, lehet égve marad. Szóval tök random még mindig
-
fpeter84
senior tag
STLink-em van, azzal programozom. Próbáltam soroson is, de meguntam a macerát hogy ide-oda kell tenni a jumpereket és vettem hozzá programozót.
Azthiszem Janos250 #4191 és a Te hsz-ed rávilágít a problémámra: ha az IDE-ben a programozási módot sorosra tesszük, akkor letiltja a JTAG-ot valamint az USB-t és GPIO módba kerülnek a lábai. Ha viszont az STLink módot választjuk, akkor az összes JTAG-hoz köthető lábat elkapcsolja a GPIO módról (azt is amit egyébként nem használ a programozó), valamint itt találtam rá utalást hogy ekkor az USB-t is inicializálja valamennyire akkor is ha én nem teszem meg a programomban, így azok a lábak is átállítódnak. A futó programból regisztereket kapcsolgatva valószínűleg helyre lehetne tenni - elvileg ahogy nézem, a JTAG szabad lábait egyesével is vissza lehetne állítani, így talán működne az STLink és, meg a GPIO-k is. De végül nem húzhattam már az időt, átdrótoztam a PB5-6-7-re a vezérlést, így működik, tudok haladni.
Mindenesetre jó tanulság, hogy nyákgyártás előtt próbapados szakaszban alaposabban kell tesztelni a konkrét lábakat, és nem cserélgetni utólag a funkciókat
Amikor megjött az STLink, akkor ugyan felraktam a Keil-t mert kíváncsi voltam a realtime belső debugra, de valahogy nem kapott el a gépszíj - már túlzottan hozzászoktam ahhoz hogy megoldom a debugot sorosporton... A jövőben lehet adok még neki esélyt, de egyelőre az Arduino IDE hatalmas támogatottsága nagy előny, és haladnom kell a projektekkel, nem tölthetek időt azzal hogy még a környezettel is ismerkednem kelljen...
Néhánnyal lejjebb volt egy sleepmode-al kapcsolatos kérdésem - esetleg abban van tapasztalatod? Miért van az, hogy az összes példaprogram/library kizárja a loop-ot, a setup végén meghívja az alvást, és trigger esetén mindig újraindul a program. Olyat nem is tud, vagy csak nem találtam még, hogy onnan folytatódik a program ahol fel lett függesztve?
Az eddigieket köszönöm, a jövőben talán segít elkerülni az ilyen fél napos szívásokat
-
#4196
tboy93
nagyúr
FireKeeper
#4195
válasz
FireKeeper
#4195
üzenetére
Na hat igen, itt jon ki hogy elektronikabol nulla vagyok.
Tehat akkor osszefoglalva, a led osszeszed valami zajt, ezert villog?
A pinMode(button, INPUT_PULLUP) parancs, tehat az input_pullup, pontosan mit is csinal a gombommal?
-
#4195
FireKeeper
nagyúr
tboy93
#4194
-
Teasüti
nagyúr
Nincs felhúzó ellenállásod. Próbáld ki ezt:
pinMode(button, INPUT_PULLUP)!
Valamint ugyan elektronikában analfabéta vagyok, de mitől lenne a jelenlegi felállásban HIGH, ha földre húzod a gombbal és alapból nincs felhúzva? Azon kívül, hogy nyitott áramkörnél lebeg a port és néha lehet pont átesik HIGH-ra. Vagyis, ha a lenyomást akarod vizsgálni, akkor az LOW lesz a gombnyomásra. -
Mi a hiba a következő összeállításban? Valamiért gombnyomás nélkül is villog a led
int led = 13;
int button = 4;
boolean buttonOn = false;
void setup() {
pinMode(led, OUTPUT);
pinMode(button, INPUT);
}
void loop() {
if (digitalRead(button) == HIGH) {
buttonOn = !buttonOn;
}
if (buttonOn) {
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
}
-
Bazs87
tag
Sziasztok!
Légminőség mérőt szeretnék építeni. Érdekes módon a készen kapható cuccok olcsóbbak, mint ha csak a szenzort szeretném megvenni. Ez vajon miért lehet?
Stabil CO2 szenzor érdekelne elsősorban, továbbá minden egyéb amit teszteltetek és ajánlotok a témához kapcsolódóan. (pl CO)A CO2 szenzorok témakörében már gugliztam pár kört, de sajnos mindig odáig jutottam, hogy egy min. 15ezres szenzor és mégsem tudja azt a fórumok szerint amire ki van találva.
Tapasztalatok érdekelnének.
Köszi!
Bazs87 -
#4189
tboy93
nagyúr
FireKeeper
#4188
válasz
FireKeeper
#4188
üzenetére
Köszönöm, kipróbálgattam és működik
-
#4188
FireKeeper
nagyúr
tboy93
#4187
FireKeeper
nagyúr
az alsó és felső sávban vízszintesen vannak összekötve a pontok (tehát a sorok), közötte pedig függőlegesen (tehát az oszlopok), de úgy hogy középen ketté van vágva, szóval nem a teljes oszlop van összekötve csak külön az alsó és felső része. középen a rés pont akkora, hogy egy DIP foglalatos IC-t bele tudsz szúrni, amúgy meg a pontok egy raszter távolságra vannak, szóval a legtöbb furatszerelt dolgot egyszerűen bele tudod szúrni.
-
#4187
tboy93
nagyúr
FireKeeper
#4186
válasz
FireKeeper
#4186
üzenetére
Igen
Nem teljesen tiszta a használata. -
zka67
őstag
válasz
fpeter84
#4183
üzenetére
Szia, először is, a JTAG portok letilthatóak, de csak óvatosan vele. Nem ismerem a boardodat, a chipet viszont igen. Ha a boardod az SWDIO/SWCLK pineken programozza a chipet, a letiltás után nem fogod tudni újraírni. Meg lehet oldani, kell hozzá egy ST-LINK V2 programozó, és az STM32 ST-LINK Utility nevű program, amivel a Connect Under Reset módban tudod ekkor programozni a chipet, vagy legalább törölni.
Szóval: az STM32F103C8T6 Refenence Maunal 184. oldalán megtalálod a 9.4.2 AF remap and debug I/O configuration register (AFIO_MAPR) leírását, ezzel tudod letiltani a JTAG pineket.
Kap-e órajelet a GPIOA portod? Ezt a 112. oldalon található 7.3.7 APB2 peripheral clock enable register (RCC_APB2ENR)-ben tudod engedélyezni. Ne felejtsd el, hogy minden perifériának engedélyezni kell az órajelét mielőtt elkezded használni.
Ha bármi kérdésed van, szívesen segítek, elég jól ismerem az ST chipjeit
Viszont én a Keil uVisiont használom, nem az arduinot, ezért nem is tudom, hogy mit csinál pl. egy pinMode, amikor ezer féle beállítása lehet egy pinnek, még output módban is négy különböző.Lehet, hogy open-drain módban vannak a pinek, ezért nem világitanak a ledjed. Le kellene szokni a pin és a GND közé kötött ledekről, és áttérni a pin és a Vdd közé kötésre.
A Keil uVision ARM 32kb kódig ingyenesen használható, ST-LINK V2 adapterrel (~800Ft) nagyon jól lehet futásidőben is debuggolni vele.
-
fpeter84
senior tag
Sziasztok ismét!
Segítsetek rajtam plz, bajban vagyok egy STM32F103C8T6 kínai minimal board-al...
"deszkamodell" formájában jól működött a kapcsolásom - bár akkor még más PB lábakat használtam kimenetnek, és tették is a dolgukat ahogy kell. Aztán terveztem egy saját nyákot alá, ahol célszerű volt az adott lábakat másikakra cserélni, így most a PA11, PA12, PA15-nek kellene vezérelnie egy külső eszközt (ki/bekapcs, reset, int), de meg se mozdulnak, hiába kapcsolom őket OUTPUT-ra és változtatom az értéküket... A végén visszanyúltam a "hello world" LED villogtatásig, hátha valami részegységet incializálik ami lefogja ezeket a lábakat a háttérben, de erről sincsen szó, már ez a kapcsolás sem képes a fenti PA lábakat megmozdítani
#define LED PC13
#define gprs_rst PA11
#define gprs_pwr PA12
#define gprs_int PA15
void setup() {
pinMode(LED, OUTPUT);
pinMode(gprs_rst, OUTPUT);
pinMode(gprs_pwr, OUTPUT);
pinMode(gprs_int, OUTPUT);
}
void loop() {
digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level)
digitalWrite(gprs_rst, HIGH);
digitalWrite(gprs_pwr, HIGH);
digitalWrite(gprs_int, HIGH);
delay(1000); // wait for a second
digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW
digitalWrite(gprs_rst, LOW);
digitalWrite(gprs_pwr, LOW);
digitalWrite(gprs_int, LOW);
delay(1000); // wait for a second
}Próbáltam turkálni a doksiját a procinak, és ami feltűnt, hogy a PA11, PA12-n az USB is, de elvileg a "main function after reset" az a GPIO módjuk lenne. A PA15 pedig a JTAG sor része, és a GPIO csak alternatív funckió. Tovább puhatolóztam, és kiderült hogy a szintén JTAG-hoz társított PB3 és PB4 is döglöttnek mutatja magát, és a legközelebbi 3-as amit szépen kapcsolgat a fenti példaprogram az a PB5, PB6, PB7...
Hiányzik valami lépés amitől GPIO módba váltanak ezek a lábak? A nyák már készen van, nem szívesen kezdenék "léggányolásba" ha szoftverből is helyrebillenthető a dolog...
-
#4181
Aryes
nagyúr
FireKeeper
#4180
válasz
FireKeeper
#4180
üzenetére
Igazából egyre jobban tetszik az ötlet.
De mi a különbség a kettő közt? -
#4180
FireKeeper
nagyúr
Aryes
#4179
FireKeeper
nagyúr
esetleg ugyanez csak 125kHz-en? a protokoll még egyszerűbb. ennél olcsóbban amúgy sem hinném hogy bárhogy megúsznád ezt.
-
Nem rossz, de drágállom. Meg kéne hozzá rfid-s kártya vagy tag. Mondjuk lehetne használni vele a saját (igazi) bankkártyám, az vagány lenne...
De a banki adatokat így se tudnám a kártyán tárolni, pedig az praktikus lenne. (Vagy helyette tároljam eeprom-ban? Az hányszor írható?) -
Szeretnék csinálni egy ehhez hasonló bankkártyaemulátort, Gazdálkodj okosan-hoz.
De nem tudok dönteni, hogy hogy oldjam meg a kártyaolvasót. Először régi telefonkártya + chipkártyaolvasót akartam, de nem találok hozzá semmi segítséget, leírást, meg kéne hardver is hozzá, de ez volna a legjobb, ha meg tudnám csinálni valahogy. Valakinek vmi használható ötlete ehelyett? A leghasználhatóbb ötletem talán a lyukkártya + résopto, de a lyukas kártya nem a legelegánsabb. 
Gondoltam még vmi nyák-os megoldáson (mint egy régi játék-cartridge), de ahhoz meg vmi csatlakozó kéne ami bírja a gyűrődést. Ez utóbbi kettőnél az adattárolást az arduinoval kellene megoldani. -
Teasüti
nagyúr
WOW!
MÁS
Uhm nem emlékszem rá, hogyan is kell két integer-be konvertált idővel számolni?
Mondjuk ki akarom vonni a 915-ből (9 óra 15 perc) a 845-öt. És 30 percet kéne eredményül kapnom.
Tudnom kéne nem csak azt, hogy egy adott időpont elérkezett, hanem azt is, hogy mennyi idő telt el azóta.
Kérhetnék erre tippet?Ok, percekben kell számolni, nem órában és percben. De buta vagyok.
-
szaszyka
senior tag
Az sz. P csak nekem jelzés, az csak egy tört lesz (1023-dht1 mérési eredmény). Nem feltétlenül akarom külön elnevezni. Abszolút járatlan vagyok a programozásban, ez lesz az első, és talán utolsó ilyen projektem. Folyamatábrát még tudok csinálni esetleg, illetve logikailag megvalósítani a programot, hogyan működhetne, de a kódolásról azt sem tudom eszik-e, vagy isszák. De azért igyekszem. Deklarálás alatt a definiálást érted?. Azt hittem a pwm is 0-1023, mint az analóg jel, de akkor 255-ig számolok majd. Köszönöm a tájékoztatást
-
válasz
szaszyka
#4172
üzenetére
Azért arra figyelj, hogy a SZ.P helyett olyan változó nevet használj, amiben nincs pont (pl SZ_P), és persze előtte deklaráld a változókat (nem tudom mennyire vágod a témát). Ja, a pwm kitöltöttség természetesen 1 és 255 közt megadható, szóval a kapott százalékot (1-100) szorozd meg 2.55-tel. -
szaszyka
senior tag
-
zka67
őstag
válasz
Teasüti
#4167
üzenetére
Szia, nem minden esetben:
Ilyesmire gondoltam első lépésben, szerintem ez kisebb kódot generál:
if (menu >= 80) {
if (menu <= 86) {
rtc[86-menu] = 0;
if (++menu > 86) menu = 80;
} else
if (menu <= 94) {
evening[94-menu] = 0;
if (++menu > 94) menu = 90;
} else
if (menu <= 104) {
morning[104-menu] = 0;
if (++menu > 104) menu = 100;
}
// ehelyett
case 81:
rtc[5] = 0;
menu++;
break;
case 82:
rtc[4] = 0;
menu++;
break;
case 83:
rtc[3] = 0;
menu++;
break;
case 84:
rtc[2] = 0;
menu++;
break;
case 85:
rtc[1] = 0;
menu++;
break;
case 86:
rtc[0] = 0;
menu = 80;
break;
case 91:
evening[3] = 0;
menu++;
break;
case 92:
evening[2] = 0;
menu++;
break;
case 93:
evening[1] = 0;
menu++;
break;
case 94:
evening[0] = 0;
menu = 90;
break;
case 101:
morning[3] = 0;
menu++;
break;
case 102:
morning[2] = 0;
menu++;
break;
case 103:
morning[1] = 0;
menu++;
break;
case 104:
morning[0] = 0;
menu = 100;
break; -
szaszyka
senior tag
Közben érdeklődnék én is. Adott a képen egy képlet. A dht1, és dht2 azok mért értékek, a pwm 1 pedig előre definiált. Egy ilyen viszonylag bonyolultabb képletet /számolást le lehet - e programozni arduinora, esetleg milyen paranccsal próbálkozzak, illetve az arduino mega képes ilyen számítási kapacitásra úgy, hogy kétszer lenne a képlet a programban. Nem bonyolult ez már neki? A mérések 2db páramérővel történik, 1db pwm jel meghatározása miatt. A segítséget előre is köszönöm, ha valakinek van tippje, milyen parancsot használjak -
Teasüti
nagyúr
Kivágtam, ami nem létszükséglet (távirányító gombjait 0..9 közt), befejeztem minden mást és hivatalosan is elkészültnek tekinthető a v1.0.
Ezt igencsak ki kellett centiznem. A program kereken 30720 bájtot foglal a rom-ban...
...a rendelkezésre álló 30720 bájtból!!
(#4162) zka67
Nem mondom, hogy ebből mindent értek, viszont volna egy kérdésem.
A switch nem hatékonyabb kód, mint az if?
Nem arra lett kitalálva, hogy 110 db if helyett legyen inkább 110 db switch case? -
-
zka67
őstag
válasz
Teasüti
#4158
üzenetére
Szia, kód feltöltésére ott van pl. a http://data.hu/
A kódodhoz pedig annyit tudok hozzátenni, hogy optimalizálni kell. Nem néztem ugyan teljesen végig, de látszik belőle, hogy ugyan azokat a dolgokat írod le ezerszer, és ezeket ezerszer beleteszi a fordító a programodba.
A helyedben én táblázat alapján kezdenék neki, amit persze nem most fogok kitalálni neked, csak mint egy lehetőséget mondok. Ez a case ... case felejtős. Ahogy azért belenéztem, van morning, rtc stb.. tömböd, amiknek ugyan azokat az elemeit változtatod más más menükben. Ezeket lehetne egy két indexű tömbben tárolni, és nem case-vel, hanem if-fel és a gombok számából számolt indexxel dolgozni, vagy a gombok számát egy tömb alapján konvertálni indexszé, és a végén ha kell, elég egyszer is beletenni pl. a menu++ -t.
-
Ma elklezdtem én is bóhockodni az ardu-val, egyelőre abszolút kezdőként
RGB ledes móka már megvolt, a kérdésem az lenne, hogy ezt a buzzlert hogyan kell bekötni? A neten annyit találtam, hogy az egyik lábát az 5V-ra, másikat testre, harmadikat pwn-re kell kötni, de melyiket melyikre? A gnd az egyértelmű.
-
Teasüti
nagyúr
SD-re? Ennyi erővel be lehetne vetni külső ROM-ot is, na de hogy veszem rá arra az AVR-t, hogy külső tárhelyre töltse fel az IDE a kódot és onnan futtassa a programot?
VAGY megtanulok programozni, ha ez az osztálykezelés ennél hatékonyabban el tudja végezni mindezt.
Na meg mások vígan menüznek Atmel328-as procikon az enyémnél bonyolultabbnak tűnő projektekben, így szerintem én csinálok vmit rosszul. -
Teasüti
nagyúr
Üdv urak!
Nagy a baj.
Elkezdtem menüt faragni 1604-es karakteres lcd-re és hozzá egy utasításkezelő rutint, viszont olyan hatalmas lett (és még nincs 100% kész), hogy máris elfogyott a rom.
Nézegettem kész megoldásokat, viszont az osztálykezelés nekem kínai, így state machine-ben csináltam kézzel az összes lehetséges opciót. Nos ez zsákutca.
Kérhetnék segítséget hogy lehetne az alábbit megoldani kisebb kóddal?
Az osztályokban történő kódolás miben különbözik ettől? Azon kívül, hogy olyan bonyolult, hogy beleszagolni se tudok.
Esetleg egy iszonyú szájbarágós tutorial osztálykezelésre? Igazából még azt sem tudom mire jó ez, csak láttam, hogy ebben írtak menüket mások.Az alsó semmi extra, csak sorszámozott képernyők az LCD-n. A menu változó hivatkozik egy adott oldalra, mely tartalmat jeleníti meg. A felső funkció pedig a távirányító egy adott gombjára* (külső switch) és adott oldalra menüben (belső switch) csinál vmit: lapozás, értékadás, stb.
*pl. távirányító 1-9 számgombjai, vagy a kurzor nyilai a numerikus bill.-en vett helyei alapján 14 - balra, 16 - jobbra, 15 - OK, stb.
void menuHandler(byte button) {
if (inMenu) {
lcd_update = true;
switch (button) {
case 10:
switch (menu) {
case 81:
rtc[5] = 0;
menu++;
break;
case 82:
rtc[4] = 0;
menu++;
break;
case 83:
rtc[3] = 0;
menu++;
break;
case 84:
rtc[2] = 0;
menu++;
break;
case 85:
rtc[1] = 0;
menu++;
break;
case 86:
rtc[0] = 0;
menu = 80;
break;
case 91:
evening[3] = 0;
menu++;
break;
case 92:
evening[2] = 0;
menu++;
break;
case 93:
evening[1] = 0;
menu++;
break;
case 94:
evening[0] = 0;
menu = 90;
break;
case 101:
morning[3] = 0;
menu++;
break;
case 102:
morning[2] = 0;
menu++;
break;
case 103:
morning[1] = 0;
menu++;
break;
case 104:
morning[0] = 0;
menu = 100;
break;
}
break;
case 1:
switch (menu) {
case 81:
rtc[5] = 1;
menu++;
break;
case 82:
rtc[4] = 1;
menu++;
break;
case 83:
rtc[3] = 1;
menu++;
break;
case 84:
rtc[2] = 1;
menu++;
break;
case 85:
rtc[1] = 1;
menu++;
break;
case 86:
rtc[0] = 1;
menu = 80;
break;
case 91:
evening[3] = 0;
menu++;
break;
case 92:
evening[2] = 0;
menu++;
break;
case 93:
evening[1] = 0;
menu++;
break;
case 94:
evening[0] = 0;
menu = 90;
break;
case 101:
morning[3] = 0;
menu++;
break;
case 102:
morning[2] = 0;
menu++;
break;
case 103:
morning[1] = 0;
menu++;
break;
case 104:
morning[0] = 0;
menu = 100;
break;
}
break;
case 2:
switch (menu) {
case 81:
rtc[5] = 2;
if (rtc[4] > 3) rtc[4] = 3;
menu++;
break;
case 82:
rtc[4] = 2;
menu++;
break;
case 83:
rtc[3] = 2;
menu++;
break;
case 84:
rtc[2] = 2;
menu++;
break;
case 85:
rtc[1] = 2;
menu++;
break;
case 86:
rtc[0] = 2;
menu = 80;
break;
case 91:
evening[3] = 0;
menu++;
break;
case 92:
evening[2] = 0;
menu++;
break;
case 93:
evening[1] = 0;
menu++;
break;
case 94:
evening[0] = 0;
menu = 90;
break;
case 101:
morning[3] = 0;
menu++;
break;
case 102:
morning[2] = 0;
menu++;
break;
case 103:
morning[1] = 0;
menu++;
break;
case 104:
morning[0] = 0;
menu = 100;
break;
}
break;
case 3:
switch (menu) {
case 82:
rtc[4] = 3;
menu++;
break;
case 83:
rtc[3] = 3;
menu++;
break;
case 84:
rtc[2] = 3;
menu++;
break;
case 85:
rtc[1] = 3;
menu++;
break;
case 86:
rtc[0] = 3;
menu = 80;
break;
case 91:
evening[3] = 0;
menu++;
break;
case 92:
evening[2] = 0;
menu++;
break;
case 93:
evening[1] = 0;
menu++;
break;
case 94:
evening[0] = 0;
menu = 90;
break;
case 101:
morning[3] = 0;
menu++;
break;
case 102:
morning[2] = 0;
menu++;
break;
case 103:
morning[1] = 0;
menu++;
break;
case 104:
morning[0] = 0;
menu = 100;
break;
}
break;
case 4:
switch (menu) {
case 82:
if (rtc[5] < 2) rtc[4] = 4;
menu++;
break;
case 83:
rtc[3] = 4;
menu++;
break;
case 84:
rtc[2] = 4;
menu++;
break;
case 85:
rtc[1] = 4;
menu++;
break;
case 86:
rtc[0] = 4;
menu = 80;
break;
}
break;
case 5:
switch (menu) {
case 82:
if (rtc[5] < 2) rtc[4] = 5;
menu++;
break;
case 83:
rtc[3] = 5;
menu++;
break;
case 84:
rtc[2] = 5;
menu++;
break;
case 85:
rtc[1] = 5;
menu++;
break;
case 86:
rtc[0] = 5;
menu = 80;
break;
}
break;
case 6:
switch (menu) {
case 82:
if (rtc[5] < 2) rtc[4] = 6;
menu++;
break;
case 84:
rtc[2] = 6;
menu++;
break;
case 86:
rtc[0] = 6;
menu = 80;
break;
}
break;
case 7:
switch (menu) {
case 82:
if (rtc[5] < 2) rtc[4] = 7;
menu++;
break;
case 84:
rtc[2] = 7;
menu++;
break;
case 86:
rtc[0] = 7;
menu = 80;
break;
}
break;
case 8:
switch (menu) {
case 82:
if (rtc[5] < 2) rtc[4] = 8;
menu++;
break;
case 84:
rtc[2] = 8;
menu++;
break;
case 86:
rtc[0] = 8;
menu = 80;
break;
}
break;
case 9:
switch (menu) {
case 82:
if (rtc[5] < 2) rtc[4] = 9;
menu++;
break;
case 84:
rtc[2] = 9;
menu++;
break;
case 86:
rtc[0] = 9;
menu = 80;
break;
}
break;
case 15:
switch (menu) {
case 51:
menu = 52;
break;
case 52:
L1switch = analogRead(A1);
break;
case 53:
menu = 54;
break;
case 54:
L2switch = analogRead(A2);
break;
case 56:
L1max = 0;
L1min = 1023;
L2max = 0;
L2min = 1023;
EEPROM.put(0, L1max);
EEPROM.put(2, L1min);
EEPROM.put(10, L2max);
EEPROM.put(12, L2min);
menu = 57;
break;
default:
goto select;
break;
}
break;
case 14:
if (menu >= 20 && menu < 30) menu = 11;
else if (menu < 20) {
menu = 1;
inMenu = false;
}
if (menu >= 40 && menu < 50) menu = 12;
if (menu == 60 || menu == 61) menu = 13;
if (menu >= 70 && menu < 80) menu = 14;
if (menu > 80 && menu <= 86) {
menu--;
break;
}
if (menu > 90 && menu <= 94) {
menu--;
break;
}
switch (menu) {
case 30:
menu = 20;
EEPROM.put(4, Bmax);
break;
case 31:
menu = 21;
EEPROM.put(5, Bmin);
break;
case 32:
menu = 22;
EEPROM.put(6, standby_light);
break;
case 33:
menu = 23;
EEPROM.put(7, default_timeout);
break;
case 34:
menu = 24;
EEPROM.put(8, white);
break;
case 35:
menu = 25;
EEPROM.put(9, gamma_correction);
break;
case 50:
menu = 40;
break;
case 51:
menu = 41;
break;
case 52:
menu = 41;
EEPROM.put(14, L1switch);
break;
case 53:
menu = 42;
break;
case 54:
menu = 42;
EEPROM.put(16, L2switch);
break;
case 55:
menu = 43;
break;
case 56:
menu = 44;
break;
case 57:
menu = 44;
break;
case 64:
menu = 60;
EEPROM.put(18, lcd_light);
break;
case 63:
menu = 61;
EEPROM.put(19, lcd_maxBrightness);
break;
case 80:
setRTC();
menu = 70;
break;
case 90:
EEPROM.put(20, evening);
menu = 71;
break;
case 100:
EEPROM.put(24, morning);
menu = 72;
break;
}
break;
case 16:
select:
if (menu >= 80 && menu < 86) menu++;
if (menu >= 90 && menu < 94) menu++;
if (menu >= 100 && menu < 104) menu++;
switch (menu) {
case 9:
menu = 10;
break;
case 10:
menu = 11;
break;
case 11:
menu = 20;
break;
case 12:
menu = 40;
break;
case 13:
menu = 60;
break;
case 14:
menu = 70;
break;
case 20:
menu = 30;
break;
case 21:
menu = 31;
break;
case 22:
menu = 32;
break;
case 23:
menu = 33;
break;
case 24:
menu = 34;
break;
case 25:
menu = 35;
break;
case 40:
menu = 50;
break;
case 41:
menu = 51;
break;
case 42:
menu = 53;
break;
case 43:
menu = 55;
break;
case 44:
menu = 56;
break;
case 51:
menu = 52;
break;
case 53:
menu = 54;
break;
case 60:
menu = 64;
break;
case 61:
menu = 63;
break;
case 70:
menu = 80;
break;
case 71:
menu = 90;
break;
case 72:
menu = 100;
break;
}
break;
case 18:
if (menu > 10 && menu < 20) menu--;
if (menu >= 20 && menu <= 25) menu--;
if (menu >= 40 && menu <= 44) menu--;
if (menu == 30 && Bmax < 254) {
Bmax += 1;
if (Bmax > maxBrightness) Bmax = maxBrightness;
}
if (menu == 33 && default_timeout < 119) default_timeout++;
if (menu == 52 && L1switch < L1max) L1switch++;
if (menu == 54 && L2switch < L2max) L2switch++;
if (menu == 60 || menu == 61) menu--;
if (menu == 63 && lcd_maxBrightness < 255) lcd_maxBrightness += 5;
if (menu >= 70 && menu <= 72) menu--;
switch (menu) {
case 10:
menu = 14;
break;
case 19:
menu = 25;
break;
case 39:
menu = 44;
break;
case 31:
Bmin += 1;
if (Bmin > Bmax) Bmin = Bmax;
break;
case 32:
standby_light = true;
break;
case 34:
white = true;
break;
case 35:
gamma_correction = true;
break;
case 50:
auto_light = true;
break;
case 55:
auto_dim = true;
break;
case 59:
menu = 61;
break;
case 64:
lcd_light = true;
break;
case 69:
menu = 72;
break;
}
break;
case 12:
if (menu < 15) menu++;
if (menu >= 20 && menu <= 25) menu++;
if (menu >= 40 && menu <= 44) menu++;
if (menu == 31 && Bmin > 0) Bmin--;
if (menu == 33 && default_timeout > 10) default_timeout--;
if (menu == 52 && L1switch > L1min) L1switch--;
if (menu == 54 && L2switch > L2min) L2switch--;
if (menu == 60 || menu == 61) menu++;
if (menu == 63 && lcd_maxBrightness > 20) lcd_maxBrightness -= 5;
if (menu >= 70 && menu <= 72) menu++;
switch (menu) {
case 15:
menu = 11;
break;
case 26:
menu = 20;
break;
case 45:
menu = 40;
break;
case 30:
Bmax -= 1;
if (Bmax < Bmin) Bmax = Bmin;
break;
case 32:
standby_light = false;
break;
case 34:
white = false;
break;
case 35:
gamma_correction = false;
break;
case 50:
auto_light = false;
break;
case 55:
auto_dim = false;
break;
case 62:
menu = 60;
break;
case 64:
lcd_light = false;
break;
case 73:
menu = 70;
break;
}
break;
}
Serial.print(F("Menu: "));
Serial.println(menu);
}
}
void lcd_menu(uint16_t page) {
byte temp;
if (menu <= 80 || menu == 90 || menu == 100) {
lcd.clear();
lcd.setCursor(0, 0);
}
switch (page) {
case 0: //welcome
lcd.print(F("Stairlights v1.0"));
lcd.setCursor(0, 1);
lcd.print(F("by Istvan Kocsis"));
break;
case 1:
if (mode == 0) lcd.print(F("Standby..."));
else if (mode == 255) lcd.print(F("Adjusting..."));
else lcd.print(F("Active..."));
lcd.setCursor(0, 1);
lcd.print(F("Press OK to menu"));
break;
case 2:
if (mode == 0) lcd.print(F("Standby..."));
else if (mode == 255) lcd.print(F("Adjusting..."));
else lcd.print(F("Active..."));
lcd.setCursor(0, 1);
lcd.print(F("Press any to set"));
break;
case 3:
if (mode == 0) lcd.print(F("Standby..."));
else if (mode == 255) lcd.print(F("Adjusting..."));
else lcd.print(F("Active..."));
lcd.setCursor(0, 1);
lcd.print(F("FPS:"));
if (fps > 9) lcd.setCursor(5, 1);
else lcd.setCursor(6, 1);
lcd.print(fps);
lcd.setCursor(8, 1);
lcd.print(F("CPS:"));
lcd.print(cps);
break;
case 4:
readRTC();
lcd.print(F("Time:"));
lcd.setCursor(8, 0);
lcd.print(rtc[5]);
lcd.print(rtc[4]);
lcd.print(F(":"));
lcd.print(rtc[3]);
lcd.print(rtc[2]);
lcd.print(F(":"));
lcd.print(rtc[1]);
lcd.print(rtc[0]);
lcd.setCursor(0, 1);
lcd.print(F("FPS:"));
if (fps > 9) lcd.setCursor(5, 1);
else lcd.setCursor(6, 1);
lcd.print(fps);
lcd.setCursor(8, 1);
lcd.print(F("CPS:"));
lcd.print(cps);
break;
case 9: //inMenu
lcd.write(byte(2));
lcd.setCursor(2, 0);
lcd.print(F("to scroll"));
lcd.setCursor(0, 1);
lcd.write(byte(0));
lcd.setCursor(1, 1);
lcd.print(F(" to go back"));
break;
case 10: //inMenu
lcd.write(byte(1));
lcd.setCursor(2, 0);
lcd.print(F("or OK"));
lcd.setCursor(0, 1);
lcd.print(F("to select"));
break;
case 11: //LED settings
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("settings"));
break;
case 12: //Sensor settings
lcd.write(byte(3));
lcd.setCursor(2, 0);
lcd.print(F("Ambient light"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.print(F("sensor settings"));
break;
case 13: //LCD settings
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Display"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("settings"));
break;
case 14: //time settings
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Date/Time"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("setting"));
break;
case 20: //LED submenu
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED max"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("brightness"));
break;
case 21: //LED submenu
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED min"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("brightness"));
break;
case 22: //LED submenu
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED standby"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("running light"));
break;
case 23: //LED submenu
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("timeout"));
break;
case 24: //LED submenu
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED color"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("set"));
break;
case 25: //LED gamma
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LED gamma"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("correction"));
break;
case 30: //LED max brightness
lcd.print(F("Max brightness:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
lcd.print(Bmax);
break;
case 31: //LED min brightness
lcd.print(F("Min brightness:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
lcd.print(Bmin);
break;
case 32: //LED standby
lcd.print(F("Standby light:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
if (standby_light) lcd.print(F("ON"));
else lcd.print(F("OFF"));
break;
case 33: //LED timeout
lcd.print(F("LED timeout:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
lcd.print(default_timeout);
lcd.print(F(" sec"));
break;
case 34: //LED color
lcd.print(F("Default mode:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
if (white) lcd.print(F("White"));
else lcd.print(F("Color"));
break;
case 35: //LED gamma
lcd.print(F("Correction:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
if (gamma_correction) lcd.print(F("ON"));
else lcd.print(F("OFF"));
break;
case 40: //Sensor auto light
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Ambient light"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("activating"));
break;
case 41: //Sensor adjust
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Primary light"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("sensor"));
break;
case 42: //Sensor adjust
lcd.write(byte(3));
lcd.setCursor(1, 0);
lcd.print(F("Secondary light"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("sensor"));
break;
case 43:
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Auto dimming"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("in the dark"));
break;
case 44: //Sensor calibration
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Light sensor"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("recalibration"));
break;
case 50:
lcd.print(F("Only in dark?"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
if (auto_light) lcd.print(F("Auto ON"));
else lcd.print(F("Always ACTIVE"));
break;
case 51:
lcd.print(F("OK: read sensor"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(1, 1);
lcd.print(F(": to adjust"));
break;
case 52:
temp = map(L1switch, L1min, L1max, 0, 100);
lcd.print(F("Sensitivity:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
if (L1switch > 99) lcd.setCursor(2, 1);
else if (L1switch > 9) lcd.setCursor(3, 1);
else lcd.setCursor(4, 1);
lcd.print(L1switch);
if (temp < 10 ) lcd.setCursor(7, 1);
else lcd.setCursor(6, 1);
lcd.print(temp);
lcd.print(F("% of max"));
break;
case 53:
lcd.print(F("OK: read sensor"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(1, 1);
lcd.print(F(": to adjust"));
break;
case 54:
temp = map(L2switch, L2min, L2max, 0, 100);
lcd.print(F("Sensitivity:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
if (L2switch > 99) lcd.setCursor(2, 1);
else if (L2switch > 9) lcd.setCursor(3, 1);
else lcd.setCursor(4, 1);
lcd.print(L2switch);
if (temp < 10 ) lcd.setCursor(7, 1);
else lcd.setCursor(6, 1);
lcd.print(temp);
lcd.print(F("% of max"));
break;
case 55:
lcd.write(byte(2));
lcd.setCursor(2, 0);
lcd.print(F("Auto dimming"));
lcd.setCursor(0, 1);
if (auto_dim) lcd.print(F("ON: dim in dark"));
else lcd.print(F("OFF: full power"));
break;
case 56:
lcd.print(F("OK to reset"));
lcd.setCursor(0, 1);
lcd.print(F("stored values?"));
break;
case 57:
lcd.print(F("Calibration data"));
lcd.setCursor(0, 1);
lcd.print(F("cleared!"));
break;
case 60:
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LCD backlight"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("mode"));
break;
case 61:
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("LCD"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("brightness"));
break;
case 63:
lcd.print(F("Brightness:"));
lcd.setCursor(0, 1);
lcd.write(byte(2));
lcd.setCursor(2, 1);
lcd.print(lcd_maxBrightness);
break;
case 64:
lcd.write(byte(2));
lcd.setCursor(2, 0);
lcd.print(F("Auto dimming"));
lcd.setCursor(0, 1);
if (lcd_light) lcd.print(F("Always ON"));
else lcd.print(F("Auto OFF"));
break;
case 70:
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Set time"));
lcd.setCursor(0, 1);
lcd.write(byte(4));;
break;
case 71:
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Set start of"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("night mode"));
break;
case 72:
lcd.write(byte(3));
lcd.setCursor(3, 0);
lcd.print(F("Set end of"));
lcd.setCursor(0, 1);
lcd.write(byte(4));
lcd.setCursor(3, 1);
lcd.print(F("night mode"));
break;
case 80:
lcd.print(F("Time:"));
lcd.setCursor(8, 0);
lcd.print(rtc[5]);
lcd.print(rtc[4]);
lcd.print(F(":"));
lcd.print(rtc[3]);
lcd.print(rtc[2]);
lcd.print(F(":"));
lcd.print(rtc[1]);
lcd.print(rtc[0]);
lcd.setCursor(0, 1);
lcd.write(byte(0));
lcd.write(byte(1));
break;
case 81:
lcd.setCursor(8, 0);
lcd.print(F("_"));
lcd.print(rtc[4]);
break;
case 82:
lcd.setCursor(8, 0);
lcd.print(rtc[5]);
lcd.print(F("_"));
lcd.print(F(":"));
lcd.print(rtc[3]);
break;
case 83:
lcd.setCursor(9, 0);
lcd.print(rtc[4]);
lcd.print(F(":"));
lcd.print(F("_"));
lcd.print(rtc[2]);
break;
case 84:
lcd.setCursor(11, 0);
lcd.print(rtc[3]);
lcd.print(F("_"));
lcd.print(F(":"));
lcd.print(rtc[1]);
break;
case 85:
lcd.setCursor(12, 0);
lcd.print(rtc[2]);
lcd.print(F(":"));
lcd.print(F("_"));
lcd.print(rtc[0]);
break;
case 86:
lcd.setCursor(14, 0);
lcd.print(rtc[1]);
lcd.print(F("_"));
break;
case 90:
lcd.print(F("Evening starts at"));
lcd.setCursor(0, 1);
lcd.write(byte(0));
lcd.write(byte(1));
lcd.setCursor(7, 1);
lcd.print(evening[3]);
lcd.print(evening[2]);
lcd.print(F(":"));
lcd.print(evening[1]);
lcd.print(evening[0]);
break;
case 91:
lcd.setCursor(7, 1);
lcd.print(F("_"));
lcd.print(evening[2]);
break;
case 92:
lcd.setCursor(7, 1);
lcd.print(evening[3]);
lcd.print(F("_"));
lcd.print(F(":"));
lcd.print(evening[1]);
break;
case 93:
lcd.setCursor(8, 1);
lcd.print(evening[2]);
lcd.print(F(":"));
lcd.print(F("_"));
lcd.print(evening[0]);
break;
case 94:
lcd.setCursor(10, 1);
lcd.print(evening[1]);
lcd.print(F("_"));
break;
case 100:
lcd.print(F("Morning starts at"));
lcd.setCursor(0, 1);
lcd.write(byte(0));
lcd.write(byte(1));
lcd.setCursor(7, 1);
lcd.print(morning[3]);
lcd.print(morning[2]);
lcd.print(F(":"));
lcd.print(morning[1]);
lcd.print(morning[0]);
break;
case 101:
lcd.setCursor(7, 1);
lcd.print(F("_"));
lcd.print(morning[2]);
break;
case 102:
lcd.setCursor(7, 1);
lcd.print(morning[3]);
lcd.print(F("_"));
lcd.print(F(":"));
lcd.print(morning[1]);
break;
case 103:
lcd.setCursor(8, 1);
lcd.print(morning[2]);
lcd.print(F(":"));
lcd.print(F("_"));
lcd.print(morning[0]);
break;
case 104:
lcd.setCursor(10, 1);
lcd.print(morning[1]);
lcd.print(F("_"));
break;
}
} -
robohw
aktív tag
-
Mindegyik draga. En most rendelgettem ossze magamnak a cuccokat, ebayrol maga az ardu uno 750ft volt, utana meg alirol 50-250Ft-ert egyesevel berendeltem mindent ami kell, fele annyibol megusztam kb mint ezek a pakkok
Egyetlen hatranya, hogy 20 kulon csomagot kell várnom -
Janos250
őstag
Persze, profik ne arduinot használjanak.
Viszont az amatőr csak akkor tudja, hogy mint jelent pl. a
htim3.Init.Prescaler = 0;
ha előtte megnézte a manuálban, hogy mi az a prescaler.
Akkor viszont már ez is egyszerű:
*((volatile uint32_t *) (baseaddress + 0x28)) = 0 ;Persze, ha utána újra hasonló programokat kell írni, akkor sokkal könnyebb fejben tartani a Prescaler nevet, mint a 0x28 számot.
Igen, persze a HAL-ban mindennek neve van, nem kell a számokkal tökölni.
De ha az STM32CubeMX-et használjuk, akkor még grafikusan is megszerkeszthetjük. Ha tudjuk, hogy mit!
Mellesleg ez is egy C (C++) programot generál, amit utána bármilyen környezetben használhatunk.
Igaz persze, hogy az arduino elterjedt STM32masterje a Maple könyvtárát használja.
"Nem találok semmi DMA kezelési példát Arduinora"
Nem arduinora, hanem STM32 procira kell keresni. Az minden környezetben használható, mivel C (C++) -
-
tvamos
nagyúr
válasz
Janos250
#4140
üzenetére
Az ST peldaprogramok nagyon jok, meg a HAL is, szerintem iszonyat melo egy ilyen RAM-DMA-PWM jatekot regiszter szinten kezelgetni. Mindig azt erdemes hasznalni, amit a legegyszerub. Azert irtam az IAR-t ide, mert sokkal-sokkal egyszerubb, es gyorsabb volt ez, mintha az Arduino frameworkben molyolok. (Jelen esetben 2 ora alatt meg is volt, a frameworkben nem hiszem, hogy egy het alatt, napi 2-3 oraban elkeszult volna. Nem talalok semmi DMA kezelesi peldat Arduinora.)
Persze, ha az ember napi 8-10-12 oraban csinalja, a munkahelyen, akkor ugye azzal kell dolgozni, ami a munkahelyen standard. (En pl. hw fejleszto vagyok, ide toltak az arcomba az orkedet, ezzel kell csinalni. Persze, a sw itt IAR-ban keszul, ami jelen esetben, mondhatjuk, szerencse...)
-
Janos250
őstag
Én amondó vagyok, hogy a proci spéci dolgainál nem nagyon látom értelmét a környezet saját dolgait kihasználni, mert:
Először kikeresi az ember a manuálból, hogy melyik regiszterbe mit kell betölteni. Utána két lehetőség van:
1. Egyszerűen az adott cím(ek)re kiírjuk az adott érték(ek)et, és örülünk ha működik.
2. Megkeressük, hogy az adott környezetben mit minek neveznek, és az adott nevekkel, módszerrel állítjuk be a regisztereket.Ha valaki ezt foglalkozásszerűen napi 8 órában csinálja, természetesen a 2. módszer sokkal kényelmesebb. de ha valaki amatőrként (mint pl. én) csinál ezt-azt, akkor a 2. módszer csak plusz macera az elsőhöz képest. Mindamellett, ha közben átállunk egy másik környezetre, minden kezdődhet elölről.
Segítség ugyan, hogy gyakorlatilag mindenki az STM által közreadott fejlesztő környezet dolgait integrálja a sajátjába, de azért ez mégiscsak macera.
"Nem találtam Arduinora megoldást, úgyhogy IAR-ral nyomom ezt most"
Na, - többek között - ezért választom én inkább a regiszterek közvetlen írását, mert az minden környezetbe változtatás nélkül átvihető. -
tvamos
nagyúr
válasz
Janos250
#4138
üzenetére
Nagyon betyar a DMA-s vezerlese a PWM-nek, azt mar kiprobaltam. (De egyenlore csak 1 PWM csatornan.)
Nem talaltam Arduinora megoldast, ugyhogy IAR-ral nyomom ezt most. Mondjuk, most az orosz ST ajanlott valami ingyenes, limit mentes fejleszto kornyezetet, majd lehet, hogy kiprobalom, ha lesz idom. -
Janos250
őstag
válasz
Teasüti
#4133
üzenetére
"Kettő között mit csinálsz?"
Semmit, várom az idő múlását. A mikrokontrollerek az idejük döntő részében ezt csinálják: várnak
"Vagy itt is van már loop1, loop2, stb?"
Még nem találkoztam vele.
"Viszont azt megnézném hogy hozod össze delay nélkül mikroszekundum szinten a dolgot!"
72 MHz órajelnél 1 microsec az 72 utasításnyi idő. Van regiszter, ami az "órajeleket számolja".
Ezért indításkor letárolom, hogy éppen hol tart, majd figyelem, hogy a pillanatnyi és a letárolt különbsége mennyi. -
Teasüti
nagyúr
válasz
Janos250
#4132
üzenetére
Aha, kezd összeállni a dolog.
Viszont azt megnézném hogy hozod össze delay nélkül mikroszekundum szinten a dolgot!
Mondjuk 1. bit elindít, majd van x uS-od a következő bitig. Kettő között mit csinálsz? A loop() biztos nem lép tovább, amíg be nem fejeződött a frissítés...
Mert ha bejön egy megszakítás, akkor oké az lemegy, de amúgy meg csak malmozol amíg végzel a szalaggal.
Vagy itt is van már loop1, loop2, stb? Kérdéses mi hasznosat lehet csinálni ezekben a hangyaf.sznyi időszeletekben. Komolyabb számításba tuti nem lehet belekezdeni. -
Janos250
őstag
válasz
Teasüti
#4131
üzenetére
"Ennél viszont ezt hogy lehet kivitelezni delay nélkül?"
A delayt ugyebár mellőzni szoktuk, helyette valami hasonlót alkalmazunk:
https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
Pontosság növelése érdekében a proci órajelét számláló regiszter tartalmát figyeljük a millis() helyett.
Itt annyi a könnyebbség, hogy a magas szint hosszát nem kell figyelni, mert azt a hardver elintézi, csak a ciklus végét kell nézni.
Ebben jóval nagyobb a tolerancia, mint a magas szint hosszában.
Persze lehet halmozni az élvezeteket, és az előre összeállított adatok kivitelét interruptal megoldani: amikor vége a ciklusnak, interrupt, és egy újabb bit.
Vagy a magas szint lejártára interrupt, mert akkor már "feltölthető a következő bit", és akkor mehet folyamatosan a PWM, nem kell bitenként újra indítani.
Lehetőségek tárháza bőséges, csak a fantázia szab határt.
"De akkor ez az idő nem lenne ugyanúgy elég bitbang esetében is (nem tudom melyik művelet gyorsabb)?"
De, csak akkor a magas szint idejét is figyelni kell, ami sokkal precízebb időzítést igényel, mint a két egymást követő bit időzítése. De megoldható, persze. Vagy akár ezt is interrupttal intézed. -
Teasüti
nagyúr
válasz
Janos250
#4130
üzenetére
Egy adott bit küldésének a megkezdése és következő közötti idő elég ahhoz, hogy a megszakítások lekezelésre kerüljenek.
Tehát ha jól látom a dolgot, akkor ez annyival nyújt többet a bitbang-nél, hogy a proci addig malmozik és lekezeli az ISR-t, amíg két bit között eltelik némi idő.
Na várjunk, a programban ez hogy működik? Bitbang-nél ugye delay-ek vannak a LOW és HIGH értékek között és ugye ki van lőve a megszakítás az időzítés miatt.
Ennél viszont ezt hogy lehet kivitelezni delay nélkül? Gondolom a loop() nem fogja átugrani az első bit után az adatküldést a következő részre a programban, szóval mit fog csinálni két bit között? Ugyanúgy delay-ezik, nem? Csak az egyik port húzogatása helyett a pwm vezérlőt buzerálja (ami amúgy időben gyorsabb volna, mint egy portot felhúzni HIGH-ra?), de a köztes időben épp úgy malmozik, mint a bitbang-nél?
Egyelőre csak annyit értek ebből, hogy nem kell kikapcsolni a megszakításokat, mert izomból megoldja a köztes időben az ISR-t. De akkor ez az idő nem lenne ugyanúgy elég bitbang esetében is (nem tudom melyik művelet gyorsabb)? -
Janos250
őstag
válasz
Teasüti
#4129
üzenetére
"És két bit között folyamatosan változtatja a paraméterezést a szoftver? Ez nagyon perverz módszernek hangzik, még ha lehetséges is."
Némileg az.
"Az MCU pwm vezérlőjének basztatásához nem kell a processzor?"
De, kell. A bit küldés indításhoz. Egy adott bit küldésének a megkezdése és következő közötti idő elég ahhoz, hogy a megszakítások lekezelésre kerüljenek.
A 72 MHz olyan, mint a 640 kByte: "mindenre elég"
"hogy lesz ebből "multitasking"? "
Igazi multitasking ebből sehogy. Még olyan se, mint pl az ESP8266-on a loop1, loop2, stb. módszer, ahol minden wait, vagy "wait" átadja a vezérlést a másik loopnak.
"Teszem azt ha bejön egy megszakítás és az ISR végrehajtása közben megszakad az adatküldés, mert nincs idő basztatni a PWM vezérlőt?"
De, van idő. Nem szakad meg, mert a hardver csinálja. Csak az indításhoz kell a proci. Az indítás után min 1.2, max néhány microsec idő van. Olyan megszakítást persze nem bír el, ami néhány microsecnél hosszabb.
"kétszer akkora ROM-ja elég meggyőző."
Így van!
DMA ügyben azok válaszoljanak, akik jobban értenek a témához, mint én. -
Teasüti
nagyúr
válasz
Janos250
#4126
üzenetére
Na várj, még mindig le vagyok maradva ott, hogy WS2812 vezérléséhez nem kell PWM - mivel hogy az a szalagon van intergálva.
A led szalag library-k bitbang-elnek legjobb tudomásom szerint, valamint az se igazán látszik nekem, hogy ehhez az adatküldéshez miképp kapcsolódik a PWM vezérlés az MCU-n.
A kitöltési tényezőt variálja minden egyes bit küldésekor? Tehát ha jól értem, akkor úgy lövi be a frekvenciát és a kitöltési tényezőt, hogy megfeleljen a WS2812 specifikációjában szereplő 1 és 0 kód időzítésének. Vagyis egy adott setup-ban az MCU pwm vezérlője csak 1-eseket küld, másik setup-ban csak 0-kat. És két bit között folyamatosan változtatja a paraméterezést a szoftver? Ez nagyon perverz módszernek hangzik, még ha lehetséges is. Az MCU pwm vezérlőjének basztatásához nem kell a processzor? Vagy hogy lesz ebből "multitasking"? Teszem azt ha bejön egy megszakítás és az ISR végrehajtása közben megszakad az adatküldés, mert nincs idő basztatni a PWM vezérlőt?
Még mindig nem világos ARM-n például hogy lehet UART RX-en adatot fogadni, miközben egy WS2812 ledszalagot frissítünk.szerk: amúgy köszönöm a fenti linkeket, meg is rendelek egy Maple Mini klónt.
Az F103C8T6 és az F103CBT6 van egy lényeges különbség ami említésre érdemes, legalábbis első ránézésre utóbbi kétszer akkora ROM-ja elég meggyőző.
DMA-t használta itt már vki adatfogadásra?![;]](//cdn.rios.hu/dl/s/v1.gif)
Neten vajmi kevés infó van a DMA használatáról.
Pedig mekkora királyság lenne már megszakítás nélkül adatot fogadni! -
Janos250
őstag
válasz
Teasüti
#4122
üzenetére
Még egy kis kiegészítés:
Beállítod a frekit úgy, hogy 1.2 microsec (ha jól emlékszem) legyen a periódusidő, a kitöltöttséget (emelt szint hossza) pedig aszerint, hogy 0 vagy 1 kerül kiküldésre. Kiküldesz 1 bitet, várod az 1.2 microsec lejártát (közben bármi történhet, az se baj, ha néhány microsecre hosszabbodik) és küldöd a következő bitet. -
fpeter84
senior tag
Sziasztok! STM32-n használ valaki sleep módot? Ahány projektet/library-t találok, minddel ugyanaz a bajom: valójában úgytűnik hogy egyik sem altatja, hanem inkább kikapcsolja teljesen a procit és visszatéréskor újraindul a program. Nekem arra lenne szükségem hogy meghívva elaludjon, a WKUP pin felhúzásakor pedig onnan folytassa a program a futását ahol fel lett függesztve. Most valamit én értelmezek nagyon félre, vagy hol lehet a probléma? Valaki használja olyan módon ahogy én leírtam?
-
robohw
aktív tag
válasz
Gergosz2
#4115
üzenetére
"Hogyne lenne! CCS, végtelen leírás controlSUITE-ban stb."
TVamos-nak is címzem:
Nem úgy gondoltam, hogy a TI kihozta a cuccait és ahhoz nincs a világon semmi, hanem úgy, hogy nincs hozzá megfelelő méretű kódbázis. Ha az arduino-ra rákeresel, millió dolgot találsz, projectek garmadáját, sőt, még jelentős redundancia is van. Az STMicro kontrollereihez is van már elég sok minden, de a TI nem büszkélkedhet ilyesmivel olyan nagyon. Az amatőr userek meg - nagyon okosan - olyan eszközt választanak, amihez vannak már cuccok.
Ami köré csoportosulnak a supporterek, más feljesztők is.Az atmel kontrollereihez vannak források, minta, vagy példaprojectek és az ST Micro-hoz is van már sok minden, de a TI cuccaiért nem állnak sorba, sokan még csak nem is hallottak róla, holott a TI meglépte azt, hogy a starter boardját 3-4 USD-ért árulta.
-
Teasüti
nagyúr
válasz
Janos250
#4104
üzenetére
A Cortexen a PWM hardver alapon egyszerűen megy, akár több is. Adott frekivel - ha kell - akár 4 különböző kitöltöttséget is tudsz timerenként.
Hardver alapon, nem kell interrupt. Ez nagyon hasznos, pl. ha valaki WS2812 pixelenként színváltós LED szalagot akar programozni. Elindítja a PWM jelet, és akár van valami interrupt, akár nincs, a PWM jel hossza nem változik.
Erről kérhetnék egy kis magyarázatot?
WS2812-höz úgy tudom nem használunk PWM.et, a szalagnak van saját vezérlője.
A library viszont kikapcsolja a megszakításokat, amíg frissíti a szalagot, hogy semmi ne szóljon bele az időzítésbe.
Így viszont nincs megszakítás és ha ekkor bejön egy jel - mondjuk UART RX porton -, akkor az megy a lecsóba Atmel-en legalábbis.
ARM-en erre van esetleg vmi megoldás?
A WS2812 szalag miatt kérdem elsősorban, mivel erre épülnek a projektjeim.
Köszi! -
-
Gergosz2
veterán
A Texas Instruments hasonló dolgaihoz még nincs, meglehet, nem is igen lesz.
Hogyne lenne! CCS, végtelen leírás controlSUITE-ban stb.
(#4110) tvamos
De TI-nek is van egy Arduino framework szerű progija. Energia-nak hívják és jópár launchpad-et támogat is.
(#4113) Janos250
Farnell-től ~4200 Ft ha személyesen mész érte.
-
Köszönöm srácok a sok segítséget!
Tegnap rájöttem, hogy vannak még kiaknázatlan lehetőségek, amikről nem tudtam, szóval nem is olyan rossz a helyzet, mint gondoltam. Ezt használja a light ir receiver lib, ezért tud mindennel együttműködni, a hagyományos ir lib viszont timer interruptot használ. Átirányítottam az analóg lábakra, azóta stabilan működik.
-
tvamos
nagyúr
A Texas Instruments hasonló dolgaihoz még nincs, meglehet, nem is igen lesz.
Van hozzá szoftver! Csak nincs benne az Arduino frameworkben. Nem ugyan az!(#4107) aryes válasza robohw (#4106) üzenetére
Vedd meg az ebay-en a legolcsóbbat, amit Janos250 ajánlott, az jó lesz!
Amúgy, ha nyanlánkság... abból mindig jön újabb, amit még nem támogat a framework. -
robohw
aktív tag
"Hogy van esélye egy kezdőnek válogatni ekkora hatalmas választékból?"
Van a gyártóknak adattábla, ahol összehasonlíthatod az eszközöket. És az igényeidnek hozzávetőlegesen megfelelőt kiválaszthatod. Tudod, mekkora RAM kell, milyen speed viszi az adott feladatot, stb.
Az ST Micro elég jó cég, olcsók is. Már 2 rugó alatt vannak próba boardjaik.
Azért is érdemes őket választani, mert van a cuccaikhoz már szoftver. A Texas Instruments hasonló dolgaihoz még nincs, meglehet, nem is igen lesz. -
robohw
aktív tag
"És ez pl. mivel tud többet egy uno-nál?"
Hogy mivel? Hajjajjajj...
UNO:
32 kB flash
02 kB RAM
16 Mhz speed.STM32F411:
512 kB flash
128 kB RAM
100-180 Mhz speed.Ezen kívül még ezer és egy dologban. Gyakorlatilag egy pentium osztályú proci teljesítményét hozza. De ekkorára neked nincs szükséged.
Ehhez a feladathoz számodra még egy F103-as is elmenne (64 kB flash, 20 kB RAM (max), 48 Mhz). -
robohw
aktív tag
válasz
Janos250
#4102
üzenetére
Hát igen, való igaz, a hestore néha gyilkolni képes az árképzésével, de azt érdemes megemlíteni, hogy az arm boardok (és más boardok) esetében is, amit a proci köré raknak olykor, az megéri a plusz befektetést.
Én vettem 3900-ért Nucleo Cortex M4-est (stm32F411Ret6) és a board nem csak bivalyerős, de arduino kompatibilis és van rajta hw debugger is, valamint egy kód is járt hozzá amivel hozzáférhetek egy komoly, erre a procira kihegyezett kódbázishoz.
De van olyan board, ami tele van pakolva minden földi jóval, ugyanennyiért, vagy alig valamivel többért.
-
tvamos
nagyúr
Nem cserélgetik a kristályt!
(#4104) Janos250 válasza aryes (#4100) üzenetére
De amit ő irt, az nem ST, hanem Freescale... ja nem, NXP... ja, már Qualcommmmmm...
De amúgy az ST ARM M3 procik voltak az elsők, az új M0+ procik sok paraméterben jobbak. (pl. fogyasztásban tuti.) -
Janos250
őstag
Igen, jelenleg az ARM STM32 vonal (M0, M3, esetleg M4, ..) az olcsó és jó megoldás, ami biztosan nem kárbaveszett munka, mert a magasabb verziójú procikon is mennek (általában) simán az alacsonyabbra írt programok. És nem utolsó szempont, hogy ARM!
A Cortexen a PWM hardver alapon egyszerűen megy, akár több is. Adott frekivel - ha kell - akár 4 különböző kitöltöttséget is tudsz timerenként.
Hardver alapon, nem kell interrupt. Ez nagyon hasznos, pl. ha valaki WS2812 pixelenként színváltós LED szalagot akar programozni. Elindítja a PWM jelet, és akár van valami interrupt, akár nincs, a PWM jel hossza nem változik.
Mindössze azt kell nézni, hogy lejárt-e már a 1.2 microsec, hogy küldhetjük a következőt. Nincs se delay, se interrupt, semmi. Korábban tetszőleges frekijű hardver PWM-re már írtam itt egy mintát.
A hang meg tipikusan I2S, de ezt csak elméletből mondom, mert ezen a proci típusom még nem próbáltam. Érdekes megoldás az I2S-re, amikor a már említett LED programozását is I2S-el oldják meg: a 0-át 1000-ként, az 1-et pedig 1110-ként küldik ki. Hasonló, mint az RLL kódolás a vincsesztereknél.Nézd meg azt a listát, ami Aryes linkelt!
Nem teljesen tiszta a használata.
Gondoltam még vmi nyák-os megoldáson (mint egy régi játék-cartridge), de ahhoz meg vmi csatlakozó kéne ami bírja a gyűrődést. Ez utóbbi kettőnél az adattárolást az arduinoval kellene megoldani.
azt hittem sokkal bonyolultabb, mindenféle parancsok kellenek majd. Köszönöm a segítséget 
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Egyetlen hatranya, hogy 20 kulon csomagot kell várnom 
Új hozzászólás Aktív témák
Hirdetés
ekkold
- BESZÁMÍTÁS! 4TB Samsung 870 EVO SATA SSD meghajtó garanciával hibátlan működéssel
- Lenovo V130-15IGM laptop (Pentium Silver N5000/8GB/256GB SSD
- AKCIÓ! Gigabyte B650M R7 7700X 32GB DDR5 1TB SSD RTX 3080Ti 12GB Cooler Master H500P WHITE 750W
- Bomba ár! Lenovo X1 Yoga 3rd - i5-8GEN I 8GB I 256GB SSD I 14" FHD Touch I W11 I CAM I Garancia!
- Canon imagePrograf PRO-6100S plotter - szinte új, 500m2 nyomat
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: CAMERA-PRO Hungary Kft
Város: Budapest