Betöltőttem a demokból a Hello world-öt, kiegészítettem egy kicsit. Így már látom hogy az UNO működik, a D13-on a LED ki-be kapcsolgat, a kijelző egy-egy villanást csinál (háátérvilágítás), mást nem.
prg:
#include <Wire.h> #include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x20 for a 16 chars and 2 line display
void setup() { pinMode(13,OUTPUT); lcd.init(); // initialize the lcd
// Print a message to the LCD. lcd.backlight(); lcd.print("Hello, world!"); delay(1000); }
Kábelezést ellenőriztem, a tápnak elégnek kell lennie, hiszen csak az LCD van rajta. (Egy másik kiépítésben van rajta SD shield, RTC, DS18B20 hőmérő + 4bites módban az LCD és tökéletesen megy.
Ha a kijelző vezetékelése simán megy, akkor jó eséllyel három helyen lehet galiba:
-- kábelezés (különösen táp, beleértve a terhelhetőséget)
-- i2c címzés
-- i2c kábelezés (sajnos ez sem mindig magától értetődő, az arduino.cc-n is van/volt fent pár ökörség).
Aztán érdemes megnézni, hogy a sketchben valami nem kavar-e be a lábaknál. Ezt ki lehet küszöbölni, ha a library mellé rakott mintákkal teszel egy próbát.
Arduino 1.0.5, UNO panel, I2C LCD panel és egy 1602 LCD
Az LiquidCrystal_I2C -t próbálom beüzemelni. Címét le tudom kérdezni, de e legegyszerűbb kiírás eredménye is csak egy felvillanás a kijelzőn, és méla sötétség.
Ez valamikor működött, de felraktam egy LCD_keypad shield-et és azzal játszottam egy darabig. Most szeretnék visszatérni az I2C-hez, mert a keypad ütközik az SD kártya kezeléssel (D10 PIN). Normál LCD kezelés 4bit-es módban megy, csak sok kemenetet foglal.
Már szereztem egy új LCD-t és egy új I2C LCD vezérlőt, de nem ezekkel van a baj.
A LiquidCrystal_I2C library-t már lecseréltem, de ez sem segített.
Várom az ötleteket, mert 2 napja csak keringek körbe-körbe.
Sziasztok, új fórumozó vagyok. Segítségre lenne szükségem a következőhöz: építettem egy mozgó szimulátor prototípust két motorral. Egy ismerősöm készíti a vezérlést Arduinoval. Sajnos sokszor nem ér rá, így nem haladunk a dologgal, nekem pedig nagyon sürgős lenne. Megcsinálta elméletileg teljesen, minden úgy működik, ahogy kell, de a motorok mozgása nem egyenletes, hanem szakaszos. Szükségem lenne valakire, aki bele tudna nézni, vagy meg tudná oldani sos-ben a problémát. Természetesen kifizetem a munkáját. Ha valakinek szakmai kérdése lenne, megpróbálok rá válaszolni, de laikus vagyok a témában, én csak a gépet találtam ki és szeretném már használni.
Igen, ez az aktuális tipp, de még nem ástam bele magam. Az lesz, hogy aki vállalja, feléleszti, aztán majd megalkuszom vele valami épeszű ellenszolgáltatásban.
Hát, ha a bootloader felment, de mégse megy az egész, akkor lehet ott nagyobb a baj. De nem biztos, hogy a PROGMEM túlszaladása okozta, az maximum a flash tárat írhatja felül. Esetleg a fuse-ok elállítódtak? (Vagy rossz modellt választottál? Én szívtam egy kicsit, amíg rájöttem, hogy az atmega168 és atmega328-nak nem ugyanaz a fuse kiosztása)
Csinálj pár futás-tesztet így is, úgy is, mert nincs kizárva, hogy kb. egy idő a számolás és a progmem kezelése. Arra figyelj, hogy a progmem ne verje ki a memóriát, mert nálam egy kártyán már felülírta a bootloadert, úgyhogy most papírnehezék a kártya.
Nem túl nagy még, majd megnézem. De használnék Progmem-ben tárolt tömböt AD gyorsításhoz, hogy ne kelljen számolgatni annyit. Ahhoz jó lenne ha külön fájlban tudnám letárolni az 1024-es tömböt.
Azért kérdem, mert nekem az eddigi legnagyobb (amiben nincs PROGMEM) 11,8 kB c++, 8,7 kB lefordítva és simán át lehet látni.
Én nem vagdosnám szét, hanem hagynám egyben az egészet és belső hívásokat [void (...) ] csinálnék a különböző feladatokra. Így kevés globális változóval meg lehet oldani a kérdést. Az egyes al-rutinokban meg annyi változót deklarálsz, amennyit akarsz (illetve ami a memóriában elfér). Ráadásul így áttekinthető(bb) is lesz az egész program.
Másfelől. Ez (lehet) az a tipikus eset, amikor egyszerűbb egy új könyvtárat (library) létrehozni. Persze ez programozásilag számottevően bonyolultabb, illetve más feladat.
Több fájlra szeretném szétosztani az ArDuino-s projektemet, hogy jobban olvasható, logikusabban rendezhető legyen. Ha létrehozok egy újabb fájlt az ArDuino IDE-vel, és abban megírom a függvényeket, akkor azokat elérem a főprogramban. Viszont ha ezekben a fájlokban deklarálnék globális változót, azt nem látja a főprogram.
Amelyik projektből kiindultam, ott ez a módszer működött (több fájlra szétbontva, és a logikailak oda tartozó globális változók az adott fájlban voltak deklarálva, és a főprogram is meghívta őket), és az ArDuino.cc-n sem találtam még instrukciót, mit kéne még csinálnom, hogy jó legyen. Extern-ként meg kéne hivatkozni? Az IDE 1.0.5-ös verzióját használom Windows 8-on.
A library-k jelentős részének nem nagyon van részletes leírása. Ami akad, az vagy az arduino.cc fórumában van, vagy a GitHub-on.
A LiquidCrystal könyvtárban a print és a write között annyi a differencia, hogy a write a zárójelbe írt éréték (vagy a zárójelbe írt változó tartalmának megfelelő) ascii kódú karaktert jeleníti meg (csak azt), míg a print-tel gyakorlatilag bármit kiírhatsz ('a' egy karaktert, "asdf" több karaktert ír ki, míg a változó kiírható magában is (direktben), vagy különböző módokon kódolva (dec, hex, oct, bin).
Változó konverzióra sok mód van, de egyik sem egyszerű. Programozási szempontból az az elsődleges, hogy a célnak megfelelő minimálisan szükséges (vagyis a lehető legkevesebb szabad memóriát lekötő) változó legyen az adott célra deklarálva.
Még arra sem igazán jöttem rá, hogy mi a különbség az lcd.print() és az lcd.write() között.
Nem igazán tudom feldolgozni azt, hogy van egy library (mondjuk az RTC-hez), és nem találok hozzá megfelelően alacson szintű leírást (mármint az én szintemnek megfelelőt).
Sajnos csak itt tudok kérdezgetni, ha már elvesztettem a türelmemet.
1. Tudod, hogy a változódba mi jön meg az rtc-ből (pontosabban a hőmérőből). Valószínűleg egy analóg érték, amit egy viszonylag egyszerű osztás/szorzás/összeadás/kivonás műveletsorral szépen decimális celsius értékké lehet konvertálni. Az, hogy ez egész (int) vagy tört (float). Namost. Az a szám, amit a végén megkapsz (float) praktikusan (a 2. pont szerint) szorzandó tízzel (egy tizedes) vagy százzal (két tizedes), aztán kell belőle gyártani egy sima int vagy long változót (ha csak szobahőmérsékletet mérsz, az int bőven elég). Figyelni kell még arra is, hogy signed vagy unsigned változót használsz-e, mert az előbbi elmehet negatívba, a másik viszont nem. A float signed, a lenti példában (mivel órához használtam) ezért van unsigned long, mert nem lehet negatív az érték.
2. El kell döntened, hogy milyen pontossággal akarod megjeleníteni az értéket. Két tizedes jegy szerintem még sok is (a hőmérő pontossága aligha van 1 fokon belül, innentől meg maximum a változást tudod tized fok pontosan figyelni, és még ez sem teljesen megbízható). Lásd még 1. pont.
3. Kód
void vagy(unsigned long v) { // ide egyébként attól függően kellhet a sima long, hogy elmész-e negatív tartományba vagy sem, lásd fent
// a v a fő loopban a hőmérséklet tárolására használt változó, típusát tekintve legyen azonos ezzel (itt unsigned long) byte ones; // sima változó-deklarálás, ez lesz az "egész" byte tens; // sima változó-deklarálás, ez lesz a "tizes" byte fractions; // tized
byte fractionss; // század
// feltételezzük, hogy a hőmérsékletet két tizedes jegyig akarod megjeleníteni, és így a korábbi egész celsius-t osztottad 100-zal (in da loop)
// itt volt egy v=v/10, de az nem kell, felesleges.
fractionss = v%10; // a század értékét meghatározzuk.
// a v%10 jelentése: oszd el v-t 10-zel, és nézd meg a maradékát. Technikai értelemben ez annyit jelent, hogy "levágjuk" a változó egyes számtartományba eső része feletti összes elemet (tizes, százas stb.), majd a számot tároljuk egy változóban (ami lehet byte, mert az értéke soha nem több 10-nél).
v = v/10; // elosztjuk tízzel, vagyis kvázi levágjuk az utolsó számjegyet, ami eddig 10-es számmező volt, az 1-es lesz, ami 100-as, az 10-es. fractions = v%10; // mint előbb v = v/10; // és tovább. ones = v%10; v = v/10; tens = v%10; // innentől is lehet feljebb menni a százas, ezres, tízezres stb. számmezők felé, amit a változó bír.
// ez innentől a megjelenítés. Pofon egyszerű, meghatározod a tizes számmezőben lévő szám helyzetét (legyen mondjuk az 1. pozíció, és kiírod a számot): lc.setDigit(0,1,tens,false);
// aztán az egyes számmező értékét eggyel jobbra, a 2. pozícióba, de ide ugye kell egy tizedesjelző is (ez itt a "true" jelzés): lc.setDigit(0,2,ones,true);
// aztán megyünk tovább... lc.setDigit(0,3,fractions,false); lc.setDigit(0,4,fractionss,false);
}
Az LiquidCrystal könyvtárral ez úgy fest, hogy:
lcd.setCursor(0, 0); // kurzorpozíció: 0. sor (felső), 0. pozíció (bal szélső). Innen kezdődően jobbra íródik ki a következő sor által definiált karaktersor
lcd.print(tens); // vagyis a tizes számmező számjegye. Mivel ez 0-9-ig lehet valami, csak egy karaktert tartalmaz.
Ez picit kód- és időigényes megoldás, viszont mindig pontosan ugyanúgy jelenik meg a szám.
if, illetve case vizsgálattal azt is meg lehet csinálni, hogy ha az első számjegy 0, akkor üres karaktert adjon, ne 0-t írjon ki (és fordítva is persze).
Biztos van ennél elegánsabb megoldás is, egyelőre nem sikerült rájönnöm.
v = v/10; fractions = v%10; v = v/10; ones = v%10; v = v/10; tens = v%10; lc.setDigit(0,1,tens,false); lc.setDigit(0,2,ones,true); lc.setDigit(0,3,fractions,false); lc.setDigit(0,4,fractionss,false);
}
Ez max72xx-re fogja kiírni, de az elsó rész gyak. bármi lehet.
A sketchben a vagy([homersekletvaltozo]); formulával tudod hívni. A homerseklatvaltozo leginkább unsigned long kell legyen, bár ezen lehet kísérletezni, hogy mi jön ki az rtc-ből (nekem a DS3231-ből sima int jön ki). Lehet, hogy csak egész értékeket fogsz kapni, ez a hőmérőtől függ (bocs, nem néztem vissza, hogy pontosan milyen).
