FULL-C: set and get: detailed

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

FULL-C: SET + GET

Tato stránka poskytuje detailní popis pro SDS_get_xXX() a SDS_set_xXX() funkce, pro všechny použitelné indexy.

Základní indexy

[0] firmware PAIRCODE

• READ-ONLY
• Použití je k rozlišení typu SDS modulu

 unsigned int PAIRCODE;
 PAIRCODE = SDS_get_u32(0);
 printf("Identifikace firmware v SDS je 0x%08X.", PAIRCODE);

[1] počet přihlášených uživatelů do web admin

• READ-ONLY

 unsigned int LoggedInUsers;
 LoggedInUsers = SDS_get_u32(1);
 printf("Na SDS web admin je (%u) přihlášených uživatelů.", LoggedInUsers);

[2] unikátní ID pro SDS (sériové číslo)

• READ-ONLY
• Hodnota je napevno z výroby a nelze změnit, je to vhodné pro jednoznačnou identifikace každého kusu SDS

 unsigned int SDS_UID;
 SDS_UID = SDS_get_u32(2);
 printf("SDS ID: %u", SDS_UID);

[2] sysLocation

• READ-ONLY
• Text je využit v SNMP, a zobrazován na webové administraci SDS

 char sysLoc[32];
 SDS_get_a(2, (void *)sysLoc, 32);
 printf("Nastavená system location: %s", sysLoc);

[3] "UpTime-10", jednotka 10msec (počet 10msec kroků od zapnutí SDS)

• READ-ONLY
• SDS zvyšuje tuto hodnotu "Uptime-10" o jedničku každých 10msec, trvale od zapnutí SDS

 unsigned int upTime;
 upTime = SDS_get_u32(3);
 upTime = upTime * 10; // prevod na msecs
 printf("SDS je aktivní %u msecs.", upTime);

[4] Lokální Čas

• READ-ONLY
• Lokální Čas je upravená hodnota času získána z NTP serveru - úprava spočívá v aplikaci uživatelského offsetu (viz index [26]) a také v aplikaci DST posunu času (letní čas)
• Zde je to uvedeno jako počet sekund od určeného základního bodu (viz "epoch time" pro vysvětlení)

 unsigned int local_time;
 local_time = SDS_get_u32(4);
 printf("Aktuální lokální čas je %u (secs).", local_time);

[5], [6], [7], [8], [9], [10], [11] rozpad Lokáního Času

• READ-ONLY
• Toto jsou aktuální rozpadnuté hodnoty z indexu [4]

 unsigned int dt_Day, dt_Month, dt_Year, dt_Hour, dt_Minute, dt_Second, dt_DayInWeek;
 dt_Day    = SDS_get_u32(5);
 dt_Month  = SDS_get_u32(6);
 dt_Year   = SDS_get_u32(7);
 dt_Hour   = SDS_get_u32(8);
 dt_Minute = SDS_get_u32(9);
 dt_Second = SDS_get_u32(10);
 dt_DayInWeek = SDS_get_u32(11);
 printf("Právě bylo: %02u.%02u.%04u %02u:%02u:%02u \n", dt_Day, dt_Month, dt_Year, dt_Hour, dt_Minute, dt_Second);
 printf("Den v týdnu, tj. počet dní od neděle: %u \n", dt_DayInWeek);

[12] device IP address

• READ-ONLY
• Na této IP adrese je dostupné webové rozhraní SDS

 unsigned int hostIP;
 unsigned int hostIP_0, hostIP_1, hostIP_2, hostIP_3;
 hostIP = SDS_get_u32(12);
 //
 hostIP_0 = (hostIP    ) & 0xFF;
 hostIP_1 = (hostIP>>8 ) & 0xFF;
 hostIP_2 = (hostIP>>16) & 0xFF;
 hostIP_3 = (hostIP>>24) & 0xFF;
 printf("Adresa SDS je %u.%u.%u.%u (0x%08x)", hostIP_0, hostIP_1, hostIP_2, hostIP_3, hostIP);

[16] gateway IP address

• READ-ONLY
• Tuto IP adresu používá SDS jako bránu (pro komunikaci mimo určenou lokální síť - tj. mimo subnet)

 unsigned int gatewayIP;
 hostIP = SDS_get_u32(16);
 printf("Adresa routeru je (0x%08x)", gatewayIP);

[20] subnet network mask

• READ-ONLY
• Síťová Maska určuje lokální síť (subnet)

 unsigned int netmask;
 netmask = SDS_get_u32(20);
 printf("Sitova maska subnetu je (0x%08x)", netmask);

[24] Ethernet Link Status

• READ-ONLY
• Stav připojení ethernetu (konektor na modulu SDS)

 unsigned int ethStatus;
 ethStatus = SDS_get_u32(24);
 if (0 == ethStatus)
 { printf("Ethernet neni aktivni (kabel/switch odpojen)."); } else
 { printf("Ethernet je aktivni, kabel a switch je pripojen."); };

[25] Ethernet Link Speed

• READ-ONLY
• Informace o rychlosti Ethernetové linky (rychlost domluvena s protistranou, např. switch)

 unsigned int ethLinkSpeed;
 ethStatus = SDS_get_u32(25);
 printf("Ethernet slinkovan na: %u MBit per second.", ethStatus);

[26] NTP GMT offset (-11 .. 11) = hodinový offset mezi UTC a LOCAL

• READ+WRITE
• Vždy nastavitelné z webové administrace SDS (změny provedené v administraci se ukládají do pevné paměti a vydrží restart SDS)
• Program může nastavení změnit zápisem do tohoto indexu, ale nikdy zde nedojde k uložení do pevné paměti (pozor!)
• Hodnota je aplikována na surový čas získaný z NTP serveru, a aplikací tedy vznikne Lokální Čas (např. pro ČR zde platí hodnota 1)

 int NTPoffset;
 NTPoffset = SDS_get_i32(26);
 printf("Aplikovany offset mezi UTC a LocalTime je: %d hod.", NTPoffset);

 // ukazka nastaveni (neni ulozeno do pevne pameti, po resetu se pouzije posledni udaj z web adminu)
 SDS_set_i32(26, 2); // nastavi offset na +2

[27] platnost přidělené IP adresy

• READ-ONLY
• Informace od DHCP serveru (používá-li SDS adresu přidělenou od DHCP)
• Jak dlouhu je ještě IP adresa, přidělená SDS, platná a SDS ji tedy může použít

 unsigned int isIPassigned;
 isIPassigned = SDS_get_u32(27);
 if (0 == isIPassigned)
 { printf("SDS nema pridelenou platnou IP adresu."); } else
 { printf("SDS ma platnou IP adresu."); };

[28] poslední okamžik kdy byla IP změněna

• READ-ONLY
• Změna může být od DHCP serveru (přidělil jinou adresu) nebo ručně od uživatele (ve webové administraci)

 unsigned int timestampOfIPchange;
 timestampOfIPchange = SDS_get_u32(28);
 printf("Posledni zmena IP adresy byla v %u milisekunde od zapnuti SDS.", timestampOfIPchange);

[29] stav DHCP

• READ-ONLY
• Pouze je-li DHCP klient v SDS aktivní (tedy není-li použita statická IP adresa pro SDS).

 unsigned int DHCPstate;
 DHCPstate = SDS_get_u32(29);
 switch (DHCPstate)
 {
   case  0: printf("IDLE"); break;
   case  1: printf("DISCOVERY sent"); break;
   case  2: printf("waiting for OFFER"); break;
   case  3: printf("REQUEST sent"); break;
   case  4: printf("waiting for ACK"); break;
   case  5: printf("BOUND - got the IP assigned"); break;
   case  6: printf("RENEW sent"); break;
   case  7: printf("waiting for ACK"); break;
   case  8: printf("RENEW sent again"); break;
   case  9: printf("waiting for ACK"); break;
   case 10: printf("RENEW sent again"); break;
   case 11: printf("waiting for ACK"); break;
 }

[30] aktualni hodnota "DHCP Lease Time"

• READ-ONLY
• Pouze je-li použito DHCP

 unsigned int DHCPleaseTime;
 DHCPleaseTime = SDS_get_u32(30);
 printf("DHCP lease time je %u seconds", DHCPleaseTime);

[31], [32], [33], [34], [35], [36] MAC[0-5] (odpověď je v dolních 8 bitech)

• READ-ONLY
• MAC je nastavena uživatelem ve webové administraci SDS
• MAC identifikuje SDS modul na Ethernetovém rozhraní

 unsigned int MAC[6];
 MAC[0] = SDS_get_u32(31);
 MAC[1] = SDS_get_u32(32);
 MAC[2] = SDS_get_u32(33);
 MAC[3] = SDS_get_u32(34);
 MAC[4] = SDS_get_u32(35);
 MAC[5] = SDS_get_u32(36);
 printf("MAC adresa SDS je %02X:%02X:%02X:%02X:%02X:%02X", MAC[0], MAC[1], MAC[2], MAC[3], MAC[4], MAC[5]);

[40] SoC power-up or Reset Reason

• READ-ONLY
• Informace, o tom, co způsobilo reset zařízení SDS (např. výpadek napájení)

 unsigned int SoCresetReason;
 SoCresetReason = SDS_get_u32(40);
 printf("SoC reset reason(s): ");
 if (SoCresetReason & 128) { printf("Low Power Reset"); };
 if (SoCresetReason & 64) { printf("W-Watchdog Reset"); };
 if (SoCresetReason & 32) { printf("I-Watchdog Reset"); };
 if (SoCresetReason & 16) { printf("Software Induced Reset"); };
 if (SoCresetReason & 8) { printf("Power-On Reset"); };
 if (SoCresetReason & 4) { printf("Hardware Induced Reset (RST pin)"); };
 if (SoCresetReason & 2) { printf("Brown-Out Event Reset"); };
 printf("\n");

[41] OEM branding (your text shown on 'SDS login' web page)

• READ+WRITE
• Váš vlastní text zobrazený na přihlašovací stránce (a dalších místech)

 char oemLWP[32];
 SDS_get_a(41, (void *)oemLWP, 32);
 printf("Uživatelský OEM text: %s", oemLWP);

 char oemLWP[32];
 unsigned int length;
 length = snprintf((char *)oemLWP, 32, "We do like this SDS !");
 SDS_set_a(41, (void *)oemLWP, length);

[42] OEM branding (your text shown on 'SDS welcome' web page)

• READ+WRITE
• Váš vlastní text zobrazený na uvítací stránce po přihlášení (a dalších místech)

 char oemWWP[128];
 SDS_get_a(42, (void *)oemWWP, 128);
 printf("Uživatelský OEM text: %s", oemWWP);

 char oemWWP[128];
 unsigned int length;
 length = snprintf((char *)oemWWP, 128, "For more details, go to our web there and there.");
 SDS_set_a(42, (void *)oemWWP, length);

[43] NTP-server IP address

• READ-ONLY
• IP adresa NTP serveru, ze kterého SDS získává surový čas

 unsigned int NTPip;
 NTPip = SDS_get_u32(43);
 printf("Adresa NTP serveru je (0x%08x)", NTPip);

[44] stav NTP-client

• READ-ONLY
• Informace o tom, zda-li se povedno z NTP serveru získat platný časový údaj

 unsigned int NTPStatus;
 NTPStatus = SDS_get_u32(44);
 if (NTPStatus == 0)
 { printf("NTP neni synchronizovano."); } else
 { printf("Cas z NTP serveru prijat a je pouzit."); };

[45] "UpTime-1", jednotka 1 msec (počítáno od startu zařízení)

• READ-ONLY
• SDS od svého zapnutí zvýší hodnotu "UpTime-1" o 1 za každou milisekundu
• Po napočítání 32bitů (unsigned) se počítá opět od nuly

 unsigned int msecUpTime;
 msecUpTime = SDS_get_u32(45);
 printf("Od startu SDS uplynulo %u milisekund", msecUpTime);

[46] teplota SoC: surová hodnota, a hodnota v degC

• READ-ONLY
• Jsou zde dva způsoby získání údaje - get u32 nebo i32
• Teplota jádra hlavního procesoru uvnitř modulu SDS
• Kalibrováno při výrobě (kalibrační tabulka je aplikována na hodnotu dostupnou přes get i32)
• (nekalibrovaná) surová hodnota je k dispozici už pouze z důvodů zpětné kompatibility (pro starší FC programy)

 unsigned int SoCtemp_RAW;
 signed int SoCtemp_degC_calibrated;
 float SoCtemp_RAW_to_degC_uncalibrated;
 //
 SoCtempRAW = SDS_get_u32(46); // cteni u32 vraci surovou hodnotu
 SoCtemp_RAW_to_degC_uncalibrated = ((((SoCtempRAW/4096.0)*3.3)-0.76)/0.0025)+25; // prevod RAW na degC pro konkretni SDS (BIG+STSW), bez aplikovane kalibrace
 printf("Teplota jadra SoC, prepoctena z RAW hodnoty (= %u), je %0.2f deg Celsius", SoCtemp_RAW, SoCtemp_RAW_to_degC_uncalibrated );
 //
 SoCtemp_degC_calibrated = SDS_get_i32(46); // cteni i32 vraci prepoctenou hodnotu, ktera je upravena vuci vyrobni kalibraci
 printf("Teplota jadra SoC, kalibrovana ve vyrobe, je %d deg Celsius", SoCtemp_degC_calibrated );

[61] random number

• READ-ONLY
• Generátor náhodných čísel, využívá náhodu vytvořenou v hardware (šum, měřená napětí, silikonový generátor v SoC, atd.)

 // tento priklad vypise deset nahodnych cisel do konzole
 unsigned int i, randNum;
 for (i = 0; i < 10; i++)
 {
   randNum = SDS_get_u32(61);
   printf("Dalsi nahodne cislo: %u", randNum);
 }

[64] časový odpočítávač

• READ-WRITE
• Určeno pro generování asynchronního odpočtu času (nastavíte hodnotu, a ta se co 1 sekundu sníží o 1, až narazí na nulu a tam zůstane - do příštího nastavení)

 // nastav hodnotu do indexu 64
 SDS_set_u32(64, 100);

 // kazdou sekundu provede SDS snizeni teto hodnoty o 1
 unsigned int time64;
 time64 = SDS_get_u32(64); 
 while (time64 != 0)
 {
   time64 = SDS_get_u32(64); 
   printf("postupny odpocet ma hodnotu: %u \n", time64);
 }
 // hodnota se zastavi na 0 a tam zustane az do dalsiho nastaveni (set)

[65] stav DST automatiky

• READ-ONLY
• DST automatika - provádí úpravu Lokálního Času s ohledem na Letní/Zimní Čas

 unsigned int DSTstate;
 DSTstate = SDS_get_u32(65); 
 if (DSTstate == 0) { printf("DST automatika neni aktivni"); } else
 if (DSTstate == 1) { printf("DST automatika je aktivni, a DST posun je aplikovan"); } else
 if (DSTstate == 2) { printf("DST automatika je aktivni, a DST posun neni aplikovan"); } else
 { printf("neznama hodnota"); };

[85] rozlišení BIG/STSW modulu

• READ-ONLY
• Využijte této informace pro rozlišení, jedná-li se o hardware SDS BIG nebo SDS STSW (či odvozené moduly).

 unsigned int Is_SDS_BIG;
 Is_SDS_BIG = SDS_get_u32(85);
 if (0 == Is_SDS_BIG)
 { printf("Device is based on SDS-STSW module."); } else
 { printf("Device is based on SDS-BIG."); };

[86] stav FULL-C programu

• READ-ONLY
• this will most likely be used by remote access (via S-UDP) than by the FULL-C program itself...

 unsigned int FULLC_Status;
 FULLC_Status = SDS_get_u32(86);
 //
 // FULLC_Status ==  0 -> status: Unknown
 // FULLC_Status ==  1 -> status: No Program Exists
 // FULLC_Status ==  2 -> status: Stopped (done or err)
 // FULLC_Status ==  4 -> status: Erasing (new program to come)
 // FULLC_Status ==  8 -> status: Uploading
 // FULLC_Status == 16 -> status: Upload Done (but not running yet)
 // FULLC_Status == 32 -> status: Paused
 // FULLC_Status == 64 -> status: Running (all OK)

[87] unikátní ID nahraného FC programu

• READ-ONLY
• Každý váš FULLC program má přiřazeno unikátní ID, kterým můžete program jednoznačně identifikovat

 unsigned int FULLC_program_ID;
 FULLC_program_ID = SDS_get_u32(87);

[89] IP-WatchDog: stav

• READ-ONLY

 unsigned int IPWstatus;
 IPWstatus = SDS_get_u32(89);
 if (IPWstatus == 0)
 { printf("IP Watchdog je vypnuty."); } else
 { printf("IP Watchdog je aktivni."); };

[90] IP-WatchDog: poslední známé RTT

• READ-ONLY

 unsigned int IPWlastKnownRTT;
 IPWlastKnownRTT = SDS_get_u32(90);
 if (0xFFFF == IPWlastKnownRTT)
  { printf("RTT neni zmereno (zrejme stale nebyla obdrzena odpoved)"); } else
  { printf("Posledni zname RTT je %u milisekund", IPWlastKnownRTT);

[91] IP-WatchDog: stav výstupu

• READ-ONLY

 unsigned int IPWoutputStatus;
 IPWoutputStatus = SDS_get_u32(91);
 if (0 == IPWoutputStatus)
 { printf("Vystup IP-W je v klidu."); } else
 { printf("Vystup IP-W je aktivovan (alarm)."); };

[139] NTP true raw epoch-time (secs since Linux Epoch) (clear UTC with *no* GMT or DST offset applied)

• READ-ONLY
• Surová hodnota (v sekundách od epoch) tak jak byla přímo získána z NTP serveru

 unsigned int NTPrawUTC;
 NTPrawUTC = SDS_get_u32(139);
 printf("Surova hodnota ziskana z NTP serveru je : %u secs", NTPrawUTC);

[140] proměnná pro speciální TRAP (401)

• READ+WRITE
• Nastavení hodnoty předané v SNMP TRAP zprávě (samotné odeslání zprávy se provádí specifickou FC funkcí, zde jen nastavujete obsah)

 unsigned int TRAP401value;
 TRAP401value = SDS_get_u32(140);
 printf("Hodnota predana pri dotazu na TRAP-401 je %d", TRAP401value);

 SDS_set_u32(140, 123456); // tento priklad nastavi hodnotu pro TRAP-401 na 123456

[141] proměnná pro speciální TRAP (402)

• READ+WRITE

 char TRAP402value[32];
 SDS_get_a(141, (void *)TRAP402value, 32);
 printf("Hodnota predana pri dotazu na TRAP-402 je: %s", TRAP402value);

 char TRAP402value[32];
 unsigned int length;
 length = snprintf((char *)TRAP402value, 32, "Status:OK");
 SDS_set_a(141, (void *)TRAP402value, length);

[142] proměnná pro speciální TRAP (403)

• READ+WRITE
• stejný obecný postup jako pro index [140]

[143] proměnná pro speciální TRAP (404)

• READ+WRITE
• stejný obecný postup jako pro index [140]

[144] proměnná pro speciální TRAP (405)

• READ+WRITE
• stejný obecný postup jako pro index [140]

[145] proměnná pro speciální TRAP (406)

• READ+WRITE
• stejný obecný postup jako pro index [140]

Sdílené Proměnné - Řízení Přístupu

[150] blokování vzdáleného přístupu ke sdíleným proměnným

• READ+WRITE
• Viz dokumentace ke sdíleným proměnným

 unsigned int FC_SharedVals_AccessLock;
 FC_SharedVals_AccessLock = SDS_get_u32(150);
 if (0 == FC_SharedVals_AccessLock)
 { printf("Pristup ke sdilenym promennym je otevreny a neni blokovan"; } else
 { printf("Pristup ke sdilenym promennym je zabezpecen (nutnost prihlasit se)."); };

 SDS_set_u32(150, 0); // 0 = odemknuto

Digitální Vstupy

[151] - [182] OPTO1..OPTO32 status

• READ-ONLY
• Fyzický stav HW vstupu modulu SDS

 unsigned int OPTO_1_value;
 OPTO_1_value = SDS_get_u32(151);
 if (0 == OPTO_1_value) // ano, X == 0 je spravne ! (aktivni v nule)
 { printf("Vstup OPTO-1 je AKTIVNI (signal je pritomny)"); } else
 { printf("Vstup OPTO-1 je bez signalu (neaktivni)"); };

 unsigned int OPTOvalues[8];

 // zapise "8" pozic od indexu "151" do pole OPTOvalues - pozor na spravne vzajemne mapovani indexu !
 SDS_get_a(151, (void *)OPTOvalues, 8 * 4);

 // ted muzeme s polem OPTOvalues pracovat, napr. zjistit stav OPTO4 (ktere je v OPTOvalue[3] protoze OPTOvalue[0] je namapovano od 151, viz radek vyse)
 if (0 == OPTOvalue[3])
 { printf("Vstup OPTO-4 je AKTIVNI (signal je pritomny)"); } else
 { printf("Vstup OPTO-4 je bez signalu (neaktivni)"); };

Speciální Položky

[183] datum vydání FW v modulu SDS

• READ-ONLY
• Informace o verzi (datum vydání) firmware který je spuštěn v modulu SDS

 TBD

[184] způsob spuštění FULL-C programu

• READ-ONLY
• Jakým způsobem byl spuštěn tento běh FC programu - vhodné pro určení následné akce

 TBD

[185] hodnota odpočtu FULL-C WatchDogu v msec

• READ-ONLY
• Je-li aktivován hlídač běhu FC programu, pak je zde informace o jeho stavu (hodnota odpočtu)

 TBD

Digitální Výstupy

[191] hlavní frekvence PWM generátoru

• READ(+WRITE)

 unsigned int PWMgeneratorFreq;
 PWMgeneratorFreq = SDS_get_u32(191);
 printf("PWM generator pracuje na frekvenci %u Hz", PWMgeneratorFreq);

 // pro nastaveni, pouzijte funkci SDS_PWM_setDutyAsXXXX()

[192] PWM duty-cycle in percents

• READ(+WRITE)

 unsigned int PWMgeneratorDutyPerc;
 PWMgeneratorDutyPerc = SDS_get_u32(192);
 printf("PWM generator ma duty-cycle v %u %%", PWMgeneratorDutyPerc);

 // pro nastaveni, pouzijte funkci SDS_PWM_setDutyAsXXXX()

[193] PWM-HW: direct "pulse" register value

• READ-ONLY
• Přímý přístup k HW generátoru PWM výstupu (bez přepočtu jak to provádí jiné funkce)
• Musíte ale vědět co děláte

 unsigned int PWMgeneratorHWregValue;
 PWMgeneratorHWregValue = SDS_get_u32(193);
 printf("PWM generator CCR1-register value: %u", PWMgeneratorHWregValue);

[196] - [228] RELAY1..RELAY32 - určení kontroly nad reléovým výstupem

• READ+WRITE

 unsigned int RELAY_1_cby;
 RELAY_1_cby = SDS_get_u32(196);
 switch (RELAY_1_cby)
 {
   case 0: printf("RELAY 1 is manually controlled (via web admin) only"); break;
   case 2: printf("RELAY 1 is controlled by FULL-C program"); break;
   case 4: printf("RELAY 1 is controlled by SDS IP-Watchdog"); break;
 }

 unsigned int RELAYcbys[6];

 // zapise "6" pozic od indexu "196" do pole RELAYcbys - pozor na spravne vzajemne mapovani indexu !
 SDS_get_a(196, (void *)RELAYcbys, 6 * 4);

 // nastav RELE 3 pro ovladani pres FULL-C
 SDS_set_u32(198, 2);

[231] - [262] RELAY1..RELAY32 - finální fyzický stav výstupu

• READ+WRITE

 unsigned int RELAY_1_state;
 RELAY_1_state = SDS_get_u32(231);
 if (0 == RELAY_1_state)
 { printf("RELE 1 je VYPNUTO"); } else
 { printf("RELE 1 je ZAPNUTO"); };

 unsigned int RELAYcbys[6];

 // (precte) zapise "6" pozic od indexu "231" do pole RELAYcbys - pozor na spravne vzajemne mapovani indexu !
 SDS_get_a(231, (void *)RELAYcbys, 6 * 4);

 // zapni RELE 3
 SDS_set_u(233, 0xFF);

[266] - [297] RELAY1..RELAY32 - název (text)

• READ-ONLY

 char RELAY_1_name[32];
 SDS_get_a(266, (void *)RELAYname, 32);
 printf("Nastaveny nazev RELE 1 je: %s", RELAY_1_name);

[301] stav (log0/log1) pinu GPIO-TOPBOARD

• READ+WRITE

 // TBD

 // TBD

[302] směr (vstup/výstup) pinu GPIO-TOPBOARD

• READ+WRITE

 // TBD

 // TBD

Analogové vstupy

[311] - [342] přepočtená hodnota (float) A/D vstupu

• READ-ONLY

 float AD_input_1__in_user_units;
 AD_input_1__in_user_units = SDS_get_f32(314); // viz mapovani jednotlivych indexu (311 = vstup mereni odporu)
 printf("Analog Input #1 value is %0.3f (units)", AD_input_1__in_user_units);

 float AD_input_values__in_user_units[8];

 // zapise "8" pozic od indexu "311" do pole
 SDS_get_a(311, (void *)AD_input_values__in_user_units, 8 * 4);

[343] - [374] jméno A/D vstupu (text)

• READ-ONLY

 char name[32];
 SDS_get_a(343, (void *)name, 32); // první index [343] je mapován na vstup měření odporu
 printf("Uživatelský název pro vstup měření odporu: %s", name);

[375] - [406] jednotka A/D vstupu (text)

• READ-ONLY

 char unit[32];
 SDS_get_a(375, (void *)unit, 32); // první index [375] je mapován na vstup měření odporu
 printf("Vstup měření odporu přepočítává výsledek na tyto jednotky: %s", unit);

[428] určený typ hardware - jaký OZ chip je použit v SDS

• READ-ONLY

 if (9 == SDS_get_u32(428))
 {
  printf("SDS používá LMV324 (a provádí korekci chyby tohoto OZ)");  
 } else
 {
  printf("SDS používá AD8630"); 
 }

[431] - [462] surová hodnota (raw) A/D vstupu

• READ-ONLY

 unsigned int AD_input_1__raw;
 AD_input_1__raw = SDS_get_u32(434); // viz mapovani jednotlivych indexu (431 = vstup mereni odporu)
 printf("Analog Input #1 value is %d (raw)", AD_input_1__raw);

 unsigned int AD_input_values__raw[8];

 // zapise "8" pozic od indexu "431" do pole
 SDS_get_a(431, (void *)AD_input_values__raw, 8 * 4);

S0 vstupy

[992] localtime timestamp - kdy bude nejbližší 23:59:59

• READ-ONLY

  printf("poslední sekunda tohoto dne bude ve timestamp %u" , SDS_get_u32(992));

[993] localtime timestamp - kdy začíná záznam pro včerejší den

• READ-ONLY

  printf("záznam pro včerejší den začal ve timestamp %u" , SDS_get_u32(993));

[994] localtime timestamp - kdy začíná záznam pro dnešní den

• READ-ONLY

  printf("záznam pro dnešní den začal ve timestamp %u" , SDS_get_u32(994));

[995] doba (sekundy) aktivity T0 vstupu, za minulý den

• READ-ONLY

  printf("tarif T0 byl za minulý den aktivní celkem %u sekund" , SDS_get_u32(995));

[996] doba (sekundy) aktivity T1 vstupu, za minulý den

• READ-ONLY

  printf("tarif T1 byl za minulý den aktivní celkem %u sekund" , SDS_get_u32(996));

[997] doba (sekundy) aktivity T0 vstupu, za dnešní den

• READ-ONLY

  printf("tarif T0 byl dnes aktivní celkem %u sekund" , SDS_get_u32(997));

[998] doba (sekundy) aktivity T1 vstupu, za dnešní den

• READ-ONLY

  printf("tarif T1 byl dnes aktivní celkem %u sekund" , SDS_get_u32(998));

[999] stav Tarifního Vstupu (T0 / T1)

• READ-WRITE
• Viz popis zpracování S0 vstupů

 unsigned int tariffStatus;
 tariffStatus = SDS_get_u32(99);
 if (0 == tariffStatus)
 { printf("S0 TARIF neni aktivni."); } else
 { printf("S0 TARIF je aktivni."); };

 // neaktivni
 SDS_set_u(99, 0);

 // aktivni
 SDS_set_u(99, 1);

[1000] - [1031] [S0-vstup] údaj počítadla pro T0

• READ+WRITE

 unsigned int S0input_counter_1_T0;
 S0input_counter_1_T0 = SDS_get_u32(1000);
 printf("S0 counter (input #1) (for T0) value is: %u", S0input_counter_1_T0);

 unsigned int S0input_counter_values_T0[9];

 // zapise "9" pozic od indexu "1000" do pole
 SDS_get_a(1000, (void *)S0input_counter_values_T0, 9 * 4);

 // zapis nove hodnoty (pozor, nezapisuje se do DF/NVM)
 SDS_set_u32(1000, 123456); // zapise hodnotu 123456 do pocitadla S0 vstupu cislo 1 (tarif T0)

[1032] - [1063] [S0-vstup] údaj počítadla pro T1

• READ+WRITE

 unsigned int S0input_counter_1_T1;
 S0input_counter_1_T1 = SDS_get_u32(1032);
 printf("S0 counter (input #1) (for T1) value is: %u", S0input_counter_1_T1);

 unsigned int S0input_counter_values_T1[9];

 // zapise "9" pozic od indexu "1032" do pole
 SDS_get_a(1032, (void *)S0input_counter_values_T1, 9 * 4);

 // zapis nove hodnoty (pozor, nezapisuje se do DF/NVM)
 SDS_set_u32(1032, 123456); // zapise hodnotu 123456 do pocitadla S0 vstupu cislo 1 (tarif T1)

[1064] - [1095] [S0-vstup] časová vzdálenost (msec) mezi posledním a předposledním impulsem

• READ-ONLY

 unsigned int S0input_1__msec_spacing;
 S0input_1__msec_spacing = SDS_get_u32(1064);
 printf("Distance between last two S0 impulses on input #1 is %u msec", S0input_1__msec_spacing);

 unsigned int S0input__msec_spacing[9];

 // zapise "9" pozic od indexu "1064" do pole
 SDS_get_a(1064, (void *)S0input__msec_spacing, 9 * 4);

[1096] - [1127] [S0-vstup] časová vzdálenost (msec) od úplně posledního zachyceného impulsu

• READ-ONLY

 unsigned int S0input_1__msec_since_last;
 S0input_1__msec_since_last = SDS_get_u32(1096);
 printf("Time since the last S0 impulse on input #1 is %u msec", S0input_1__msec_since_last);

 unsigned int S0input__msec_since_last[9];

 // zapise "9" pozic od indexu "1096" do pole
 SDS_get_a(1096, (void *)S0input__msec_since_last, 9 * 4);

[1500] - [1531] [S0-vstup] konfigurační struktura pro S0 vstup

• READ-ONLY

 // POZOR 
 //  FW od 26.1.2021 ma ve strukture pridane nove polozky (puvodni struktura NEZMENENA)

 struct S0_INPUT_CFG_t {

   // WEB-ADMIN CONFIG:
   unsigned long jednotka_ma_impulsu; // kolik impulsu na jednotku (vzdy cele cislo)

   // WEB-ADMIN CONFIG:
   unsigned long cena_za_jednotku_T0; // kolik CZK je za jednotku (pseudofloat, x*100 -> dve desetinna mista)
   unsigned long cena_za_jednotku_T1; // kolik CZK je za jednotku (pseudofloat, x*100 -> dve desetinna mista)

   // WEB-ADMIN CONFIG:
   char jednotka[32+1+3]; // popisek jednotky se vztahem k casu (napr. kWh - akumulovana energie)

   // WEB-ADMIN CONFIG:
   char penize_jednotka[32+1+3]; // popisek meny (CZK)

  // WEB-ADMIN CONFIG:
   char jednotka_vykon[32+1+3]; // popisek jednotky bez vztahu k casu (vykon kW, prutok l/h, . . . )

   // WEB-ADMIN CONFIG:
   char nazev_vykon[32+1+3]; // popisek nazvu cinnosti

   // WEB-ADMIN CONFIG:
   char nazev_merice[32+1+3]; // nazev merice energie (nazev vstupu)

   // WEB-ADMIN CONFIG:
   unsigned char je_to_S0_vstup; // je to pouzito?  0 == ne

   // WEB-ADMIN CONFIG:
   unsigned char pouzivam_tarifni_rozliseni; // ==0 : jedno pocitadlo T0, nebo != 0 : dve samostatne T0 a T1

   // nepouzito, ale reservovano
   unsigned char reserved_and_align[2];  
   unsigned char reserved_zeros[32+1+3];


   // WEB-ADMIN CONFIG:
   unsigned long prevodovy_pomer_mtd; // normovany prevodovy pomer x, kde jde o 1:x

   // WEB-ADMIN CONFIG:
   unsigned long minimalni_delka_impulsu; // miliseconds, default == 4

   // WEB-ADMIN CONFIG:
   unsigned short delka_zacatecniho_zakmitu; // v msec (pridano 26.1.2021)

   // WEB-ADMIN CONFIG:
   unsigned short delka_dokmitu; // v msec (pridano 26.1.2021)

 }; // PACKED

 struct S0_INPUT_CFG_t S0_INPUT_CFG;

 // vypln "S0_INPUT_CFG" hodnotami pro vstup #1 (index [1500])
 SDS_get_a(1500, (void *)&S0_INPUT_CFG, sizeof(S0_INPUT_CFG));
 // ted mame pristup ke vsem polozkam ve strukture, takze napriklad:
 printf("Name of the S0 input #1 is : %s", S0_INPUT_CFG.nazev_merice);
 
 // a ted vypln "S0_INPUT_CFG" hodnotami pro vstup #2 (index [1501])
 SDS_get_a(1501, (void *)&S0_INPUT_CFG, sizeof(S0_INPUT_CFG));
 printf("Prevodovy pomer MTD pro S0 vstup #2 je '1:%u' ", S0_INPUT_CFG.prevodovy_pomer_mtd);

1-Wire vstupy

Pokud vaše aplikace v SDS nevyužívá sběrnice 1-Wire, pak je žádoucí aby jste SDS o tom informovali tak, že na začátku vašeho FULL-C zavoláte (jednou) funkci: SDS_disable_onewire();.

Detaily ohledně 1-Wire v (SDS druhé produktové řady) jsou na tomto odkazu.

[2000] - [2063] 1-W BUS (A): device status

• READ-ONLY

 unsigned int index;
 unsigned int OW_busA_DevStatus;
 index = 0; // select first item in array
 OW_busA_DevStatus = SDS_get_u32(2000+index); // 2000 + index [0..63]
 // vyznam hodnot plne zavisi na typu (viz ROMcode) konkretniho vybraneho (index) zarizeni pripojeneho na sbernici
 printf("BUS-A: device #%u: detailed_status = %u \n", index, (OW_busA_DevStatus & 0xFF));
 printf("BUS-A: device #%u: work_status     = %u \n", index, ((OW_busA_DevStatus >> 8) & 0xFF));
 if (OW_busA_DevStatus & 0x10000)
 {
   printf("BUS-A: device #%u: position locked \n");
 };

[2100] - [2163] 1-W BUS (A): konfigurační struktura

• READ-ONLY

 // typova definice struktury (FULL-C: automaticky jako 'packed' aneb 1B-align)
 // velikost OW_DEVICE_CFG_t je presne 25 bajtu - lze pouzit 'sizeof' pro overeni
 struct OW_DEVICE_CFG_t {

   // ROM code (as detected / read from 1-W device)
   unsigned char ROMcode[8];

   // user-assigned 1-W device name
   unsigned char DeviceName[16+1]; // SDS fills the first 16 chars [0..15], the trailing zero is the [16]

 };

 unsigned int index;
 struct OW_DEVICE_CFG_t OW_DEVICE_CFG;
 //
 index = 1; // select second item (1) in array (0=first, 1=second, ...)
 //
 SDS_get_a(2100+index, (void *)&OW_DEVICE_CFG, 8+16+1 ); // 2100 + index [0..63]
 //
 printf("BUS-A: device #%u: ROM-CODE = %02X %02X %02X %02X %02X %02X %02X %02X \n", index,
        OW_DEVICE_CFG.ROMcode[0], OW_DEVICE_CFG.ROMcode[1], OW_DEVICE_CFG.ROMcode[2], OW_DEVICE_CFG.ROMcode[3],
        OW_DEVICE_CFG.ROMcode[4], OW_DEVICE_CFG.ROMcode[5], OW_DEVICE_CFG.ROMcode[6], OW_DEVICE_CFG.ROMcode[7]);
 printf("BUS-A: device #%u: name     = %s \n", index, OW_DEVICE_CFG.DeviceName);

[2200] - [2263] 1-W BUS (A): přečtená hodnota (základní)

• READ-ONLY

 int OW_DEVICE_first_value;
 OW_DEVICE_first_value = SDS_get_i32(2200); // 2200 + index [0..63]
 printf("Ziskana (hlavni) hodnota ze 1-W zarizeni na BUS-A je: %d \n", OW_DEVICE_first_value);

[2300] - [2363] 1-W BUS (A): přečtená hodnota (doplňková)

• READ-ONLY

 int OW_DEVICE_second_value;
 OW_DEVICE_second_value = SDS_get_i32(2300); // 2300 + index [0..63]
 printf("Ziskana (sekundarni) hodnota ze 1-W zarizeni na BUS-A je: %d \n", OW_DEVICE_second_value);

[2500] - [2563] 1-W BUS (B): device status

• READ-ONLY

 // stejne jako pro BUS-A, jen zakladni offset je 2500

[2600] - [2663] 1-W BUS (B): konfigurační struktura

• READ-ONLY

 // stejne jako pro BUS-A, jen zakladni offset je 2600

[2700] - [2763] 1-W BUS (B): přečtená hodnota (základní)

• READ-ONLY

 // stejne jako pro BUS-A, jen zakladni offset je 2700

[2800] - [2863] 1-W BUS (B): přečtená hodnota (doplňková)

• READ-ONLY

 // stejne jako pro BUS-A, jen zakladni offset je 2800

[2998] general 1-W Master Chip status

• READ-ONLY

 unsigned int SDS_OW_MASTER_status;
 SDS_OW_MASTER_status = SDS_get_u32(2998);
 switch (SDS_OW_MASTER_status)
 {
   case  0: printf("UNKNOWN STATUS"); break;
   case  1: printf("PREPARING TO START FOR THE VERY FIRST TIME"); break;
   case  2: printf("START FAILED - WILL TRY AGAIN"); break; // pozn. pred dalsim startem probiha odpocet, viz polozka [2999]
   case  4: printf("START HAS FULLY FAILED - no more attempts to try"); break;
   case  8: printf("RUNNING - ALL OK"); break;
   case 16: printf("1-W FULLY DISABLED (by user)"); break;
 }

[2999] general 1-W Master Chip status: detection-retry countdown (*10msec)

• READ-ONLY

 unsigned int SDS_OW_MASTER_restart_countdown;
 SDS_OW_MASTER_restart_countdown = SDS_get_u32(2999);
 // toto ma vyznam pouze pokud hodnota [2998] == 2
 printf("SDS 1-W MASTER odpocet do noveho pokusu o start sbernice: %u msec \n", SDS_OW_MASTER_restart_countdown*10);

Vlastní Textové OID položky pro SNMP

[3001] - [3005] custom string (readable via SNMP .8.80 - .8.84)

• READ-WRITE
• Text (omezená velikost), který lze kdykoliv přečíst ze SDS modulu prostřednictvím SNMP dotazu (na konkrétní OID)

 TBD

Stav Napájení SDS

[3800] PVD Active - main power failure detected

• READ-ONLY
• Informace o zjištěném blížícím se úplném výpadku napájení pro SDS modul.
• Jakmile se výpadek blíží, dává SDS krátkou šanci pro FC program aby se správně zařídil (např. uzavřel otevřené soubory, vypnul relé, atd.)
• Typicky následuje vypnutí nebo reset SDS modulu (detekujeme výpadek při poklesu napájecího napětí na takovou úroveň, že to už jinak ani nemůže skončit, ale dáváme šanci se ještě chvíli správně zařídít)

 TBD

[3801] PVD Was Active - this flag is only cleared by reading this index 3801

• READ-ONLY
• Pokud byl detekován bližící se výpadek (tj. index [3800] byl aktivní), tak je nastaven i tento údaj - a zůstane nastaven, až do okamžiku jeho přečtení (teprve tím se nuluje)

 TBD

SD Karta

Viz stránka s popisem FULL-C: SD card.

Sdílené Proměnné

Viz stránka s popisem FULL-C: sharing.

Zálohovaná Paměť BkpRAM

TBD

MQTT

Viz stránka s popisem MQTT.

MODBUS-TCP

Viz stránka s popisem MODBUS-TCP.