Nagy vonalakban...

 

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.

lcd.setCursor(0, 1); // eggyel jobbra lépünk (kurzorpozíció)

lcd.print(ones);       //egyesek

lcd.setCursor(0, 2);

lcd.print(',');           // itt így jön a tizedesvessző

lcd.setCursor(0, 3); // és a többi

lcd.print(fractions);

lcd.setCursor(0, 4);

lcd.print(fractionss);

 

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.