konverze datových typů / komunikace s displayem pomocí SPI

Wiring, C++, C, Java, ...
Pravidla fóra
Toto subfórum slouží k řešení obecných otázek kolem programování (konstrukce, knihovny, alokace paměti, ...)
ondraN
Příspěvky: 932
Registrován: 08 srp 2019, 20:01
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od ondraN » 23 led 2020, 09:52

Spíš šlo o uchování 256 hodnot změřených teplot, jestli jsem tedy autora vlákna správně pochopil. A taky jak je potom snadno tisknout.

Maxim
Příspěvky: 128
Registrován: 22 led 2019, 20:32
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od Maxim » 23 led 2020, 18:04

ondraN píše:
23 led 2020, 09:52
Spíš šlo o uchování 256 hodnot změřených teplot, jestli jsem tedy autora vlákna správně pochopil. A taky jak je potom snadno tisknout.
přesně tak, chci záznam hodnot

kód samozřejmě bude ve funkci, budu ho používat v programu asi 6x, takže dělat to pokaždé znova celé by byl docela mazec..

display mám 128*160px, někde jsem ho tu posílal.... komunikuju s ním pomocí SPI sběrnice

ondraN
Příspěvky: 932
Registrován: 08 srp 2019, 20:01
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od ondraN » 23 led 2020, 18:55

Když už budeš psát ty funkce, tak asi narazíš na problém, jak donutit funkci, aby vracela dvě hodnoty. To se dá udělat, že se funkci v parametrech předá ukazatel na proměnnou a funkce ji díky tomu dokáže změnit. Nebo je druhá cesta, elegantnější. Vytvořit novou strukturu, z ní udělat pole a proměnné. Funkce pak může vracet kompletní hodnotu struktury stejným způsobem, jako třeba int.

Kód: Vybrat vše

void setup() {
  // put your setup code here, to run once:
}

struct dual{  // vytvoreni typu dual, se kterym se pracuje stelne jako s jakoukoli jinou promennou
  byte Cele;  // ke clenum Cele a Desetinne se dostanes opratorem tecka takto: NazevPromene.Cele  a  NazevPromene.Desetinne
  byte Desetinne;
};

dual DTemp, Values[256];  //databaze 256 hodnot, zabere 512byte
float Temp;
int Index=0;

dual TempToDual(float Temp); // prototyp funkce konverze teploty z float do dual

void loop() {
  // put your main code here, to run repeatedly:
  for(Index=0;Index<256;Index++){  //naplnis celou tabulku od 0 do 255, tedy 256 hodnot
    float Temp=-15.87; //Tady si zmeris teplotu a das do Temp, ja zde jen neco dosadim
    Values[Index]=TempToDual(Temp); //prepocet a ulozeni do pole
    // dalsi kroky 
    // zpracovani tabulky
  }
}//End of loop


dual TempToDual(float Temp){
  dual NewVal;
  NewVal.Cele=0;
  if(Temp<0){
    NewVal.Cele=128; //nastavi signum, bit 7, do jednicky
    Temp=Temp*(-1);
  }
  NewVal.Cele=NewVal.Cele+byte(Temp);
  Temp=Temp-byte(Temp);  //v Temp zbyde jen desetinna cast;
  Temp=byte(Temp*100);
  NewVal.Desetinne=byte(Temp); //ted jsou v Desetinne desetiny a setiny
  return NewVal;
}


Uživatelský avatar
pavel1tu
Příspěvky: 2054
Registrován: 26 říj 2017, 08:28
Reputation: 0
Bydliště: Trutnov
Kontaktovat uživatele:

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od pavel1tu » 24 led 2020, 06:11

Včera jsem to večer testoval
Ve funkci jsem přímo zapisoval do pole, jinak mi to nešlo - dostat zpět do programu.

A nejlepší je asi řešení od AstroMika, je to elegantní, pro mne lehce čitelné.
UNO, NANO, Mikro, PRO mini, DUE, ESP32S2, RPi PICO
Pavel1TU
"Správně napsaný kod lze číst jako knihu"

ondraN
Příspěvky: 932
Registrován: 08 srp 2019, 20:01
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od ondraN » 24 led 2020, 06:53

Když chceš pracovat s polem ve funkci tak musíš použít odkaz, tedy ukazatel na proměnnou. Tou je v C nebo C++ přímo název pole, takže je to docela jednoduché. Opravdu doporučuji se s tím trochu seznámit, je to opravdu silná vlastnost jazyka a umožňuje řešit i jinak těžko řešitelné věci.
Ta konverze na int od AstroMika je jednoduchá ve směru převodu na int a zpět na float. Perné chvíle ale připraví při formátovaném výstupu, obvzláště při nedostatku paměti. Volba řešení je vždy o kompromisu. Kdyby nebyl potřeba formátovaný výstup, je to jasně volba číslo 1.

Maxim
Příspěvky: 128
Registrován: 22 led 2019, 20:32
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od Maxim » 04 úno 2020, 13:02

Ahoj,
zkouším tu funkci dtostrf a vypadá to, že to bude fungovat. Takže díky za pomoc, jestli sem pak napíšu výsledek.
Arduino budu napájet z baterie, u které chci měřit její napětí. Četl jsem, že je možné nastavit referenční napětí na 1V a poté měřit napětí baterie pomocí napěťového děliče a funkce analogRead. Nebo by někdo poradil něco jednoduššího?
Díky

Uživatelský avatar
pavel1tu
Příspěvky: 2054
Registrován: 26 říj 2017, 08:28
Reputation: 0
Bydliště: Trutnov
Kontaktovat uživatele:

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od pavel1tu » 04 úno 2020, 13:36

Já to dělám takto,
DC/DC měnič z baterek používám s vysokou účinností, většinou si přepíná režimy podle spotřeby a umí StepDown i By-pass
Pak těch 3,3V použiji jako UREF, dělič udělám tak aby max. napětí baterky (i při nabíjení) bylo těch 3,3V
Přesnost záleží na kolísání napětí z DC/DC měniče a přesnosti odporů v děliči.
Na měření LiLion článku to stačí

Zkoušel jsem i nějaké zdroje REF-U, mají sice přesnost 0,01V, ale je to další spotřeba.
UNO, NANO, Mikro, PRO mini, DUE, ESP32S2, RPi PICO
Pavel1TU
"Správně napsaný kod lze číst jako knihu"

Maxim
Příspěvky: 128
Registrován: 22 led 2019, 20:32
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od Maxim » 04 úno 2020, 15:59

Použít stepup mě taky napadlo, Arduino mini pro se dá napájet 5V, že? V tomto případě by mi to stačilo, napájet budu z li-ion článku.
Ale kdybych v budoucnu chtěl např. bezdrátový teploměr aby odesílal teplotu na ústředu a napájel bych to knoflíkovou baterií CR2025, pak bych tam asi ten stepup nechtěl. Ta vysoká účinnost je kolik?

Uživatelský avatar
pavel1tu
Příspěvky: 2054
Registrován: 26 říj 2017, 08:28
Reputation: 0
Bydliště: Trutnov
Kontaktovat uživatele:

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od pavel1tu » 04 úno 2020, 17:50

StepUP je nic moc + pokud si ho stavíte - dost součástek musí být kvalitních a co nejblíže IO (cívečky, kondiky)
Já pokud to je venku napájím 18650 + solárko na dobíjení, ono to vysílání a spousta čidel dost sežere + neustálé probouzení od snímače srážek
Tam používám AP2112K-3.3, je na 3,3V a napájím tim přímo Atmegu328 bez externího krystalu (běží na interních 8MHz)

Doma jedu z 2ks tužkovek (AA), AAA jsem zatím netestoval.
První jsem zkoušel TPS61090, ale bylo to šílené - moc mi ze začátku nechodil - výstup má ale i 5V - nakonec jsem ho opustil, možná se mi tu ještě válí pár ks.
Druhý testuji MCP1640C, z 2xAA na 3,3V (verze C umí kombinovat PWM/PFM i bypass), účinnost píší 96%, no já jsem asi na 90%. Ale živím s tím jen Atmegu328, BME680 a RFM69xx (měřím 1x za 5 min asi 5s, jinak to spí). Jede mi už rok, ale bohužel neměřím baterky - chyba na PCB. Za baterky jsem dal ještě diodu, potřebuje prý 0,3V mezi vstupem a výstupem, ale rozdíl 0,5V je jistota, umí šlapat až do 0,5V na vstupu - s nižžším napětím asi klesá účinnost, tu já měřil jen na plně nabitých AA.

Oba IO jsou velice náchylné na kvalitu a rozmístění součástek !
UNO, NANO, Mikro, PRO mini, DUE, ESP32S2, RPi PICO
Pavel1TU
"Správně napsaný kod lze číst jako knihu"

Maxim
Příspěvky: 128
Registrován: 22 led 2019, 20:32
Reputation: 0

Re: konverze datových typů / komunikace s displayem pomocí SPI

Příspěvek od Maxim » 04 úno 2020, 21:02

Tak jsem opět narazil.. již po třetí..
myslím, že je problém v paměti arduina, začne dělat kraviny, když přidám jen třeba výpis na seriový monitor nebo cokoliv jiného, třeba jen declaraci a výpis int proměnné. globální proměnné zabírají 70% dynamické paměti a pak už mi to prostě blbne...nyní se mi na display zobrazuje 95% toho co bych potřeboval, ale přes to se nemůžu přesnést... poradil by někdo? nebo víc z toho nedostanu?

celý kód vypadá takto:

Kód: Vybrat vše


// include TFT and SPI libraries
#include <TFT.h>
#include <SPI.h>
#include "DHT.h" //knihovna pro modul DHT22
#include <OneWire.h> // knihovny pro externí čidlo
#include <DallasTemperature.h> //knihovny pro externí čidlo
#include <LowPower.h>


// pin definition for Arduino UNO
#define cs   10
#define dc   9
#define rst  8
#define DHTPIN 6 //nastavení PINu pro modul DHT22
#define DHTTYPE DHT22   // DHT 22  (AM2302)

// nastavení čísla vstupního pinu pro externí čidlo
const int pinCidlaDS = 5;
// vytvoření instance oneWireDS z knihovny OneWire (ext. čidlo)
OneWire oneWireDS(pinCidlaDS);
// vytvoření instance senzoryDS z knihovny DallasTemperature (ext. čidlo)
DallasTemperature senzoryDS(&oneWireDS);

// create an instance of the library
TFT TFTscreen = TFT(cs, dc, rst);

DHT dht(DHTPIN, DHTTYPE);

float nejvyssiTeplota = -100;
float nejnizsiTeplota = 200;

int casNejvyssiTeplota;
int casNejnizsiTeplota;
int casNejvyssiTeplotaExt;
int casNejnizsiTeplotaExt;
int casNamereniNejvyssiTeploty;
int casNamereniNejnizsiTeploty;
long casOdStartuArduina;
int pocetUspani;


int16_t zaznamyTeplot[256]; 
int16_t zaznamyTeplotExt[256]; //

uint8_t indexTeplot = 0; //index který zapisuji jako index pole záznamů teplot, sám přeteče při 255+1

uint8_t indexNejnizsiTeploty = 0;
uint8_t indexNejvyssiTeploty = 0;
int16_t nejnizsiUlozenaTeplota = 901;
int16_t nejvyssiUlozenaTeplota = -900;

float nejnizsiTeplotaExt = 9010;
float nejvyssiTeplotaExt = -9000;

uint8_t indexNejnizsiTeplotyExt = 0;
uint8_t indexNejvyssiTeplotyExt = 0;
int16_t nejnizsiUlozenaTeplotaExt = 9010;
int16_t nejvyssiUlozenaTeplotaExt = -2000;


float kolikCykluUbehlo (int aktualniCyklus , int pocitanyIndex) {

  float kolikCykluUbehlo;
  int pomocnyCyklus = aktualniCyklus;
    
  if (pocitanyIndex > aktualniCyklus) {
    pomocnyCyklus = pomocnyCyklus + 255;
  }

  kolikCykluUbehlo = pomocnyCyklus - pocitanyIndex;
  return kolikCykluUbehlo;
  
}

long zobrazeniCasuAZnakuCasu(char *pomocnePole , size_t velikostPole , long pocetCyklu) {

  long hodnotaCasuUpravena = pocetCyklu;
  hodnotaCasuUpravena = pocetCyklu * 2;

  if (hodnotaCasuUpravena < 99) {

    hodnotaCasuUpravena = snprintf(pomocnePole, velikostPole - 1, "%i" , (long)hodnotaCasuUpravena); //převede int "hodnotaCasu" na řetězec "velikostPole" a uloží do velikostPole délku proměnné velikostPole, kterou vrací funkce snprinf
    pomocnePole[hodnotaCasuUpravena] = 's'; //na konec řetězce připíše s

  }

  if ((hodnotaCasuUpravena > 99) and (hodnotaCasuUpravena < 5939)) {
    hodnotaCasuUpravena = hodnotaCasuUpravena / 60;
    hodnotaCasuUpravena = snprintf(pomocnePole, velikostPole - 1, "%i" , (long)hodnotaCasuUpravena); //převede int "hodnotaCasu" na řetězec "velikostPole" a uloží do velikostPole délku proměnné velikostPole, kterou vrací funkce snprinf
    pomocnePole[hodnotaCasuUpravena] = 'm'; //na konec řetězce připíše m

  }

  if (hodnotaCasuUpravena > 5939) {
    hodnotaCasuUpravena = hodnotaCasuUpravena / 3600;
    hodnotaCasuUpravena = snprintf(pomocnePole, velikostPole - 1, "%i" , (long)hodnotaCasuUpravena); //převede int "hodnotaCasu" na řetězec "velikostPole" a uloží do velikostPole délku proměnné velikostPole, kterou vrací funkce snprinf
    pomocnePole[hodnotaCasuUpravena] = 'h'; //na konec řetězce připíše h

  }

  pomocnePole[hodnotaCasuUpravena + 1] = 0; //vytvoří novou zarážku na konci řetězce

  return pomocnePole + 1;

}

void setup() {

  Serial.begin(9600);

  pinMode(3, INPUT_PULLUP); //pin pro vstup tlačítka
  pinMode(A0, INPUT);

  Serial.println("DHT22 funguje!"); //ověření spojení s modulem DHT22

  senzoryDS.begin();

  //initialize the library
  TFTscreen.begin();

  // clear the screen with a black background
  TFTscreen.background(0, 0, 0);

}

void loop() {

  float h = dht.readHumidity();
  float t = dht.readTemperature();
  senzoryDS.requestTemperatures();
  float te = senzoryDS.getTempCByIndex(0);

  int16_t teplotaZaznamINT = t * 10; // teplota vynásobená 10 (pro úsporu paměti)
  int16_t teplotaExtZaznamINT = te * 100; // teplota vynásobená 100 (pro úsporu paměti)

  int sensorValue = analogRead(A0);
  // Převede analogový vstup (od 0 do 1023) na napětí (0 - 5V):
  float voltage = sensorValue * (5.0 / 1023.0);
  float voltageUpravene = voltage * 100;
  int voltageINT = int(voltageUpravene);

  zaznamyTeplot[indexTeplot] = teplotaZaznamINT; //zapíše hodnotu teploty s indexem indexTeplot
  zaznamyTeplotExt[indexTeplot] = teplotaExtZaznamINT; //zapíše hodnotu teploty externího čidla s indexem indexTeplot

  nejnizsiUlozenaTeplota = 901;
  nejvyssiUlozenaTeplota = -200;
  indexNejnizsiTeploty = 0;
  indexNejvyssiTeploty = 0;

  for (int16_t i = 0; i < 256; i++) {

    int16_t porovnavanaTeplota = zaznamyTeplot[i];
    int16_t porovnavanaTeplotaExt = zaznamyTeplotExt[i];

    if (porovnavanaTeplota != 0) {

      if (porovnavanaTeplota < nejnizsiUlozenaTeplota) {
        nejnizsiUlozenaTeplota = porovnavanaTeplota;
        indexNejnizsiTeploty = i;
      }
      if (porovnavanaTeplota > nejvyssiUlozenaTeplota) {
        nejvyssiUlozenaTeplota = porovnavanaTeplota;
        indexNejvyssiTeploty = i;
      }

    }

    if (porovnavanaTeplotaExt != 0) {

      if (porovnavanaTeplotaExt < nejnizsiUlozenaTeplotaExt) {
        nejnizsiUlozenaTeplotaExt = porovnavanaTeplotaExt;
        indexNejnizsiTeplotyExt = i;
      }
      if (porovnavanaTeplotaExt > nejvyssiUlozenaTeplotaExt) {
        nejvyssiUlozenaTeplotaExt = porovnavanaTeplotaExt;
        indexNejvyssiTeplotyExt = i;
      }

    }

  }

  //test a nastavení nejvyšší a nejnižší teploty
  if (nejvyssiTeplota < t) {
    nejvyssiTeplota = t;
    casNejvyssiTeplota = millis() / 1000;
  }

  if (nejnizsiTeplota > t) {
    nejnizsiTeplota = t;
    casNejnizsiTeplota = millis() / 1000;
  }

  //test a nastavení nejvyšší a nejnižší externí teploty
  if (nejvyssiTeplotaExt < te) {
    nejvyssiTeplotaExt = te;
    casNejvyssiTeplotaExt = millis() / 1000;
  }

  if (nejnizsiTeplotaExt > te) {
    nejnizsiTeplotaExt = te;
    casNejnizsiTeplotaExt = millis() / 1000;
  }

  casOdStartuArduina = millis() / 1000;
  indexTeplot++;

  char teplotaHodnota[6];
  char teplotaExtHodnota[7];
  char vlhkostZobrazit[8];
  char nejvyssiTeplotaZobraz[10];
  char nejnizsiTeplotaZobraz[10];
  char casNamereniNejvyssiTeplotyHodnota[8];
  char casNamereniNejnizsiTeplotyHodnota[8];
  char casNejvyssiTeplotaZobrazit[8];

  char aktualniTeplotaExtZobrazit[10];
  char nejnizsiTeplotaExtZobrazit[10];
  char nejvyssiTeplotaExtZobrazit[10];
  
  char pocetSekundOdStartu[8];
  char indexNejnizsiTeplotyZobraz[8];
  char indexNejvyssiTeplotyZobraz[8];
  char indexNejnizsiTeplotyZobrazExt[6];
  char indexNejvyssiTeplotyZobrazExt[6];
  char napetiZobraz[5];
  char napetiZobrazDouble[5];
  char pocetUspaniZobraz[8];

  int16_t nejnizsiUlozenaTeplotaINT = nejnizsiUlozenaTeplota * 10;
  int16_t nejvyssiUlozenaTeplotaINT = nejvyssiUlozenaTeplota * 10;
  int16_t aktualniTeplotaINT = t * 10;

  char nejnizsiUlozenaTeplotaZobrazit[10];
  char nejvyssiUlozenaTeplotaZobrazit[10];
  char nejnizsiUlozenaTeplotaExtZobrazit[10];
  char nejvyssiUlozenaTeplotaExtZobrazit[10];
  char aktualniTeplotaZobrazit[10];
  char napetiZobrazit[8];

  char zaznamI1[9];
  int zaznamI1I = indexTeplot - 2;
  float zaznamI1F = zaznamyTeplot[zaznamI1I];
  zaznamI1F = zaznamI1F / 10;
  dtostrf(zaznamI1F,6,1,zaznamI1);

  char zaznamI2[9];
  int zaznamI2I = indexTeplot - 4;
  float zaznamI2F = zaznamyTeplot[zaznamI2I];
  zaznamI2F = zaznamI2F / 10;
  dtostrf(zaznamI2F,6,1,zaznamI2);
  
  char zaznamI3[9];
  int zaznamI3I = indexTeplot - 11;
  float zaznamI3F = zaznamyTeplot[zaznamI3I];
  zaznamI3F = zaznamI3F / 10;
  dtostrf(zaznamI3F,6,1,zaznamI3);


  //char cyklusZobrazit[8];
  
  
  float aktualniTeplotaFloat = aktualniTeplotaINT;
  aktualniTeplotaFloat = aktualniTeplotaFloat / 10;
  dtostrf(aktualniTeplotaFloat,6,1,aktualniTeplotaZobrazit);

  dtostrf(nejnizsiTeplota,6,1,nejnizsiTeplotaZobraz);
  dtostrf(nejvyssiTeplota,6,1,nejvyssiTeplotaZobraz);

  float nejnizsiUlozenaTeplotaFloat = nejnizsiUlozenaTeplota;
  nejnizsiUlozenaTeplotaFloat = nejnizsiUlozenaTeplotaFloat / 10;
  dtostrf(nejnizsiUlozenaTeplotaFloat,6,1,nejnizsiUlozenaTeplotaZobrazit);

  float indexNejnizsiTeplotyFloat = indexNejnizsiTeploty;
  dtostrf(indexNejnizsiTeplotyFloat,6,0,indexNejnizsiTeplotyZobraz);
  
  float kolikCykluNejnizsiUlozeneTeploty = kolikCykluUbehlo(indexTeplot, indexNejnizsiTeploty);
  char dobaNamereniNejnizsiUlozeneTeploty[10];
  zobrazeniCasuAZnakuCasu(dobaNamereniNejnizsiUlozeneTeploty , 10 , kolikCykluNejnizsiUlozeneTeploty);
  
  float nejvyssiUlozenaTeplotaFloat = nejvyssiUlozenaTeplota;
  nejvyssiUlozenaTeplotaFloat = nejvyssiUlozenaTeplotaFloat / 10;
  dtostrf(nejvyssiUlozenaTeplotaFloat,6,1,nejvyssiUlozenaTeplotaZobrazit);

  float indexNejvyssiTeplotyFloat = indexNejvyssiTeploty;
  dtostrf(indexNejvyssiTeplotyFloat,6,0,indexNejvyssiTeplotyZobraz);

  float kolikCykluNejvyssiUlozeneTeploty = kolikCykluUbehlo(indexTeplot, indexNejvyssiTeploty);
  char dobaNamereniNejvyssiUlozeneTeploty[10];
  zobrazeniCasuAZnakuCasu(dobaNamereniNejvyssiUlozeneTeploty , 10 , kolikCykluNejvyssiUlozeneTeploty);
  
  //externí teploty
  dtostrf(te,6,2,aktualniTeplotaExtZobrazit);

  dtostrf(nejnizsiTeplotaExt,6,2,nejnizsiTeplotaExtZobrazit);
  dtostrf(nejvyssiTeplotaExt,6,2,nejvyssiTeplotaExtZobrazit);

  float nejnizsiUlozenaTeplotaExtFloat = nejnizsiUlozenaTeplotaExt;
  nejnizsiUlozenaTeplotaExtFloat = nejnizsiUlozenaTeplotaExtFloat / 100;
  dtostrf(nejnizsiUlozenaTeplotaExtFloat,7,2,nejnizsiUlozenaTeplotaExtZobrazit);

  float nejvyssiUlozenaTeplotaExtFloat = nejvyssiUlozenaTeplotaExt;
  nejvyssiUlozenaTeplotaExtFloat = nejvyssiUlozenaTeplotaExtFloat / 100;
  dtostrf(nejvyssiUlozenaTeplotaExtFloat,7,2,nejvyssiUlozenaTeplotaExtZobrazit);

  float kolikCykluNejnizsiUlozeneTeplotyExt = kolikCykluUbehlo(indexTeplot, indexNejnizsiTeplotyExt);
  char dobaNamereniNejnizsiUlozeneTeplotyExt[10];
  zobrazeniCasuAZnakuCasu(dobaNamereniNejnizsiUlozeneTeplotyExt , 10 , kolikCykluNejnizsiUlozeneTeplotyExt);

  float kolikCykluNejvyssiUlozeneTeplotyExt = kolikCykluUbehlo(indexTeplot, indexNejvyssiTeplotyExt);
  char dobaNamereniNejvyssiUlozeneTeplotyExt[10];
  zobrazeniCasuAZnakuCasu(dobaNamereniNejvyssiUlozeneTeplotyExt , 10 , kolikCykluNejvyssiUlozeneTeplotyExt);

  
  char zaznamE1[9];
  int zaznamE1I = indexTeplot - 2;
  float zaznamE1F = zaznamyTeplotExt[zaznamE1I];
  zaznamE1F = zaznamE1F / 100;
  dtostrf(zaznamE1F,6,2,zaznamE1);

  char zaznamE2[9];
  int zaznamE2I = indexTeplot - 4;
  float zaznamE2F = zaznamyTeplotExt[zaznamE2I];
  zaznamE2F = zaznamE2F / 100;
  //float zaznamE2F = 10.56;
  dtostrf(zaznamE2F,6,2,zaznamE2);

  //char zaznamE3[10];
  //int INTaazaznamE3I = 55 - 11;
  //Serial.println("sdaf");
  //Serial.println(INTaazaznamE3I);
  //float zaznamE3F = (float)zaznamyTeplotExt[zaznamE3I];
  
  //zaznamE3F = zaznamE3F / 100;
  //Serial.println(zaznamE3F);
  //dtostrf(zaznamE3F,8,2,zaznamE3);

  
    
  //vlhkost  
  dtostrf(h,5,2,vlhkostZobrazit);
  
  //napětí
  dtostrf(voltage,5,2,napetiZobrazit);

  //aktualni cyklus
  float aktualniCyklus = indexTeplot;
  //dtostrf(aktualniCyklus,5,0,cyklusZobrazit);


  char casZobrazit[8];
  float casOdStartuArduinaFloat = casOdStartuArduina;
  dtostrf(casOdStartuArduina,6,0,casZobrazit);

  float pocetUspaniFloat = pocetUspani;
  dtostrf(pocetUspaniFloat,6,0,pocetUspaniZobraz);
  

  TFTscreen.background(0, 0, 0);
  TFTscreen.stroke(100, 255, 100); //zelená
  TFTscreen.setTextSize(1);
  
  TFTscreen.text("T: ", 3 , 2);
  TFTscreen.text(aktualniTeplotaZobrazit, 20, 2);

  TFTscreen.stroke(255, 150, 150); // modrá
  TFTscreen.text(nejnizsiTeplotaZobraz, 50, 2);

  TFTscreen.stroke(50, 50, 255); // červená
  TFTscreen.text(nejvyssiTeplotaZobraz, 86, 2);

  TFTscreen.stroke(100, 255, 100); //zelená
  TFTscreen.text("E: ", 3 , 14);
  TFTscreen.text(aktualniTeplotaExtZobrazit, 20, 14);

  TFTscreen.stroke(255, 150, 150); // modrá
  TFTscreen.text(nejnizsiTeplotaExtZobrazit, 55, 14);

  TFTscreen.stroke(50, 50, 255); // červená
  TFTscreen.text(nejvyssiTeplotaExtZobrazit, 90, 14);

  TFTscreen.stroke(255, 255, 255); //bílá

  TFTscreen.text("Vlh.: ", 3 , 27);
  TFTscreen.text(vlhkostZobrazit, 36, 27);
  TFTscreen.text("%", 70, 27);    

  TFTscreen.text("Nap.: ", 86 , 27);
  TFTscreen.text(napetiZobrazit, 113, 27);
  TFTscreen.text("V", 148, 27);

  TFTscreen.stroke(255, 255, 255); //bílá
  TFTscreen.text("I:", 3, 40);
  
  TFTscreen.stroke(255, 100, 100); // modrá
  TFTscreen.text(nejnizsiUlozenaTeplotaZobrazit, 8, 40);
  TFTscreen.text(dobaNamereniNejnizsiUlozeneTeploty, 55, 40);

  TFTscreen.stroke(50, 50, 255); //červená
  TFTscreen.text(nejvyssiUlozenaTeplotaZobrazit, 75, 40);
  TFTscreen.text(dobaNamereniNejvyssiUlozeneTeploty, 120, 40);

  TFTscreen.stroke(255, 255, 255); //bílá
  TFTscreen.text("E:", 3, 53);

  TFTscreen.stroke(255, 100, 100); // modrá
  TFTscreen.text(nejnizsiUlozenaTeplotaExtZobrazit, 8, 53);
  TFTscreen.text(dobaNamereniNejnizsiUlozeneTeplotyExt, 56, 53);

  TFTscreen.stroke(50, 50, 255); //červená
  TFTscreen.text(nejvyssiUlozenaTeplotaExtZobrazit, 73, 53);
  TFTscreen.text(dobaNamereniNejvyssiUlozeneTeplotyExt, 130, 53);

  delay(10);

  //záznamy interních teplot
  TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text("ZI:", 1, 72);

  TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text(zaznamI1,15,72);

  TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text(zaznamI2,45,72);

  TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text(zaznamI3,80,72);
  
  //záznamy externích teplot
  //TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text("ZE:", 2, 85);

  TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text(zaznamE1,16,85);

  //TFTscreen.stroke(150, 255, 155); //barva
  TFTscreen.text(zaznamE2,54,85);

  //TFTscreen.stroke(150, 255, 155); //barva
  //TFTscreen.text("asdfw",82,85);



  //TFTscreen.stroke(255, 255, 255); //bílá
  //TFTscreen.text(pocetSekundOdStartu, 3, 115);
  //TFTscreen.text(cyklusZobrazit , 3 , 117);
  //TFTscreen.text(casZobrazit, 53, 117);
  TFTscreen.text(pocetUspaniZobraz, 100, 117);


  // wait 500 miliseconds until change to next color
  delay(10);
  LowPower.powerDown(SLEEP_60MS, ADC_OFF, BOD_OFF);
  pocetUspani++;

}


Odpovědět

Kdo je online

Uživatelé prohlížející si toto fórum: Žádní registrovaní uživatelé a 14 hostů