Sdsc sysf

Z onlinetechnology.cz

Přejít na: navigace, hledání
Tato stránka popisuje programovací jazyk SDS-C, který je dostupný na vybraných zařízeních SDS. Některá zařízení používají FULL-C, pro který máme návody jinde na této WiKi.


Existující funkce

Funkce poskytované zařízením první řady SDS, které používá SDS-C, jsou vypsány na této stránce.

Můžete pracovat pouze a jenom s těmi funkcemi, které jsou zde uvedeny (pro konkrétní zařízení SDS-C).

Nezapomeňte, že většina styku s okolním světem se v SDS-C provádí prostřednictvím systémových proměnných (nastavení/čtení hodnot, je to aktualizováno v reálném čase).

Poznámka. pro zařízení SDS druhé řady, které využívájí FULL-C, platí zcela jiný seznam systémových funkcí.


Tabulka

Kliknutím na název funkce vás odkaz přemístí na detailnější popis použití.

Vždy zkontrolujte, jakou verzi SDS-C má vaše SDS. Pokud máte starou verzi, nebudou vám nové funkce k dispozici - řešení je jednoduché, vždy použijte nejaktuálnější firmware.

Funkce Dostupné od verze SDS-C číslo: Rychlý popis
init {...} 01 funkce zavolaná jen jednou po spuštění zařízení (resetu)
main {...} 01 funkce hlavní smyčky programu
return; 01 předčasné ukončení právě prováděné uživatelské funkce
echo() 01 zápis do konzole s odřádkováním
echoclear() 01 vymaže celý obsah konzole
echoinline() 06 zapís do konzole bez odřádkování
wait() 01 pozastavení činnosti programu na určenou dobu
sprintf() 06 zápis do pole text[]
textcmp() 08 porovnání části pole text[] s pevným textem
atoi() 06 převod textu na číslo
itoa() 08 převod čísla na text (decimálně)
itoh() 08 převod čísla na text (hex)
smtp_send() 01 odešle email na zadanou adresu
ping() 01 odešle ICMP PING REQUEST
dns_resolv() 01 překlad názvu na IP
http_get() 01 pošle požadavek HTTP GET na server
snmp_send_trap() 06 odeslání SNMP v1 TRAP zprávy
send_udp() 06 odeslání UDP paketu
lcd_echo() 01 psaní textu na LCD (pro SDS MACRO)
lcd_clear() 01 smazání LCD (pro SDS MACRO)
lcd_newline() 01 posune text na LCD o jeden řádek nahoru (pro SDS MACRO)
lcd_setpixel() 06 manipulace jednotlivého pixelu na LCD (pro SDS MACRO)
serial1_set() 01 nastavení parametrů COM1
serial6_set() 08 nastavení parametrů COM6
serial1_text_out() 01 odeslání řetězce znaků na COM1
serial6_text_out() 08 odeslání řetězce znaků na COM6
serial1_write() 06 odeslání obsahu text[] na COM1
serial6_write() 08 odeslání obsahu text[] na COM6
read_dataflash() 05 čte jednu proměnnou z DataFlash
write_dataflash() 05 zapíše obsah jedné proměnné do DataFlash
read_dataflash_page_to_ram() 06 přečte obsah DataFlash stránky do ram[]
write_ram_block_to_dataflash_page() 06 zapíše obsah ram[] do DataFlash stránky
onewire_rescan() 06 provede rescan 1-W sběrnice
sdsc_reset_program() 08 provede znovuspuštění SDS-C programu (restart)
sdsc_set_wdg() 08 nastavení a spuštění hlídání běhu SDS-C programu
sdsc_kick_wdg() 08 pravidelné nulování odpočtu hlídače běhu SDS-C programu


Vyhrazené funkce

init { ... }
funkce (dobrovolně/volitelně použitá programátorem), která se provede jen jednou, právě po zapnutí zařízení (resetu)
main { ... }
funkce (musí být definován její obsah), provádí se stále bezodkladně dokola (ale typicky má programátor svou vlastní vnitřní smyčku uvnitř, takže nikdy z main() "neodejde")
return;
předčasné ukončení právě prováděné uživatelské funkce (návrat)

Využití init: tato funkce je zavolána jen jednou pro spuštění programu (tj. po resetu zařízení SDS nebo po nahrání nového programu).

init
{
  echo('Jsem ve funkci init.');
  // sem dejte to, co chcete, aby se provedlo jednou po restartu zařízení
}


Využití main: tato funkce je zavolána jako první (ale až po funkci init je-li funkce init použita) ze všech funkcí v programu. Jakmile se provedou všechny příkazy zapsané ve funkci main, je tato funkce spuštěna znovu (a znovu...). Samozřejmě opakovanému volání se lze vyhnout, pokud funkci správně naprogramujete.

main
{
  echo('Jsem ve funkci main.');
 
nekonecna_smycka:
  goto nekonecna_smycka;
}


Využití return: tento příkaz předčasně ukončí provádění funkce, ve které je zapsán a právě proveden.

funkce
{
  echo('Pred return');
 
  return; // ukončení funkce hned v tento moment
 
  echo('Toto se nikdy neprovede');
}
 
main
{
  echo('Jsem ve funkci main.');
 
  funkce();
 
nekonecna_smycka:
  goto nekonecna_smycka;
}


Jednotné funkce pro SDS-C

Všechny vlastní systémové funkce SDS-C mají vždy minimálně jeden parametr.

Pokud zavoláte (obvykle omylem) interní funkci bez parametru, např. jen echo(), tak samozřejmě nebude cokoliv vykonáno pro konkrétní zavolání této funkce.

Pozor - uživatelem definované funkce naopak parametry nemají, takže vaše vlastní funkce si volejte bez parametrů, např. moje() je správně.



echo()

echo()
zapíše text na konzoli (zobrazena na webové stránce) a odřádkuje, užitečné pro ladění programu nebo pro průběžné sledování stavu

Funkce echo() v podstatě odpovídá funkci printf(), s tím, že funkce echo() na konec vypsaného textu vždy umístí znak pro nový řádek. Takže každé zavolání echo() odřádkuje text v konzolovém výpisu.

 echo('Hello !');
 echo('Teplota je ',sys[310],' °C ...');

Každé zavolání funkce echo() vloží text do konzole, a současně jej odřádkuje. Konzole je přístupná přes webové rozhraní, popř. přes speciální webovou stránku (web-snippet - viz: echo.htm), na které je čistě jen výpis konzole. Odřádkování používá HTML tag "br".



echoinline()

echoinline()
zapíše text na konzoli bez odřádkování

Funkčně shodné s funkcí echo(). Neprovede však odřádkování (posun pozice v konzoli na nový řádek).

 echoinline('Hello !');
 echoinline('Teplota je ',sys[310],' °C ...');



echoclear()

echoclear()
vymaže celý obsah konzole (viz echo(), ...)
 echoclear(0);

Cokoliv co bylo dosud zapsáno na konzoli je smazáno. Samozřejmě lze dále znovu zapisovat pomocí funkce echo(...).

Jako parametr můžete uvést jakékoliv číslo, nemá to v současné verzi firmware vliv (v budoucnu ale může být parametru přiřazen nějaký význam, takže tam raději pište nulu pro budoucí kompatibilitu).



smtp_send()

smtp_send()
odešle email na zadanou adresu, s daným subjectem (nadpis zprávy), obsahem je pak zbytek (tzv. multi-text)
 smtp_send('adresa','subject', 'multi-text');
 smtp_send('joe@foo.com', 'alarm', 'Teplota cidla ',cidlo,' prekrocila 35 stupnu ! Aktualne to je ',teplota);

Odřádkování provedete pomocí zapsání \n. Toto lze vložit kamkoli do textu, i vícekrát. Příklad:

 smtp_send('joe@foo.com', 'alarm', 'Toto je první řádek.\nToto je druhý řádek.');
 
 VE VÝSLEDKU (obsah zprávy emailu):
  Toto je první řádek.
  Toto je druhý řádek.

Nezapomeňte, že je potřeba mít správně nastavený SMTP server (jeho IP adresu) v administraci (webové rozhraní).

SDS-C: maximální délka textového obsahu zprávy je 1024 znaků !!! Detaily viz SMTP.

Poznámka: po zavolaní smtp_send() se začne email odesílat, avšak program v SDS-C ihned pokračuje - nečeká se na dokončení zavolané funkce! Proto je vhodné, po zavolání funkce, mít v programu testovací smyčku, která počká na výsledek (podle hodnoty chybového hlášení OSI7 - viz seznam systémových proměnných).



ping()

ping()
odešle ICMP PING REQUEST na zadané IP
 ping(ip[0],ip[1],ip[2],ip[3],ping_sequence);
 ping(192,168,1,1,1234);

Funkce po svém zavolání nuluje výsledkové proměnné, pošle ICMP PING REQUEST a nečeká - hned se vrací, aby mohl program pokračovat. Výsledek (povedlo-li se odeslat nebo ne) je uložen do příslušných systémových proměnných. Až v okamžiku příjmu odpovídajícího ICMP PING RESPONSE (ECHO) je spočítán RTT a tato hodnota je uložena do sys[94], včetně aktualizace stavu funkce v sys[92]. To že se jedná o odpovídající RESPONSE pozná zařízení tak, že porovná SEQUENCE ID v přijatém paketu odpovědi s posledním odeslaným SEQUENCE ID pomocí funkce ping(), a současně se musí jednat o stejnou IP adresu odesílatele odpovědi s IP adresou v odeslaném REQUESTu.

Použijte ping_sequence pro odlišení vašeho ICMP PING REQUEST paketu od jiných ICMP PING REQUEST paketů (např. od integrovaného IP watchdogu). Typicky, ping_sequence je potřeba po každém odeslání inkrementovat (nebo jinak změnit) ! Bez ping_sequence by nebylo pro program možné rozeznat odpovědi na více najednou odeslaných PING REQUESTů.

Pozor! Funkce ping() je k dispozici až teprve ve verzi SDS-C č. 04.



dns_resolv()

dns_resolv()
provede požadavek na DNS server o překlad názvu domény (text) na IP adresu
 dns_resolv('www.onlinetechnology.cz')

Příklad:

 dns_resolv('www.onlinetechnology.cz');
 
 //pockam az se funkce spusti
label cekam_na_dns_1:
 if (sys[65] == 0) goto cekam_na_dns_1; 
 
 //nastavime cas, po ktery jsme ochotni cekat
 sys[64] = 15; // 15 seconds
 
 //jeste pracuje?
label cekam_na_dns_2:
 
 //vyprsel cas po ktery jsme cekali?
 if (sys[64] == 0) goto dns_chyba;
 
 //test - pracuje jeste?
 if (sys[65] == 514) goto cekam_na_dns_2;
 
 //test - byla chyba?
 if (sys[65] == 513)
 {
label dns_chyba:
   echo('Chyba pri DNS prekladu. Nemam vysledek.');
   goto preskocit;
 }
 
 //mame vysledek?
 if (sys[65] == 512)
 {
  //ok, neni chyba!
  //mame vysledek:
  echo('DNS preklad: status=',sys[65],'  IP=',sys[66],'.',sys[67],'.',sys[68],'.',sys[69]);
 } 
 
 label preskocit:

Nezapomeňte, že je potřeba mít nastavenou adresu DNS serveru v administraci (webové rozhraní).

Poznámka - po zavolání této funkce není program zastaven (nečeká na ukončení funkce), funkce DNS překladu běží tzv. "na pozadí" (to proto, že to může trvat i velmi dlouho), a díky tomu je možné po dobu čekání na dokončení DNS překladu vykonávat jinou programovou činnost.

Je velmi doporučeno si ověřit v praxi, jak se ve vaší sítí bude tato funkce chovat, ideálně pomocí vlastního testovacího programu (provádět dns_resolv() a vypisovat průběh a výsledky do konzole).



wait()

wait()
pozastavení činnosti programu na určenou dobu v milisekundách
 wait(100);

Příklad: počká 100 msec. Po nastavenou dobu je program zablokován. Pokud provádíte čekání, je vždy lepší využít smyčku a odečítat proměnnou (při znalosti že jedna celá instrukce trvá asi 1 msec), než používat wait(), jde o to, že tak v době čekání může program v té smyčce dělat ještě něco jiného.



http_get()

http_get()
pošle požadavek (jako klient) na vzdálený HTTP server (HTTP GET)

Tato funkce má dva cíle: kontrolu funkčnosti webových serverů a možnost odesílat data na webový server.

Tato funkce je k dispozici ve firmware od dne 13.8.2010.

Tuto funkci lze využít i pro vzdálenou změnu proměnných, popř. čtení hodnot těchto vzdálených proměnných.

Funkce vytvoří TCP spojení na vzdálený server, pošle HTTP GET příkaz s uživatelem stanovenou GET cestou. Data, které server vrátí, můžete nechat uložit do pole ram[] (viz text dále), každopádně vždy je uložen návratový kód HTTP protokolu (číselná hodnota, např. 200 pro OK).

Uživatel si může sestavit libovolné parametry pro GET (tj. URL s parametry formuláře). Pozor, funkce neprovádí překódování speciálních znaků, tak jak jsou parametry předány funkci, tak jsou poslány ven.

První čtyři vstupní parametry jsou IP adresa, následuje název host (rozlišení pro více serverů na stejné IP), a všechny následující parametry jsou seskládány do GET požadavku. Pokud žádné další parametry nezadáte, je vytvořen prázdný GET /.

  http_get(ip[0],ip[1],ip[2],ip[3],'host', ...get_strings...);

Proč je potřeba zadávat jak jednak IP adresu, tak i název host? Protože častá praxe poskytovatelů webového prostoru je ta, že na jedné společné IP adrese je stroj, který poskytuje celou řadu virtuálních serverů. Protože je však potřeba adresovat konkrétní server, je potřeba vyplnit jak IP (adresa serveru - stroje) tak i položku host (konkrétní webový server na společném stroji). Pokud není rozlišení přes 'host' nutné, vyplňte danou položku IP adresou (takže tam bude jednak IP na začátku jako čísla, a pak zopakovaná jako text).

Důležitá informace: 'host' je jen jedna položka (parametr funkce), všechny následující parametry jsou již vloženy do URL.

Důležitá informace: 'host' se předává 1:1 do hlavičky odeslané webovému serveru. Proto můžete do 'host' napsat pouze text, který přímo webový server akceptuje. Nelze tam psát jakékoliv doplňky, které vás napadnou (např. www.x.qa:80 to je špatně, :80 je tam navíc - nepište to tam, naopak použijte sys[76]).

Následující příklad vytvoří spojení na server (zadaný vždy pomocí IP) a pošle požadavek GET /store.php?teplota1=2205 (pozn. hodnota 2205 je aktuálním obsahem systémové proměnné, viz kód příkladu).

 http_get(10,20,0,85,'www.foo.com','/store.php?teplota1=',sys[310]);

Vždy musíte zadat IP adresu (a také správně vyplnit parametr 'host'). Pokud chcete používat textovou adresu, lze samozřejmě využít DNS pomocí dns_resolv() funkce, tím se získá IP a to se pak dosadí jako parametry do http_get().

Od verze 03 máte možnost změnit TCP port, na kterém je provedena komunikace s WWW serverem. Změnu musíte provést před zavoláním funkce http_get(). Jakmile funkci zavoláte, další změny se již na prováděné komunikaci neprojeví - ale až pro další zavolání funkce. Změna se provádí zápisem platného čísla portu do systémové proměnné (viz seznam).

Pozor, po zavolání funkce http_get() je spuštěn proces komunikace s webovým serverem, ale je to prováděno "na pozadí", tzn. program dále pokračuje v práci (lze tedy dělat další věci).

Před zavoláním funkce http_get() musí být všechny ostatní funkce (např. smtp_send() atd.) plně ukončeny.

 /* tento příklad získá stav webového serveru www.onlinetechnology.cz, konkrétně www.onlinetechnology.cz/index.html */
 
 // port WWW serveru
 sys[76] = 80; // prakticky se tento radek pise do programu pouze pokud bude pouzity porty jiny nez 80 (protoze 80 je uz nastaveno jako vychozi hodnota)
 
 // provedeme DNS překlad
 dns_resolv('www.onlinetechnology.cz');
 
 // pockam az probehne funkce do konce
label cekam_na_dns:
 if (sys[65] == 0) goto cekam_na_dns; 
 
 // otestujeme úspěch DNS překladu
 if (sys[65] != 512) goto preskocit_protoze_chyba_DNS;
 
 // ok, mam IP ziskanou pomoci DNS
 
 // test na stav SDS
 if (sys[65] == 128) // -> 128 : nezapojeny Ethernet
  goto jina_chyba;
 
 // takze volam http_get
 
 http_get(sys[66],sys[67],sys[68],sys[69],'www.onlinetechnology.cz','/index.html');
 
 // prvni test - tento se provadi okamzite
 if (sys[65] == 1029)
  goto moc_brzo_musim_jeste_cekat;
 
 // CEKACI SMYCKA:
 
 // pockam az probehne funkce do konce
label cekam_na_http:
 
 // stala se nejaka chyba ? (1025, 1026, atd. . . . )
 if (sys[65] > 1024) goto chyba_www_serveru;
 
 // zatim pracuje, takze cekam dale
 if (sys[65] != 1024) goto cekam_na_http; 
 
 // takze mame vysledek (1024)
 
 // overime navratovou hodnotu
 if (sys[75] != 200) goto chyba_www_serveru;
 
 // je to 200 OK
 echo('Server hlasi 200 OK    - HOTOVO');
 
 // vse hotovo
 goto final;
 
label preskocit_protoze_chyba_DNS:
 // obsluha chyby - např. provést chybové hlášení na konzoli
 
 echo('Chyba, nelze provest DNS preklad.');
 
 goto final;
 
label chyba_www_serveru:
 // obsluha chyby - www server
 
 echo('Chyba, www server nedostupny nebo nevratil 200 OK - konkretni http kod je: ',sys[75]);
 
 goto final;
 
label moc_brzo_musim_jeste_cekat:
 // 1029
 
 echo('Volani http_get bylo moc brzo, protoze se jeste nedokoncila predchozi zavolana funkce.');
 
 goto final;
 
label jina_chyba:
 // jina chyba
 
 echo('Jina chyba: ',sys[65]);
 
 //
label final:
 
 //konec prikladu


Všimněte si způsobu, jakým je zpracováván stav sys[65] v tomto ukázkovém programu.


Od verze SDS-C č. 04 je k dispozici možnost uložit uživatelem určený počet bajtů (viz příslušný sys[]) z textu, vráceného serverem. Tyto data se ukládají do pole ram[] od indexu [1], kde index [0] obsahuje skutečný počet uložených znaků, vše viz detaily v popisu systémových proměnných. Tuto funkci můžete ovládat nebo zakázat (nedojde k přepsání ram[]) nastavením příslušné systémové proměnné.

Od verze SDS-C č. 06 je k dispozici možnost uložit uživatelem určený počet bajtů (viz příslušný sys[]) z textu, vráceného serverem do pole text[]. Provede se to nastavením sys[77] na hodnotu 2 (hodnota 1 naopak zapíše výsledek do pole ram[] a hodnota 0 zakáže jakýkoliv zápis přijatých dat). I při volbě zápisu do pole text[] se zapisuje skutečně přijatý počet znaků do položky ram[0].



lcd_echo()

lcd_echo()
psaní textu na LCD (použitelné pro zařízení SDS MACRO)

Máte-li SDS MACRO vybavené doplňkovým modulem (interním) s displayem (LCD), můžete na tento display psát libovolné texty, pomocí funkce lcd_echo().

Display je provozován v režimu čtyři řádky po 22 znaků.

 lcd_echo(POZICE_NA_ŘÁDKU, ŘÁDEK, BARVA, ...text...);

Funkce se používá shodně jako echo(), ovšem je zde potřeba určit, na který ze dvou řádků se má daný výstup zapsat - a proto je potřeba hned první parametr při volání této funkce použít pro určení řádku. Druhý parametr je vyhrazen pro určení barvy, pro aktuální použitý display můžete zvolit:

  • neinvertovaná barva - číslo 0
  • invertovaná barva - číslo 1

určení pozice na řádku:

  • číslo 1 až 22

a pro určení řádku:

  • první řádek (a bude nejprve smazán) - číslo 1
  • druhý řádek (a bude nejprve smazán) - číslo 2
  • třetí řádek (a bude nejprve smazán) - číslo 3
  • čtvrtý řádek (a bude nejprve smazán) - číslo 4
  • první řádek (nebude smazán) - číslo 100
  • druhý řádek (nebude smazán) - číslo 200
  • třetí řádek (nebude smazán) - číslo 300
  • čtvrtý řádek (nebude smazán) - číslo 400

Pokud chcete zapsat více než 16 znaků, budou nadbytečné znaky zahozeny (nedojde k přepsání dalšího řádku). Zápis probíhá vždy od levého kraje řádku. Také si můžete vybrat, zda-li chcete celý řádek před novým zápisem smazat nebo ne.

Příklad zápisu do prvního řádku na první pozici z kraje, včetné předcházejícího smazání, neinvertované barvy:

 lcd_echo(1, 1, 0, 'text', 'a dalsi');

Příklad zápisu do třetího řádku bez předchozího smazání řádku, od desáté pozice zleva, invertované barvy:

 lcd_echo(10, 300, 1, 'Teplota je ',sys[310]);

Pozor! Při jakékoliv změně obsahu LCD (byť zápis jediného znaku) je celý display aktualizován - nedojde ke ztrátě předchozích zápisů, ale je potřeba zvážit případné zdržení (příklad: např. při zápisu po jednotlivých znacích (mnoho volání lcd_echo() ) bude mnohem déle trvat celá akce, než jediné zavolání lcd_echo() s celým textem).



lcd_clear()

lcd_clear()
smazání LCD (použitelné pro zařízení SDS MACRO)

Funkce má jediný parametr, a to určení řádku. Po zavolání se celý daný řádek vymaže. Nedojde ke změně na ostatních řádcích.

  • celý LCD - číslo 0
  • první řádek - číslo 1
  • druhý řádek - číslo 2
  • třetí řádek - číslo 3
  • čtvrtý řádek - číslo 4

Příklad smazání celého prvního řádku:

 lcd_clear(1);



lcd_newline()

lcd_newline()
posune text na LCD o jeden řádek nahoru (použitelné pro zařízení SDS MACRO)

Funkce nemá parametr. Vhodné pro emulaci vzhledu konzolového výpisu.

Po zavolání funkce je text každého řádku přesunut o jeden řádek výše. Původní obsah nejvyššího řádku se ztrácí.

Příklad použití:

 lcd_newline(0);

Paramtery: vždy uveďte číslo 0. V budoucí verzi se totiž význam hodnoty parametru může změnit (nové funkce).



lcd_setpixel()

lcd_setpixel()
vykreslení nebo smazání jednoho pixelu na LCD (použitelné pro zařízení SDS MACRO)

Tato funkce je podporována ve firmware SDS MACRO od verze 3.10.2013, dřívější verzi nemají podporu pro manipulaci s jednotlivými pixely na LCD (k dispozici byla podpora pouze pro výpisy textů).

Funkce má tři parametry:

  • (první parametr) souřadnice X
  • (druhý parametr) souřadnice Y
  • (poslední parametr) operace

"Operace" má tyto dvě sady tří povolených hodnoty:

  • 0 = pixel je smazán (nesvítí), display je okamžitě překreslen z bufferu
  • 1 = pixel je aktivní (svítí), display je okamžitě překreslen z bufferu
  • -1 = pixel je invertován (pokud svítil, nebude, a naopak), display je okamžitě překreslen z bufferu
  • 10 = pixel je smazán (nesvítí), změna je provedena jen v bufferu
  • 11 = pixel je aktivní (svítí), změna je provedena jen v bufferu
  • -11 = pixel je invertován (pokud svítil, nebude, a naopak), změna je provedena jen v bufferu

Při použití kreslení a následného okamžitého překlopení na LCD, je v důsledku dlouhotrvajícího překreslení (přenos bufferu z RAM do LCD) celý program značně zpomalen. Pokud se kreslí jeden pixel, není to problém. Pokud chcete kreslit více pixelů (např. nějaký graf), pak nemá význam po každém změněném pixelu přenášet celý buffer do LCD - stačí to totiž udělat až nakonec, při kreslení posledního pixelu z celé řady. Toto celé se dá provést vhodnou kombinací hodnot "operace" při volání funkce.

Příklad použití:

 //--- ZMENY SE IHNED PROJEVI NA LCD:
 
 // nastav pixel na [10,20] a ihned aktualizuj cele LCD
 lcd_setpixel(10,20,1);
 
 // smaz pixel na [11,21] a ihned aktualizuj cele LCD
 lcd_setpixel(11,21,0);
 
 // invertuj pixel na [10,20] a ihned aktualizuj cele LCD
 lcd_setpixel(10,20,-1);
 
 //--- Pokracovani prikladu:
 //--- ZMENY SE ZAPISI JEN DO BUFFERU:
 
 // nastav pixel na [10,20] (zmena jen v bufferu, LCD neni aktualizovano)
 lcd_setpixel(10,20,11);
 
 // smaz pixel na [11,21] (zmena jen v bufferu, LCD neni aktualizovano)
 lcd_setpixel(11,21,10);
 
 //--- nakonec potrebujeme prekreslit buffer na LCD
 
 // invertuj pixel na [10,20] a ihned aktualizuj cele LCD (udela zmenu a pak prenese cely buffer)
 lcd_setpixel(10,20,-1);



serialX_set()

serial_set()
serial1_set()
serial6_set()
změna parametrů sériové linky (COM1, COM6)

Funkce má pevný počet parametrů, všechny je potřeba vždy vyplnit.

Tato funkce změní konfiguraci sériové linky. Protože sériová linka je využívána společně s převodníkem Ethernet/Serial, a to současně, je potřeba počítat s tím, že pokud se někdo k převodníku Eth/Serial připojí a pomocí RFC změní konfiguraci sériové linky, nebude už platit to co bylo předtím nastaveno zavoláním této funkce.

Parametry:

  • rychlost v bps (1bps až 1Mbps)
  • počet datových bitů (8, 7, 6, 5)
  • počet stop bitů (1,2)
  • počet a typ paritních bitů

Význam nastavení paritních bitů:

  • 0 = bez parity
  • 1 = bez parity
  • 2 = 1 paritní bit, ODD (hodnota bitu určena z předchozích dat)
  • 3 = 1 paritní bit, EVEN (hodnota bitu určena z předchozích dat)
  • 4 = 1 paritní bit, MARK (bit drží hodnotu)
  • 5 = 1 paritní bit, SPACE (bit drží hodnotu)

Příklad nastavení 9600 bps, 8 datových bitů, 1 stop bit, žádná parita:

 // SDS-C starší než verze 08 (tedy verze 01 až 07 včetně, ale už ne 08):
 // -> nastavení vždy jen pro COM1
 serial_set(9600, 8, 1, 0);
 // SDS-C verze 08 (včetně) a novější:
 
 // -> nastavení pro COM1
 serial1_set(9600, 8, 1, 0);
 
 // -> nastavení pro COM6
 serial6_set(9600, 8, 1, 0);

Pozor: původní funkce serial_set() je od verze SDS-C 08 nahrazena novými funkcemi (serial1_set() a serial6_set()). Pro zpětnou kompatibilitu je původní funkce serial_set() zachována tak, že její zavolání odpovídá zavolání funkce serial1_set().



serialX_write()

serial_write()
serial1_write()
serial6_write()
odeslání řetězce bajtů na sériovou linku (COM1, COM6)

Funkce odešle určený obsah pole ram[] nebo text[] na sérivou linku. Konfigurace sériové linky se provádí jiným příkazem, serial_set().

Podle parametrů předadných této funkci dojde k odvysílání bajtů z určeného pole. Každý bajt v poli je předán na sérivou linku, bez jakýchkoliv změn.

Tuto funkci využijete jako alternativu k serial_text_out(), která má specifické chování.

Funkce serial_write() odesílá přesně stanovený počet bajtů, bez ohledu na jejich obsah (nezastaví se na 0x00 a tak dále).


Parametry funkce:

 serial_write(ArrayType, StartIndex, NumOfBytes);
  • ArrayType = výběr text[] nebo ram[]
  • StartIndex = počáteční index v poli (odsud, včetně tohoto indexu, se začnou brát data)
  • NumOfBytes = počet bajtů k odeslání (vždy bude odeslán přesně tento počet bajtů, ať už mají jakýkoliv obsah)


Hodnota ArrayType:

  • 0 == pole text[]
  • 1 == pole ram[]


Při překročení maximální délky pole dojde k automatickému zaříznutí po poslední položce v poli, a dále už se nebude vysílat.

Přiklad:

 // vyplníme náhodne bajty
 text[10] = 0x12;
 text[11] = 0x24;
 text[12] = 0x00;
 text[13] = 0x63;
 text[14] = 0xAB;
 
 // odešli bajty z pole text[10] až text[(10+5)-1] na COM1
 // (příklad pro SDS-C verze 01 až 07)
 serial_write(0, 10, 5);
 
 // pro tento příkald jsou odeslány tyto bajty: 0x12 0x24 0x00 0x63 0xAB
 
 // (příklad pro SDS-C verze 08 (včetně) a novější)
 serial1_write(0, 10, 5); // zápis do COM1
 serial6_write(0, 10, 5); // zápis do COM6

Pozor: původní funkce serial_write() je od verze SDS-C 08 nahrazena novými funkcemi (serial1_write() a serial6_write()). Pro zpětnou kompatibilitu je původní funkce serial_write() zachována tak, že její zavolání odpovídá zavolání funkce serial1_write().



serialX_text_out()

serial_text_out()
serial1_text_out()
serial6_text_out()
odeslání řetězce znaků na sériovou linku (COM1, COM6)

Funkce odešle všechny své parametry na sériovou linku. Konfigurace sériové linky se provádí jiným příkazem, serial_set().

Celkem je možno na jedno volání této funkce odeslat až 1024 znaků.

Příklad odeslání textu (lze kombinovat více parametrů):

 serial_text_out('*B1', 'OS', '2H' ,0x0D);

Tento příklad odešle následující znaky: 0x2a 0x42 0x31 0x4f 0x53 0x32 0x48 0x0d (tj. text *B1OS2H\n)

Funkčně identický k předchozímu příkladu je následující příklad (aby šlo vidět, že lze poslat i delší texty):

 serial_text_out('*B1OS2H' ,0x0D);

Samozřejmě lze odeslat text a hodnotu proměnné, která se převede na text !

Příklad zpracování proměnné:

 var i;
 
 i = 1234;
 
 // varianta pro SDS-C verze 01 až 07 (včetně)
 serial_text_out('hodnota i = ', i);
 
 // varianta pro SDS-C verze 08 (včetně) a novější
 serial1_text_out('hodnota i = ', i); // zápis do COM1
 serial6_text_out('hodnota i = ', i); // zápis do COM6

Tento příklad odešle následující text: hodnota i = 1234, tj. v hexa: 0x68 0x6f 0x64 0x6e 0x6f 0x74 0x61 0x20 0x69 0x20 0x3d 0x20 0x31 0x32 0x33 0x34

S výhodou můžete využít simulátor SDS-C, který vypisuje výstup funkce serial_text_out() jak v hexa hodnotách, tak jako jednotlivé znaky - což je výhodné pro kontrolu co se skutečně v zařízení odesílá.

Poznámka: příjem ze strany sériové linky do zařízení je k dispozici pouze pro verzi SDS-C č. 04 a novější. Data jsou po příjmu z UARTu ukládána do bufferu, a ve správném pořadí je možno je číst (vyjmout z bufferu a použít v programu), a to pomocí čtení hodnoty příslušné systémové proměnné (viz popis systémových proměnných). SDS-C program tak má plnohodnotný přístup k sériové lince zařízení.

Pozor: původní funkce serial_text_out() je od verze SDS-C 08 nahrazena novými funkcemi (serial1_text_out() a serial6_text_out()). Pro zpětnou kompatibilitu je původní funkce serial_text_out() zachována tak, že její zavolání odpovídá zavolání funkce serial1_text_out().



read_dataflash()

read_dataflash()
čte jednu proměnnou z DataFlash

Tato funkce je dostupná teprve pro SDS-C č. 05 a novější.

Detailní popis je dostpný na tomto odkaze.



write_dataflash()

write_dataflash()
zapíše obsah jedné proměnné do DataFlash

Tato funkce je dostupná teprve pro SDS-C č. 05 a novější.

Detailní popis je dostpný na tomto odkaze.



read_dataflash_page_to_ram()

read_dataflash_page_to_ram()
přečte obsah DataFlash stránky do ram[]

Tato funkce je dostupná teprve pro SDS-C č. 06 a novější.

Detailní popis je dostpný na tomto odkaze.



write_ram_block_to_dataflash_page()

write_ram_block_to_dataflash_page()
zapíše obsah ram[] do DataFlash stránky

Tato funkce je dostupná teprve pro SDS-C č. 06 a novější.

Detailní popis je dostpný na tomto odkaze.



atoi()

atoi()
převod textu (z pole text[]) na proměnnou (číselnou hodnotu)

Tato funkce je dostupná teprve pro SDS-C č. 06 a novější.

Funkce převede vybraný text uložený v poli text[] do uvedené proměnné.

 var i;
 
 text[0] = '1'; text[1] = '2'; text[2] = '3'; text[3] = 0;
 
 atoi(text[0]); // převede z pole text[] z indexu 0 do sys[62]
 
 i = sys[62]; // výsledek je totiž vždy uložen do sys[62]
 
 echo(i); // vypíše: 123   pozn. ano, mohli by jsme zde napsat echo(sys[62]) se stejným výsledkem

Význam parametrů funkce:

 atoi(text[počáteční_index]);

Funkce atoi() přebírá znaky od určeného indexu pole text[] (první parametr funkce) tak dlouho, dokud nenarazí na hodnotu 0 uloženou v jednom z následujících indexů pole text[]. Následně se pokusí celý tento vybraný řetězec převést na číslo, které se zapíše do sys[62]. Pokud to není možné (jsou tam nečíselné znaky, např. písmena), je proces převodu přerušen a hodnota v sys[62] není změněna (zůstane tam původní hodnota).



itoa()

itoa()
převod číselné proměnné na text (do pole text[]) - desítková soustava

Tato funkce je dostupná teprve pro SDS-C č. 08 a novější.

Funkce převede hodnotu ve vybrané proměnné, do textového formátu - zapíše text na určené místu v poli text[] (včetně zakočení znakem 0x00).

 var i;
 
 // vstupní číselná hodnota  
 i = 1234;
 
 // převod obsahu "i" na řetězec do pole text na pozici [32]
 itoa(i, 32);
 
 echo(text[32]); // vypíše text: 1234
 
 // nebo také takto
 itoa(1234, 32);
 
 // nebo také takto
 var pozice;
 pozice = 32;
 itoa(1234, pozice);
 

Význam parametrů funkce:

 itoa(proměnná_k_převodu, počáteční_index_do_pole_text);

Funkce itoa() zapisuje na konec převodu znak 0x00. Takže pokud převádí hodnotu 1234, tak zapíše 5 znaků do pole text - a to '1' '2' '3' '4' a 0x00.

Na konec textu je vždy zapsán terminační znak 0x00. Na pozici (index) kam je 0x00 do pole text[] zapsána, ukazuje číslo v sys[98] - snadno lze tak navázat další text od této pozice. Vždy využívejte údaje ze sys[98], nespoléhejte se na vlastní odhad délky zapsaného textu.



itoh()

itoh()
převod číselné proměnné na text (do pole text[]) - výstup v hex (šestnáctková soustava)

Tato funkce je dostupná teprve pro SDS-C č. 08 a novější.

Funkce převede hodnotu ve vybrané proměnné, do textového formátu (hex) - zapíše text na určené místu v poli text[] (včetně zakočení znakem 0x00).

 var i;
 
 // vstupní číselná hodnota  
 i = 1234;
 
 // převod obsahu "i" na řetězec do pole text na pozici [32], textový výstup zarovnat zleva nulami na čtyři místa
 itoh(i, 32, 4);
 
 echo(text[32]); // vypíše text: 04D2
 
 // nebo také takto
 itoh(1234, 32, 4);
 
 // nebo také takto
 var pozice;
 pozice = 32;
 itoh(1234, pozice, 4);
 

Význam parametrů funkce:

 itoh(proměnná_k_převodu, počáteční_index_do_pole_text, celkové_zarovnání_zleva);

Funkce itoh() zapisuje na konec převodu znak 0x00. Takže pokud převádí hodnotu 1234 se zarovnáním výstupu 4, tak zapíše 5 znaků do pole text - a to '0' '4' 'D' '2' a 0x00.

Pokud bude potřebný zápis delší než je hodnota celkové_zarovnání_zleva, tak bude text zapsán celý (jinak řečeno: nebude ořezán). Hodnota celkové_zarovnání_zleva tedy určuje požadovanou minimální délku (a do té se zarovnává zleva znakem '0'), nikoliv omezení na maximální délku. Především u záporných čísel se může snadno stát, že bude zapsáno rovnou osm znaků (plus navíc terminační 0x00, takže devět).

Na konec textu je vždy zapsán terminační znak 0x00. Na pozici (index) kam je 0x00 do pole text[] zapsána, ukazuje číslo v sys[98] - snadno lze tak navázat další text od této pozice. Vždy využívejte údaje ze sys[98], nespoléhejte se na vlastní odhad délky zapsaného textu.



sprintf()

sprintf()
zápis do pole text[]

Tato funkce je dostupná teprve pro SDS-C č. 06 a novější.

Funkce je určena pro vyplnění (zápis textu do) pole text[] od určeného indexu. Pole text[] se totiž dá ručně vyplňovat jen po jednotlivých položkách (jeden znak), takže když chcete zapsat delší text, je vhodné použít právé funkci sprintf().

Příklad:

 sprintf(text[0], 'Teplota je ', sys[310],' stupňů.');

Parametry se zadávají stejně jako u funkce echo().

Hodnota v sys[98] určuje, kde je poslední zapsaný znak (0x00) při posledním provedení funkce sprintf. Toho lze využít pro navázání více následných volání funkce sprintf pro zápis textů přesně za sebou, bez ohledu na různou délku těchto textů.

Příklad:

 var posledni_znak;
 sprintf(text[0], 'AbcdEfgh');
 // text[] = 'AbcdEfgh'0
 posledni_znak = sys[98];
 sprintf(text[posledni_znak], 'IjklMnop');
 // text[] = 'AbcdEfghIjklMnop'0



textcmp()

textcmp()
TBD

Tato funkce je dostupná teprve pro SDS-C č. 08 a novější.

Text TBD.

Příklad:

 // příklad: porovnej obsah text[] od indexu [0] s textem 'mac_tx_ok\r\n'
 textcmp(text[0], 'mac_tx_ok\r\n');
 
 // zobraz výsledek porovnání
 echo(sys[98]); 

Hodnota v sys[98] určuje výsledek porovnání. Pozor, sys[98] je sdílená pozice pro více různých funkcí.



snmp_send_trap()

snmp_send_trap()
odeslání SNMP v1 TRAP zprávy

Tato funkce je dostupná teprve pro SDS-C č. 06 a novější (a to konkrétně ve firmware od 2013 včetně a novější).

Funkce odešle jeden SNMP v1 TRAP na určenou IP adresu (na výchozím SNMP TRAP portu). Obsah TRAP zprávy se definuje pomocí zadaných parametrů při zavolání této funkce.

Parametry funkce:

 snmp_send_trap(ip[0],ip[1],ip[2],ip[3], PDUspecificValue, TableIndex);
  • IPadresa = adresa stroje na kterém je spuštěn SNMP TRAP přijímač (cílové zařízení)
  • PDUspecificValue = číselná hodnota určující konkrétní OID položku (podle definice konkrétní TRAP zprávy) viz MIB soubor
  • TableIndex = pokud je konkrétní OID položka tabulky, vyplňte index (viz MIB), jinak je tato položka ignorována (dejte 0)

Pozn. při odeslání TRAPu je vždy použita hodnota enterprise 33283 (odpovídá výrobci zařízení SDS).

Poslat lze pouze ty TRAP zprávy, které dané zařízení podporuje - vždy jsou podporovány všechny SNMP zprávy z celého enterprise rozsahu zařízení. Vše co přečtete ze zařízení SDS pomocí SNMP WALK, a je prefixována 33283, lze poslat jako TRAP.

Konkrétní hodnoty PDUspecificValue viz MIB soubor pro příslušné zařízení.

Příklad zavolání funkce:

poslat_trap
{
 
proved_poslani:
 // pokusi se odeslat SNMP TRAP na host IP 10.22.31.47
 // PDUspecificValue je v tomto prikladu 100 (zalezi na specifikaci v SDS: coz je popsano MIB souboru)
 // pro konkretni promennou 1.3.6.1.4.1.33283.1.2.2.1 (typ INTEGER)
 // a protoze to neni tabulkova hodnota, je TableIndex nastaven na nulu
 //
 snmp_send_trap(10,22,31,47, 100, 0);
 
 // pockame na vysledek
cekej_na_odeslani:
 if (sys[96] == 1) goto cekej_na_odeslani;
 
 // test na stav
 if (sys[96] == 5)
 {
   // TRAP neni odeslan. Funkce odeslani TRAPu byla zavolana kdyz jeste probiha cinnost jine funkce...
   echo('TRAP neodeslan (neskoncila jina predchozi komunikace)');
   return;
 }
 
 // test jestli se to nepovedlo (TRAP nebyl odeslan) kvuli chybnemu zadani pri zavolani funkce
 if (sys[96] == 3) 
 {
   echo('TRAP neodeslan (chybne parametry).');
   return;
 }
 
 // test jestli se to nepovedlo (TRAP nebyl odeslan) kvuli ARPu
 if (sys[96] == 4) 
 {
   echo('TRAP neodeslan (ARP), budu opakovat.');
 
   // nepovedlo, chvili pockame
   wait(100);
   // a zkusime to znovu
   goto proved_poslani;
 }
 
 // jen pro informaci:
 if (sys[96] == 2)
 {
    echo('TRAP odeslan uspesne.');
 }
 
} 

Více informací o SNMP viz příslušná stránka na této WiKi.

Po zavolání této funkce se zařízení SDS pokusí okamžitě odeslat SNMP TRAP paket na cílové zařízení. Pokud ještě nebyl proveden ARP překlad IP adresy, není TRAP zpráva odeslána, a SDS-C aplikace je o tom informována hodnotou v sys[96]. Je povinností aplikace hlídat tuto hodnotu po každém zavolání funkce a podle to se zařídit (např. snažit se TRAP zprávu znovu odeslat).

Pro popis hodnot sys[96] se podívejte sem.



send_udp()

send_udp()
odeslání UDP paketu

Tato funkce je dostupná teprve pro SDS-C č. 06 a novější (tj. firmware od 22.8.2012 včetně a novější).

Funkce odešle jeden UDP paket na určenou IP adresu a určený port. Obsah paketu jsou data v poli text[]. Typické použití je: pravidelný přenos údajů z SDS do centrálního serveru, nebo přenost textu do syslog serveru.

 send_udp(ip[0],ip[1],ip[2],ip[3], udp_port, text_start_index, data_length);
 send_udp(192,168,1,100,1234,0,64);

Pokud není známa MAC adresa příslušející ke zvolené IP adrese, je namísto UDP paketu odeslán ARP dotaz. Proto je nutné vždy po odeslání UDP paketu funkcí send_udp() zkontrolovat, zda-li skutečně došlo k odeslání paketu, nebo zda-li byl namísto toho odeslán ARP dotazový paket. To platí pro všechny možné IP adresy, i ty, které nejsou v místní síti, do které spadá zařízení SDS. Proto vždy kontrolujte výsledek a v případě odeslání ARP dotazu ručně opakujte odeslání UDP paketu tak dlouho, dokud se to zdárně nepodaří.

Informaci o stavu odesílání UDP naleznete v sys[95].

Po každém zavolání funkce send_udp() dojde k nastavení sys[95], a program SDS-C pokračuje v činnosti - odeslání UDP paketu se provede "na pozadí", ale bez zdržení. Pokud však dojde k potřebě poslat ARP dotaz, je tento dotaz ihned odeslán a to opět bez blokování další činnosti SDS-C programu.

Jakmile je úspěšně odeslán UDP paket, nebo jakmile je úspěšně odeslán ARP dotaz, tak je hodnota sys[95] nastavena na 2 respektive 3. Váš program to musí pohlídat a nesmí funkci send_udp() zavolat znovu dříve, než je sys[95] nastaveno na 0 resp. 2 resp. 3.

V případě že sys[95] je nastaveno na 5, zadali jste jeden nebo více neplatných parametrů při zavolání této funkce. Volání můžete ihned opakovat (ale použijte správné parametry, jinak to bude opět přerušeno s chybou 5).

Data k odeslání musí být připravena v poli text[] (z jiného místa neumí tato funkce data převzít). Můžete určit, od kterého indexu pole text[] budou data převzata, a kolik položek (počet bajtů) z tohoto pole chcete odeslat.

Z pole text[] je vždy za všech okolností použit přesně ten počet bajtů, které určíte parametrem funkce send_udp() (pokud se však nenarazí na skutečný konec pole daný jeho celkovou velikostí). Na rozdíl od ostatních funkcí, které využívají pole text[] a které se "zastaví" jakmile narazí na hodnotu 0 v některém z položek tohoto pole, tak funkce send_udp() tuto hodnotu nesleduje a převezme ji do obsahu UDP paketu jako jakokoliv jinou hodnotu.

Využíváme pole text[] proto, že jeho jednotlivé položky jsou o velikosti 1 byte. To znamená, že každá položka pole text[] představuje jeden bajt v odeslaném UDP paketu.

 
odesli_paket
{
opakovat_odesilani:
 
  // požádat o okamžité odeslání UDP paketu na IP: 192.168.1.100 port 1234
  // s obsahem v poli text[] od indexu [0] o délce 64 bajtů
  send_udp(192,168,1,100, 1234, 0,64);
 
  // počkáme až se to dokončí (odešle se paket)
cekej_na_provedeni:
 
  // ještě pracuje ?
  if (sys[95] == 1) 
   goto cekej_na_provedeni; 
 
  // teď: co se skutečně provedlo ?
 
  if (sys[95] == 2) 
  {
    // byl odeslán UDP paket, takže jsme hotovi
    return; 
  }
 
  if (sys[95] == 3)
  {  
    // místo UDP paketu byl odeslán ARP dotaz
    // takže chvíli počkáme, ať nezahltíme síť opakování ARP dotazů 
    // (obvykle to chvíli trvá, než přijde ARP odpověď, 
    // takže počkáme např. 250msec - toto si upravte dle potřeby)
    wait(250);
 
    // tím, že se místo našeho požadovaného UDP paketu
    // odeslal ARP paket, byl náš původní UDP paket zahozen:
    // takže ho musíme nechat poslat znovu (dokola dokud se to nepovede)
    // pozn. tady by bylo dobré dát počítadlo a pokud se to nepovede
    // vícekrát, tak ohlásit selhání a skončit, jinak se program odsud nikdy nedostane
    goto opakovat_odesilani;
  }
 
  if (sys[95] == 4)
  {
    // funkce send_udp() byla zavolána dříve než bylo dokončeno
    // provádění předchozího požadovaného požadavku
 
    // obsluhu této situaci si musíte vyřešit dle svého úkolu
 
    // typické řešení by bylo počkat (chvíli, 250 msec například)
    // a pak provést: goto opakovat_odesilani; 
 
    // my v tomto příkladu opustíme tuto funkci (tj. naše selhání)
    return;
  }
 
  if (sys[95] == 5)
  {
    // funkce zavolána s neplatným parametrem (nebo více parametry)
 
    // tento příklad nic takového neřeší, 
    // takže jdeme z této funkce pryč.
    return;
  }
 
  // pokud se dostaneme sem, tak je v sys[95] neznámá hodnota
  echo('sys[95] == neznámá hodnota'); 
}

Poznámka: dokud není úspěšně odeslán UDP paket (tj. dokud sys[95] není 2), nesmíte změnit tu část obsahu pole text[], která se má odeslat jako obsah UDP paketu. Pokud to změníte, dříve než se provede skutečné odeslání, tak se samozřejmě i změní obsah co bude UDP paket obsahovat, což může vést k nečekaným a obtížně zjistitelným problémům.

Poznámka: zadání IP adresy jako 255.255.255.255 do funkce send_udp() způsobí, že MAC adresa odeslaného UDP paketu bude nastavena na FF:FF:FF:FF:FF:FF. Toto má využití pro rozesílání broadcast UDP paketů v segmentu místní sítě. Využijete to například pro odeslání Wake-On-LAN over UDP paketu.



onewire_rescan()

onewire_rescan()
provede rescan 1-W sběrnice

Tato funkce je dostupná teprve pro firmware (SDS-C) od 28.12.2013 včetně a novější.

Parametry funkce:

 onewire_rescan(busID, familyID);
  • busID = číslo sběrnice: 0 == A, 16 == B
  • familyID = jaký 1-W chip je hledán (budou zpracovány jen chipy s odpovídajícím Family Code byte)

Tato funkce umožňuje provést okamžitý rescan 1-W sběrnice (sběrnice A nebo B, podle busID). Tento rescan ale vždy ignoruje všechny teploměrné 1-W chipy (teplotní čidla na 1-W sběrnici).

1-W sběrnice umožňuje připojení více než jednoho 1-W chipu. Může to být kombinace různých chipů (teplotní čidla, a další).

Zařízení SDS striktně odděluje funkčnost pro teplotní čidla a ostatní chipy. Teplotní čidla jsou automaticky zpracovávány vlastním firmware zařízení SDS, a SDS-C program má přímo přístup k jednotlivým změřeným teplotám ze všech čidel, aniž by musel nějak ovládat komunikaci po 1-W sběrnici s teplotními čidly.

Ostatní 1-W chipy ("ne-teploměrné" chipy) jsou dostupné pouze přímo z SDS-C programu, který si musí 1-W sběrnici ovládnout sám. V tuto chvíli poskytuje SDS-C pouze jedinou funkci s tímto účelem, a to onewire_rescan().

Tato funkce nemá jakýkoliv vliv na činnost firmware SDS, který se stará o teplotní čidla připojené na 1-W sběrnici. Pokud dojde k smíchání teplotních čidel a ostatních chipů na stejné sběrnici, pak firmware SDS bude neustále dokola číst hodnoty z jednotlivých teplotních čidel, a SDS-C program toto může pouze dočasně pozastavit, zavoláním funkce onewire_rescan(). Jakmile je rescan proveden, firmware SDS si 1-W sběrnici zase zpátky převezme (pokud jsou na 1-W sběrnici připojena teplotní čidla).


Typické použití funkce onewire_rescan() je detekce připojení (přiložení) přístupového chipu DS1990A. Pravidelným opakování volání rescan funkce lze detekovat, zda-li uživatel přiložil identifikační chip ke čtecí hlavici (zda-li připojil DS1990A na 1-W sběrnici).

Jednotlivé 1-W chipy se rozlišují pomocí hodnoty Family Code byte: pro chip DS1990A je to hodnota 0x01, hodnoty pro jiné chipy viz datasheet výrobce pro konkrétní chip.

Výstupem onewire_rescan() je nastavení hodnot do několika sys[], viz zde.

Rescan 1-W sběrnice trvá určitou dobu (150 až 500 msec, podle počtu chipů na 1-W sběrnici). Pokud SDS-C program zavolá funkci onewire_rescan() dříve, než byl předchozí rescan dokončen, bude toto volání funkce ignorováno (viz sys[940], sys[941]).

Spuštění rescanu a výsledek rescanu je k dispozici po každou sběrnici samostatně. Výsledkem je ROM-CODE nalezeného chipu (pokud je nalezen chip s odpovídajícím Family Code byte) a časová značka, kdy přesně byl tento chip na 1-W sběrnici nalezen.

Časová značka je hodnota sys[3] v okamžiku, kdy byl chip nalezen, popřípadě je nastavena na nulu, pokud nebyl nalezen.

Příklad: hledání DS1990A na sběrnici B:

 onewire_rescan(16, 0x01);



sdsc_reset_program()

sdsc_reset_program(key)
provede okamžité znovuspuštění (restart) SDS-C programu

Tato funkce je dostupná teprve pro SDS-C č. 08 a novější.

Výsledek zavolání této funkce je identický tomu, co se stane když se provedou všechny instrukce ve funkci main(). Aktuální program SDS-C se spustí znovu od začátku (funkce main).

Vzor: okamžité znovuspuštění SDS-C programu.

 // 
 sdsc_reset_program(1);  // reset programu se provede jen a pouze, pokud je parametr == 1
 
 // nebo takto:
 
 var k;
 k = 1234;
 sdsc_reset_program(k); // protoze "k" neni 1, program bude pokracovat (nestane se restart programu)
 
 k = 1;
 sdsc_reset_program(k); // a ted uz se program spusti odznova, protoze klic je 1 



sdsc_set_wdg()

sdsc_set_wdg(timeout_in_sec)
aktivování hlídače činnosti SDS-C programu

Tato funkce je dostupná teprve pro SDS-C č. 08 a novější.

Po zavolání této funkce se aktivuje činnost watchdog pro samotný SDS-C program. Jednou zapnutý watchdog nelze vypnout jinak než nahráním jiného programu nebo vypnutím zařízení SDS.

Watchdog funguje na principu požadavku na pravidelné hlášení o činnosti - funkce sdsc_kick_wdg() - a toto hlášení musí přijít dříve, než uplyne nastavená doba (timeout_in_sec).

Pokud v daném časovém okně není provedeno hlášení, a tedy tento časový odpočet dojde až na konec (na nulu), zařízení SDS provede nové spuštění SDS-C programu.

Funkce hlídání SDS-C (watchdog SDS-C programu) může mít celou řadu využití, obecně je vhodný dodatečný bezpečnostní prvek, zamezující zablokování SDS-C programu nastane-li jeho zablokování (např. pokud je v programu chyba, nevhodná smyčka, nebo snad program čeká na nějaký vstup).

Využití watchdogu si musí každý programátor SDS-C nalézt sám, nicméně je obecně doporučeno jej použít (čistě z důvodu ošetření možných chybových stavů samotného vašeho SDS-C programu).

Zařízení SDS má svůj vlastní hardwarový watchdog, který nemá s tímto dodatečným programovým watchdogem cokoliv společného - obojí jsou nezávislé systémy, a jejich výstup má nezávislý dopad. Z hlediska SDS-C máte možnost ovlivnit nastavení pouze programového watchdogu pro samotný SDS-C program.



sdsc_kick_wdg()

sdsc_kick_wdg(key)
obnovení odpočtu hlídače SDS-C programu

Tato funkce je dostupná teprve pro SDS-C č. 08 a novější.

Je-li aktivován hlídač SDS-C programu (funkcí sdsc_set_wdg), musí SDS-C program stihnout informovat systém o tom, že "žije". To se provádí voláním funkce sdsc_kick_wdg(), a toto volání se musí stihnout dříve než vyprší časový úsek nastavený při spuštění watchdogu (viz parametr funkce sdsc_set_wdg).

Po zavolání sdsc_kick_wdg() se hlídací odpočet nastaví na plnou délku, a opět se začne zkracovat.

Dokud tedy SDS-C program provádí opakované volání funkce sdsc_kick_wdg(), a stíhá to vždy v době kratší než je délka odpočtu, tak nedojde k aktivaci watchdogu.

Pokud to nestihne, dojde tedy k doběhu odpočtu do nulové polohy, a systém provede restart SDS-C programu (zbytek SDS pokračuje bez zásahu, dojde jen k ukončení a ihned ke znovuspuštění SDS-C programu).

Vzor: celý WDG

 // start programu
 sdsc_set_wdg(10);  // spustit SDSC-WDG a nastavit odpočet na 10 sec
 
 // a pak v průběhu programu
 
hlavnismycka:
 
 // ...
 
 sdsc_kick_wdg(10); // klíč je stejná hodnota jako timeout_in_sec
 
 // ...
 
 goto hlavnismycka;

Parametr key musí odpovídat hodnotě původně zapsané do timeout_in_sec (parametr volání funkce sdsc_set_wdg). Pokud to nebude stejné, nedojde k očekávané akci (znovunastavení odpočítávání na plnou hodnotu) a eventuálně dojde k aktivaci watchdogu.



Konec stránky.

konec stránky

Osobní nástroje
Translate