Kiwiki - Príspevky používateľa [sk]

Hlavná stránka

2024-10-03T19:29:11Z

Juraj:

<div id="mainpage_topbox" style="margin:0px">
<div id="mainpage_pagetitle" style="text-align:center">Kiwiki - informácie nakope</div>
<div id="mainpage_sitelinks">
[[File:studentskePrace.jpg|link=Študentské práce]] [[File:PodkladyKvyucbe.jpg|link=Podklady k prednáškam a cvičeniam]] [[File:Projekty.jpg|link=Projekty]]
</div>
</div>
<div class="mainpage_hubtitle" style="background-color:#FE9A2E">'''Pomôžte rozšíriť kiwiki'''</div>
<div class="mainpage_boxcontents" style="padding:0px 20px; border:1px solid gray">
{| style="border:1px; margin:0px;vertical-align:top" width="100%" cellspacing="10"
|-
|
"Predstavte si svet, v ktorom môže každý človek slobodone zdieľať všetky vedomosti" (slogan Wikimedia foundation). Predstav si tú množinu vedomostí, do ktorých môžeš prispieť aj Ty!

'''Mysli slobodne - buď open source.'''

Zverejni svoju záverečnú prácu na portáli kiwiki.info. Prečo?
* Aby si ju mohli prečítať tí, ktorí sa o danú problematiku zaujímajú.
* Pretože Tvoja záverečná práca je dobrá na to, aby bola zamknutá v univerzitnom archíve.
* Ak boli ľubovolné informácie z webu kiwiki.info užitočné pri štúdiu, tak rozšír množinu týchto informácií.
Viac informácií o podmienkach zverejnenia na stránke [[Študentské práce]].

Kontaktujte ma: [[Redaktor:Juraj]]
|

|}

</div>
{| style="border:1px; margin:0px;vertical-align:top" width="100%" cellspacing="10"
|-
|class="mainpage_hubbox" valign="top"|
<div class="mainpage_hubtitle">'''Čo je kiwiki'''</div>
<div style="padding:5px" itemscope itemtype="http://schema.org/CreativeWork">
<span itemprop="name">Kiwiki</span> je <span itemprop="alternativeHeadline">otvorená a slobodná wiki</span> obsahujúca <span itemprop="about" itemscope itemtype="http://schema.org/Thing"><span itemprop="name">študentské práce</span> a <span itemprop="name">výučbové materiály</span> a rôzne <span itemprop="name">projekty</span>. Na kiwiki zú zverejnené:</span>
* <span itemprop="description">záverečné práce</span> (bakalárske, ročníkové, diplomové).
* <span itemprop="description">študijné materiály</span> pre predmety vyučované na technických fakultách.
* zaujímavé <span itemprop="description">projekty</span>.
</div>
|class="mainpage_hubbox" valign="top" style="width:30%"|
<div class="mainpage_hubtitle" >'''Ako sme veľkí'''</div>
<div class="mainpage_boxcontents">
Táto wiki má už
*{{NUMBEROFPAGES}} stránok, z toho je
**{{NUMBEROFARTICLES}} článkov
**{{NUMBEROFFILES}} nahratých súborov
*{{NUMBEROFUSERS}} redaktorov.
</div>

|class="mainpage_hubbox" valign="top" style="width:35%"|
<div class="mainpage_hubtitle" >'''Repozitár zdrojových kódov'''</div>
{|
| [[File:gitlab.png|150px|link=https://gitlab.nsoric.com/mtf]]
|
* Zdrojové kódy z riešení bakalárskych a diplomových prác
* https://nsoric.mtf.stuba.sk
|}
|}

I2C - základné použitie pre STM32

2023-03-25T20:45:00Z

Juraj:

{{MCU_ARM_Obsah_vpravo}}
__TOC__

Rozhranie I2C obsahuje každý mikrokontrolér rodiny STM32. Zvyčajne sú k dispozícii minimálne 2 nezávislá rozhrania.

==Základná konfigurácia rozhrania I2C==
Po vytvorení projektu v STM32CubeMX alebo STM32IDE je potrebné si aktivovať rozranie: v časti "Pinout & Configuration" si v vyberieme rozhranie I2C. V konfiguračnej časti sa zobrazí voľba pre výber typu zbernice; vyberieme "I2C"

[[Súbor:I2c stm32 config.png|600px|Aktivácia rozhrania I2C]]

Aktivácia rozhrania I2C

V pravej časti sa zobrazia piny MCU, ktoré majú priradenú funkciu liniek SDA a SCL.

===Konfigurácia I2C rozhrania===

[[Súbor:I2c stm32 parameters.png|600px|Parametre rozhrania I2C]]

====Nastavenie parametrov I2C rozhrania====
Význam jednotlivých nastavení:
; Custom timing : Dovoľuje nastaviť si vlastné parametre generovania časového signálu. Odporúča sa ponechať prednastavenú hodnotu ''Disabled''. {{default|Disabled}}
; I2C Speed Mode: Voľba režimu časovania. V zozname sú len tie režimy, ktoré vybratý MCU podporuje.
* Standard Mode
* Fast Mode
* Fast Mode Plus
; I2C Speed Frequency: hodnota taktovacej frekvencie pre vybraný režim. Táto hodnota sa automaticky nastaví na maximálnu povolenú hodnotu pre vybraný režim.
; Rise Time / Fall Time: manuálna modifikácia parametrov pre CLK. Detaily o výpočte týchto časov sú [https://fastbitlab.com/i2c-rise-time-calculation tu].
; Analog Filter : Ak sú na zbernici I2C nežiaduce rušenia signálu (pochádzajúce zo zlého návrhu dosky plošného spoje, aplikácie na riadenie motora, ...), môžete použiť digitálne a analógové filtre šumu, ktoré sú k dispozícii medzi logikou GPIO a registrami I2C. Analógový filter je implementovaný v súlade so špecifikáciou I2C, ktorá vyžaduje potlačenie špičiek so šírkou impulzu do 50 ns. Digitálny filter umožňuje potlačiť špičky s programovateľnou dĺžkou 1 až 15 periód I2CCLK. Podrobnosti o nízkoúrovňovom nastavení časovania je v dokumete AN4235<ref>Application Note 4235 - https://www.st.com/resource/en/application_note/an4235-i2c-timing-configuration-tool-for-stm32f3xxxx-and-stm32f0xxxx-microcontrollers-stmicroelectronics.pdf</ref>

Vlastnosti v režime slave zbernice I2C:
; Clock No Stretch Mode: vypne možnosť pozdržania hodinového signálu. {{default|Disabled}}
* Po rozpoznaní zodpovedajúcej adresy I2C s požiadavkou na čítanie MCU okamžite odošle obsah registra I2C_TXDR (dátový register I2C).
* Softvér na MCU musí zabezpečiť, aby vysielací register (I2C_TXDR) vždy obsahoval platné údaje.
* Subsystém I2C bude automaticky potvrdzovať všetky udalosti čítania a zápisu z nadradenej jednotky<ref>https://drolliblog.wordpress.com/2017/11/04/stm32l031x6-slave-transmitter-and-receiver/</ref>.
; General Call Address Detection: V režime Slave je rozhranie schopné rozpoznať svoje vlastné adresy (7 alebo 10-bitové) a všeobecnú adresu volania. Rozpoznávanie adresy všeobecného volania je možné zapnúť alebo vypnúť touto voľbou.
; Primary Address Length Selection: Dĺžka adresy usla slave. {{default|7bit}}
; Dual Address Acknowledgement: Režim, kedy má uzol slave 2 adresy. {{default|Disabled}}
; Primary Slave Address: Adresa uzla slave (režim slave)

====Nastavenie NVIC====
* I2Cx event interrupt
* I2Cx error interrupt

====Nastavenie DMA====
Dovoľuje pridať 2 požiadavky na DMA prenos:
* I2Cx_RX - z periférie do pamäte
* I2Cx_TX - z pamäte do periférie

==Práca s rozhraním I2C v programovom kóde==
Základná kostra vygenerovaného programu v prostredí STM32CubeMX/STM32IDE:
<source lang="c" line>
#include "main.h"

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);

int main(void)
{
HAL_Init();
SystemClock_Config();

MX_GPIO_Init();
MX_I2C1_Init();

while (1)
{
}
}

static void MX_I2C1_Init(void)
{
hi2c1.Instance = I2C1;
hi2c1.Init.Timing = 0x00000E14;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
}

/** Configure Analogue filter */
if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
{
Error_Handler();
}

/** Configure Digital filter */
if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
{
Error_Handler();
}
}
</source>

Vygenerovaná funkcia `MX_I2C1_Init()` sa stará o správne nastavenie parametrov podľa grafického konfigurátora v predchádzajúcom kroku. Po zbernici I2C môžeme komunikovať až po úspešnom ukončení funkcie `MX_I2C1_Init()`.

===Funkcie pre I2C komunikáciu===

Existujú dva spôsoby prenosu:
; Režim blokovania : Komunikácia prebieha v režime dotazovania. Stav spracovania všetkých údajov sa vracia tou istou funkciou po ukončení prenosu.
; Režim bez blokovania : Komunikácia sa vykonáva pomocou prerušenia alebo DMA. Tieto funkcie vracajú stav spustenia prenosu. Ukončenie spracovania údajov bude indikované prostredníctvom vyhradeného IRQ I2C pri použití režimu prerušenia alebo IRQ DMA pri použití režimu DMA.

{| class="wikitable"
|-
! Funkcie v blokujúcom režime
! Funkcie v neblokujúcom režime s prerušením
! Funkcie v neblokujúcom režime s DMA
|-
|
* HAL_I2C_Master_Transmit()
* HAL_I2C_Master_Receive()
* HAL_I2C_Slave_Transmit()
* HAL_I2C_Slave_Receive()
* HAL_I2C_Mem_Write()
* HAL_I2C_Mem_Read()
* HAL_I2C_IsDeviceReady()
|
* HAL_I2C_Master_Transmit_IT()
* HAL_I2C_Master_Receive_IT()
* HAL_I2C_Slave_Transmit_IT()
* HAL_I2C_Slave_Receive_IT()
* HAL_I2C_Mem_Write_IT()
* HAL_I2C_Mem_Read_IT()
* HAL_I2C_Master_Seq_Transmit_IT()
* HAL_I2C_Master_Seq_Receive_IT()
* HAL_I2C_Slave_Seq_Transmit_IT()
* HAL_I2C_Slave_Seq_Receive_IT()
* HAL_I2C_EnableListen_IT()
* HAL_I2C_DisableListen_IT()
* HAL_I2C_Master_Abort_IT()
|
* HAL_I2C_Master_Transmit_DMA()
* HAL_I2C_Master_Receive_DMA()
* HAL_I2C_Slave_Transmit_DMA()
* HAL_I2C_Slave_Receive_DMA()
* HAL_I2C_Mem_Write_DMA()
* HAL_I2C_Mem_Read_DMA()
* HAL_I2C_Master_Seq_Transmit_DMA()
* HAL_I2C_Master_Seq_Receive_DMA()
* HAL_I2C_Slave_Seq_Transmit_DMA()
* HAL_I2C_Slave_Seq_Receive_DMA()
|}

Zoznam funkcií spätného volania pre neblokujúce režimy:
* HAL_I2C_MasterTxCpltCallback()
* HAL_I2C_MasterRxCpltCallback()
* HAL_I2C_SlaveTxCpltCallback()
* HAL_I2C_SlaveRxCpltCallback()
* HAL_I2C_MemTxCpltCallback()
* HAL_I2C_MemRxCpltCallback()
* HAL_I2C_AddrCallback()
* HAL_I2C_ListenCpltCallback()
* HAL_I2C_ErrorCallback()
* HAL_I2C_AbortCpltCallback()

====HAL_I2C_Master_Transmit====
V režime Master odošle údaje ''pData'' v blokujúcom režime
<source lang="c">
HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
</source>
* hi2c - Pointer na štruktúru I2C_HandleTypeDef - nakonfigurované rozhranie I2C
* DevAddress - adresa cieľového zariadenia slave. 7 bitová adresa slave zariadenia uvedená v datasheete musí byť posunutá o 1 bit vľavo.
* pData - Pointer na odosielané dáta
* Size - počet bajtov, ktoré sa budú odosielať.
* Timeout - časový limit pre odoslanie. Uvádza sa v milisekundách. Po uplynutí tohto času sa odosielanie ukončí a funkcia vráti chybový kód.

====HAL_I2C_Master_Receive====
V režime Master prijme požadovaný počet bajtov v blokujúcom režime
<source lang="c">
HAL_StatusTypeDef HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
</source>
* hi2c - Pointer na štruktúru I2C_HandleTypeDef - nakonfigurované rozhranie I2C
* DevAddress - adresa cieľového zariadenia slave. 7 bitová adresa slave zariadenia uvedená v datasheete musí byť posunutá o 1 bit vľavo.
* pData - Pointer na buffer, kde budú prijaté dáta uložené
* Size - počet bajtov, ktoré sa budú prijímať.
* Timeout - časový limit pre príjem. Uvádza sa v milisekundách. Po uplynutí tohto času sa príjem ukončí a funkcia vráti chybový kód.

====HAL_I2C_Master_Transmit_IT / HAL_I2C_Master_Transmit_DMA====
V režime Master odošle údaje ''pData'' v neblokujúcom režime s prerušením / s DMA
<source lang="c">
HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_I2C_Master_Receive_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size);
</source>
Význam parametrov je rovnaký ako v prípade HAL_I2C_Master_Transmit. Chýba parameter ''Timeout''. Po ukončení odosielania sa spustí ISR ''I2C1_EV_IRQHandler'' (definovaný v súbore stm32NNxxx_it). Ten zabezpečí zavolanie funkcie spätného volania:

<source lang="c">
void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c)
{
// tento kod sa vykona po ukonceni odoslania cez I2C
}
</source>

Túto funkciu je potrebné si implemetovať v kóde aplikácie. Jej definícia sa nachádza v súbore stm32NNXXxx_hal_i2c.c

====HAL_I2C_Master_Receive_IT / HAL_I2C_Master_Receive_DMA====
V režime Master prijme údaje v neblokujúcom režime s prerušením / s DMA
<source lang="c">
HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
HAL_StatusTypeDef HAL_I2C_Master_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
</source>
Význam parametrov je rovnaký ako v prípade HAL_I2C_Master_Receive. Chýba parameter ''Timeout''. Po ukončení odosielania sa spustí ISR ''I2C1_EV_IRQHandler'' (definovaný v súbore stm32NNxxx_it). Ten zabezpečí zavolanie funkcie spätného volania:

<source lang="c">
void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)
{
// tento kod sa vykona po ukonceni odoslania cez I2C
}
</source>

Túto funkciu je potrebné si implemetovať v kóde aplikácie. Jej definícia sa nachádza v súbore stm32NNXXxx_hal_i2c.c

====HAL_I2C_Mem_Write / HAL_I2C_Mem_Write====
V režime Master zapíše údaje ''pData'' na požadovanú adresu v uzle slave. Komunikácia je v blokujúcom režime.

<source lang="c">
HAL_StatusTypeDef HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout);
HAL_StatusTypeDef HAL_I2C_Mem_Read(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout);
</source>
* hi2c - Pointer na štruktúru I2C_HandleTypeDef - nakonfigurované rozhranie I2C
* DevAddress - adresa cieľového zariadenia slave. 7 bitová adresa slave zariadenia uvedená v datasheete musí byť posunutá o 1 bit vľavo.
* MemAddress - adresa v pamäti komunikujúcej stranu - uzla slave
* MemAddSize - počet bajtov, ktoré sa majú zapísať/prečítať.
* pData - Pointer na odosielané/prijímané dáta
* Size - počet bajtov, ktoré sa budú odosielať/prijímať.
* Timeout - časový limit pre odoslanie. Uvádza sa v milisekundách. Po uplynutí tohto času sa odosielanie ukončí a funkcia vráti chybový kód.

==Zdroje a odkazy==
<references/>

GNU/GPL/KI

2023-03-25T19:40:11Z

Juraj:

=Licencia GNU/GPL pre študijné materiály KI=
*Tento dokument slúži ako študijný materiál.
*Tento dokument je možné volne šírit pod licenciou ’GNU General Public Licence’ za podmienok uvedených v tejto licencii a s uvedením zdroja pôvodu:
**kiwiki - otvorená wiki s výukovými materiálmi a študentskými prácami
**http://www.kiwiki.info
*Pri citovaní častí z tohoto dokumentu je nevyhnutné rešpektovat články 4 a 5 licencie GPL.
*Použitie dokumentu je na vlastné riziko. Tvorcovia dokumentu venovali maximálnu pozornosť tomu, aby bol tento dokument bez vecných a formálnych chýb, absolútnu bezchybnosť nemôžu ale zaručiť. Prípadné následky omylov a chýb v dokumente Vás neoprávňujú k náhrade škody, najmä nie sú dôvodom k zmene Vášho hodnotenia študijných výsledkov.
*Slovesnké znenie licencie GNU/GPL je dostupné na adrese http://www.gpl.sk/v1
[[Kategória:kiwiki]]

Šablóna:Default

2023-03-25T19:32:07Z

Juraj: Vytvorená stránka „<span style="background-color:rgb(230,220,215)">Default: {{{1}}}</span>“

<span style="background-color:rgb(230,220,215)">Default: {{{1}}}</span>

I2C - základné použitie pre STM32

2023-03-25T14:46:25Z

Juraj: Vytvorená stránka „{{MCU_ARM_Obsah_vpravo}} __TOC__ Rozhranie I2C obsahuje každý mikrokontrolér rodiny STM32. Zvyčajne sú k dispozícii minimálne 2 nezávislá rozhrania. ==Zákla…“

Súbor:I2c stm32 config.png

2023-03-25T14:45:32Z

Juraj:

Súbor:I2c stm32 parameters.png

2023-03-25T14:44:27Z

Juraj:

Mikrokontroléry ARM

2023-03-25T14:20:12Z

Juraj:

== Obsah ==
{{MCU ARM Obsah}}

Komunikačné rozhranie I2C

2023-03-25T14:19:34Z

Juraj:

{{MCU_ARM_Obsah_vpravo}}
__TOC__

Inter-Integrated Circuit alebo I²C je dvojvodičová obojsmerná zbernica vyvinutá firmou Philips začiatkom 90-tych rokov 20. storočia, používaná predovšetkým na prepojenie periférnych zariadení s mikrokontrolérom. Na zbernicu sú pripojené zariadenia rozdelené na riadiace (Master - zahajuje a ukončuje komunikáciu; generuje hodinový signál SCL) a riadené (Slave - zariadenie adresované Masterom) <ref name="upythonUcebnica">Gabriel Gašpar a Juraj Ďuďák. Využitie mikrokontrolérov v automatizovanom riadení. Spektrum, 2023. ISBN: 978-80-227-5283-1.</ref> na Obr. 1 <ref name="bpmn">Matúš Nečas: Multi-displej systém pre embedded aplikácie, Bakalárska práca, MTF STUBA, 2023</ref>

{| class="wikitable"
|-
| [[Súbor:Mcu_i2c_1_pripojenie.png|600px|Obr. 1a. Pripojenie zaradení na zbernicu]]
| [[Súbor:Mcu_i2c_1_schematic.jpg|600px|Obr. 1b. Interné zapojenie]]
|}

Obr. 1 A)Pripojenie zaradení na zbernicu, B) Interná schéma zapojenia rozhrania I2C<ref name="sparkfun">https://learn.sparkfun.com/tutorials/i2c/all</ref>

SDA (Serial Data) je dátový signál a SCL (Serial Clock) je hodinový signál. Hodinový signál je vždy generovaný aktuálnym radičom zbernice; niektoré periférne zariadenia môžu niekedy vynútiť nízku hodnotu hodinového signálu, aby radič oneskoril odoslanie ďalších údajov (alebo aby potreboval viac času na prípravu údajov pred pokusom radiča o ich taktovanie). Tento postup sa nazýva "natiahnutie hodín" (clock stretching).

'''Terminologická poznámka''': Označenie master/slave môže byť nahradené označním controller/peripheral.

I2C umožňuje prepojenie až 128 rôznych zariadení s pomocou iba dvoch obojsmerných vodičov. Jeden tvoria hodinový signál SCL (Synchronous Clock) a druhý dátový kanál SDA (Synchronous Data). Maximálna dĺžka vodičov je daná ich najvyššou povolenou kapacitou 400 pF, všeobecne sa uvádza cca 10cm. Každý vodič musí byť pripojený jedným pull-up rezistorom ku kladnému napätiu, čo zaistí vysokú úroveň v pokojovom stave. Pri prebiehajúcom prenose sú na SDA vysielané jednotlivé dátové bity pričom platí pravidlo, že logická úroveň na SDA sa môže nastaviť len ak je SCL v úrovni L. Toto pravidlo je porušené v dvoch špeciálnych prípadoch, a to pri vysielaní podmienok START a STOP, ktoré sa používajú na začatie komunikácie a k ukončeniu prenosu.
Maximálna frekvencia signálu SCL je podľa verzie I2C 100 kHz alebo 400 kHz. Pre obe frekvencie je daná minimálna povolená doba zotrvania SCL v úrovni L a H. Pri komunikácii aj pri prenose dát si jednotlivé stanice synchronizujú generátory hodín tak, že trvanie úrovne H na SCL je odmeriavané vnútorným časovačom každej stanice až od okamihu, keď SCL skutočne úrovne H dosiahne (pretože je SCL typu otvorený kolektor, môže byť v úrovni L držaný aj v situácii kedy sa daná stanica snaží nastaviť úroveň H). Podobne je doba trvania úrovne L na SCL odmeriavaná od zostupnej hrany. Tento mechanizmus umožňuje pre niektoré zo staníc spomaliť prenos: pomalá stanica môže podržať po určitú dobu signál SCL v úrovni L a tým zabrániť vysielajúcej stanici vo vyslaní ďalšieho bitu. Zbernica I2C neumožňuje duplexný prenos, v jednom okamihu vysiela len jedno zariadenie. Všetky zariadenia pripojené na zbernicu musia mať individuálnu adresu a implementovaný mechanizmus komunikácie pomocou I²C zbernice <ref name="upythonUcebnica"></ref><ref name="bpmn"></ref>.

==Princíp obojsmernej komunikácie<ref>Texas Instruments, Understanding the I2C Bus, Application Report SLVA704 - June 2015. https://www.ti.com/lit/slva704</ref>==
Otvorený kolektor označuje typ výstupu, ktorý môže stiahnuť napäťovú úroveň zbernica na nízku úroveň - teda log.0 (vo väčšine prípadov na zem), alebo "uvoľniť" zbernicu a nechať napätie aby pomocou pull-up rezistora stúplo na úroveň logicej.1. V prípade, že je zbernica uvoľnená uzlom master alebo slave, pripojený pull-up rezistor je zodpovedný za vytiahnutie zbernice na úroveň napájacieho napätia. Keďže žiadne zariadenie nesmie vynucovať vysokú úroveň napätie na linke (teda úroveň pre log.1), znamená to že na zbernici nikdy nedôjde ku komunikačnému problému, keď sa jedno zariadenie pokúsi pripojiť napätie pre úroveň log.1 a iné zariadenie stiahne zbernicu na úroveň log.0, čo by spôsobilo skrat (napájacie napätie na zem). I2C vyžaduje, aby v prípade že master v zapojení s viacerými mastermi vysiela a vidí, že linka je v úrovni log.0 (iné zariadenie ju ťahá nadol - teda iné zariadenie komunikuje), zastaví komunikáciu, pretože zbernicu používa iné zariadenie.

[[Súbor:Mcu_i2c_bidirCom.png|300px|Obr. 1x. Základná štruktúra linky SDA/SCL]]

Obr. 1x. Základná štruktúra linky SDA/SCL

Obr. 1x zobrazuje zjednodušenú schému vnútornej štruktúry master alebo slave zariadenia pre komunikačné linky SDA/SCL. Táto schéma obsahuje vyrovnávaciu pamät (buffer) na čítanie vstupných údajov a znižujúci (pull-down) tranzistor FET na prenos údajov. Zariadenie je schopné meniť napäťovú úroveň iba na log.0 (vytvoriť skrat na zem) alebo uvoľniť linku zbernice (vysoká impedancia voči zemi) a umožniť, aby pull-up rezistor zvýšil napätie. Toto je dôležitý koncept, ktorý si treba uvedomiť pri práci s I2C zariadeniami, pretože žiadne zariadenie nesmie zvyšovať úroveň napätia pre log.1. Táto vlastnosť umožňuje obojsmernú komunikáciu medzi uzlami master a slave.

==Protokol prenášaných údajov<ref name="bpmn"></ref>==

Údaje v rozhraní I2C sa prenášajú v tzv. správach. Každá správa je rozdelená do jednotlivých rámcov, a to: adresný rámec, ktorý identifikuje binárnu adresu Slave zariadenia a následne jeden alebo viacero dátových rámcov, ktoré obsahujú prenášaný obsah. Správy obsahujú aj bity pre čítanie/zápis, bity ACK/NACK a podmienky START a STOP (Obr. 2).

[[Súbor:MCU_I2C_Basic_Address_and_Data_Frames.jpg|1024px|Obr. 2. Štruktúra správy cez I2C rozhranie]]

Obr. 2. Štruktúra správy cez I2C rozhranie<ref name="sparkfun"></ref>

* '''START''' - podmienka štart signalizuje začiatok komunikácie. Linka SDA sa prepne z vysokej (log. 1) na nízku hodnotu (log. 0) ''skôr'', ako sa linka SCL prepne z vysokej na nízku hodnotu.
* '''ADDRESS''' - adresa Slave zariadenia, s ktorým chce Master komunikovať. Adresa predstavuje 7 alebo 10 bitové celé číslo v binárnom tvare, ktoré predstavuje jedinečný identifikátor každého Slave zariadenia. Dve zariadenia by nemali mať tú istú adresu v jednej I2C zbernici.
* '''RW''' - jeden bit, ktorý určuje či sa vykonáva operácia zápisu alebo čítania:
** Ak RW = 0, zápis údajov na Slave zariadenie.
** Ak RW = 1, čítanie údajov zo Slave zariadenia.
* '''ACK/NACK''' nasleduje za každým rámcom v správe. Je to bit potvrdenia/nepotvrdenia:
** Ak bol úspešne prijatý adresný alebo dátový rámec, prijímajúce zariadenie vráti odosielateľovi log. 0 (ACK - Acknowledged).
** Ak nastala chyba v prenose, prijímajúce zariadenie vráti odosielateľovi log. 1 (NACK - Not Acknowledged).
* Existuje niekoľko situácií, ktoré vedú k vytvoreniu NACK:
** Prijímač vykonáva nejakú funkciu v reálnom čase a nie je pripravený začať komunikáciu s Masterom.
** Prijímač odbrží neznáme údaje alebo príkazy.
** Počas prenosu prijímač nemôže prijímať ďalšie dátové bajty.
** Master ukončí čítanie údajov a oznámi to Slave zariadeniu pomocou NACK.

* '''DATA''' - Dátový rámec je vždy dlhý 8 bitov a posiela sa s najvýznamnejším bitom (MSB) ako prvým. Za každým dátovým rámcom bezprostredne nasleduje bit ACK/NACK na overenie, či bol rámec úspešne prijatý. Pred odoslaním ďalšieho dátového rámca musí bit ACK prijať buď master, alebo slave (v závislosti od toho, kto dáta odosiela).
* '''STOP''' - ukončovacia podmienka štart signalizuje koniec komunikácie. Linka SDA sa prepne z nízkej (log. 0) na vysokú hodnotu (log. 1) ''potom'', čo sa linka SCL prepne z nízkej úrovne na vysokú <ref>Scott Campbell. BASICS OF THE I2C COMMUNICATION PROTOCOL. https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/.</ref><ref>Sal Afzal. I2C Primer: What is I2C? (Part 1). https://www.analog.com/en/technical-articles/i2c-primer-what-is-i2c-part-1.html.</ref>.

Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní

===Dátový prenos na zbernici I2C<ref>https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/</ref>===
# Master vyšle štart podmienku každému pripojenému slave prepnutím linky SDA z úrovne vysokého napätia na úroveň nízkeho napätia pred prepnutím linky SCL z vysokej na nízku.
# Master posiela každému uzlu slave 7 alebo 10-bitovú adresu s ktorým chce komunikovať, spolu s bitom pre čítanie/zápis
# Každý slave porovnáva adresu odoslanú od mastera so svojou vlastnou adresou. Ak sa adresa zhoduje, podriadená jednotka vráti bit ACK tým, že potiahne linku SDA na jeden bit. Ak sa adresa od nadradeného zariadenia nezhoduje s vlastnou adresou podriadeného zariadenia, podriadené zariadenie ponechá linku SDA na úrovni log.1.
# Master odošle alebo prijme dátový rámec
# Po prenose každého dátového rámca prijímacie zariadenie vráti odosielateľovi ďalší bit ACK, aby potvrdilo úspešné prijatie rámca
# Ak chcete zastaviť prenos dát, master pošle podriadenému zariadeniu stop podmienku prepnutím SCL na vysokú hodnotu pred prepnutím SDA na vysokú hodnotu.

Na Obr.3 je vyobrazený časový diagram zápisu a čítania údajov s veľkosťou 2B prostredníctvom rozhrania I2C.

[[Súbor:MCU_I2C_3_casovyDiagram.png|600px|Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní]]

===Základné vlastnosti a parametre zbernice I2C===

Základná pracovná frekvencia linky je 100kHz. Špecifikácia I2C dovoľuje zvýšiť túto frekvenciu až na 3.4 MHz. Zvýšenie frekvencie na strane mikrokontroléra je záležitosť konfigurácie. Je potrebné zvoliť takú frekvenciu, ktorú podporuje pripojený senzor alebo zariadenie, s ktorým chceme komunikovať.

{| class="wikitable"
|-
! Časovanie !! SCL
|-
| Standard Mode || 100 kHz
|-
| Fast Mode || 400 kHz
|-
| Fast Mode Plus || 1 MHz
|-
| High Speed Mode || 3.4 MHz
|}

== Zdroje a odkazy ==
<references/>

Šablóna:MCU ARM Obsah vpravo

2023-03-25T14:19:22Z

Juraj: Vytvorená stránka „<div class="sideBox" style="width:250px;background-color:rgb(240,255,190);padding-left:5px;border:2px solid rgb(155,155,100)"> Mikrokontroléry ARM ---- {{MCU_ARM_Ob…“

Šablóna:MCU ARM Obsah

2023-03-25T14:19:16Z

Juraj:

{{vyuka_tema|Architektúra ARM mikrokotnrolérov|Základné nastavenie STM32 core}}
{{vyuka_tema|ARM - vstupno/výstupné piny|nieco o pinoch}}
{{vyuka_tema|Komunikačné rozhranie UART|UART - základné použitie pre STM32}}
{{vyuka_tema|Komunikačné rozhranie I2C|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}
{{vyuka_tema|Komunikačné rozhranie SPI|SPI - základné použitie pre STM32}}

[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Šablóna:MCU ARM Obsah

2023-03-25T14:14:31Z

Juraj:

<div class="sideBox" style="width:250px;background-color:rgb(240,255,190);padding-left:5px;border:2px solid rgb(155,155,100)">
[[Mikrokontroléry ARM]]
----
{{vyuka_tema|Architektúra ARM mikrokotnrolérov|Základné nastavenie STM32 core}}
{{vyuka_tema|ARM - vstupno/výstupné piny|nieco o pinoch}}
{{vyuka_tema|Komunikačné rozhranie UART|UART - základné použitie pre STM32}}
{{vyuka_tema|Komunikačné rozhranie I2C|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}
{{vyuka_tema|Komunikačné rozhranie SPI|SPI - základné použitie pre STM32}}
</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Komunikačné rozhranie I2C

2023-03-25T14:11:36Z

Juraj: Juraj premiestnil stránku MCU ARM/I2C na Komunikačné rozhranie I2C

{{MCU_ARM_Obsah}}
__TOC__

Inter-Integrated Circuit alebo I²C je dvojvodičová obojsmerná zbernica vyvinutá firmou Philips začiatkom 90-tych rokov 20. storočia, používaná predovšetkým na prepojenie periférnych zariadení s mikrokontrolérom. Na zbernicu sú pripojené zariadenia rozdelené na riadiace (Master - zahajuje a ukončuje komunikáciu; generuje hodinový signál SCL) a riadené (Slave - zariadenie adresované Masterom) <ref name="upythonUcebnica">Gabriel Gašpar a Juraj Ďuďák. Využitie mikrokontrolérov v automatizovanom riadení. Spektrum, 2023. ISBN: 978-80-227-5283-1.</ref> na Obr. 1 <ref name="bpmn">Matúš Nečas: Multi-displej systém pre embedded aplikácie, Bakalárska práca, MTF STUBA, 2023</ref>

{| class="wikitable"
|-
| [[Súbor:Mcu_i2c_1_pripojenie.png|600px|Obr. 1a. Pripojenie zaradení na zbernicu]]
| [[Súbor:Mcu_i2c_1_schematic.jpg|600px|Obr. 1b. Interné zapojenie]]
|}

Obr. 1 A)Pripojenie zaradení na zbernicu, B) Interná schéma zapojenia rozhrania I2C<ref name="sparkfun">https://learn.sparkfun.com/tutorials/i2c/all</ref>

SDA (Serial Data) je dátový signál a SCL (Serial Clock) je hodinový signál. Hodinový signál je vždy generovaný aktuálnym radičom zbernice; niektoré periférne zariadenia môžu niekedy vynútiť nízku hodnotu hodinového signálu, aby radič oneskoril odoslanie ďalších údajov (alebo aby potreboval viac času na prípravu údajov pred pokusom radiča o ich taktovanie). Tento postup sa nazýva "natiahnutie hodín" (clock stretching).

'''Terminologická poznámka''': Označenie master/slave môže byť nahradené označním controller/peripheral.

I2C umožňuje prepojenie až 128 rôznych zariadení s pomocou iba dvoch obojsmerných vodičov. Jeden tvoria hodinový signál SCL (Synchronous Clock) a druhý dátový kanál SDA (Synchronous Data). Maximálna dĺžka vodičov je daná ich najvyššou povolenou kapacitou 400 pF, všeobecne sa uvádza cca 10cm. Každý vodič musí byť pripojený jedným pull-up rezistorom ku kladnému napätiu, čo zaistí vysokú úroveň v pokojovom stave. Pri prebiehajúcom prenose sú na SDA vysielané jednotlivé dátové bity pričom platí pravidlo, že logická úroveň na SDA sa môže nastaviť len ak je SCL v úrovni L. Toto pravidlo je porušené v dvoch špeciálnych prípadoch, a to pri vysielaní podmienok START a STOP, ktoré sa používajú na začatie komunikácie a k ukončeniu prenosu.
Maximálna frekvencia signálu SCL je podľa verzie I2C 100 kHz alebo 400 kHz. Pre obe frekvencie je daná minimálna povolená doba zotrvania SCL v úrovni L a H. Pri komunikácii aj pri prenose dát si jednotlivé stanice synchronizujú generátory hodín tak, že trvanie úrovne H na SCL je odmeriavané vnútorným časovačom každej stanice až od okamihu, keď SCL skutočne úrovne H dosiahne (pretože je SCL typu otvorený kolektor, môže byť v úrovni L držaný aj v situácii kedy sa daná stanica snaží nastaviť úroveň H). Podobne je doba trvania úrovne L na SCL odmeriavaná od zostupnej hrany. Tento mechanizmus umožňuje pre niektoré zo staníc spomaliť prenos: pomalá stanica môže podržať po určitú dobu signál SCL v úrovni L a tým zabrániť vysielajúcej stanici vo vyslaní ďalšieho bitu. Zbernica I2C neumožňuje duplexný prenos, v jednom okamihu vysiela len jedno zariadenie. Všetky zariadenia pripojené na zbernicu musia mať individuálnu adresu a implementovaný mechanizmus komunikácie pomocou I²C zbernice <ref name="upythonUcebnica"></ref><ref name="bpmn"></ref>.

==Princíp obojsmernej komunikácie<ref>Texas Instruments, Understanding the I2C Bus, Application Report SLVA704 - June 2015. https://www.ti.com/lit/slva704</ref>==
Otvorený kolektor označuje typ výstupu, ktorý môže stiahnuť napäťovú úroveň zbernica na nízku úroveň - teda log.0 (vo väčšine prípadov na zem), alebo "uvoľniť" zbernicu a nechať napätie aby pomocou pull-up rezistora stúplo na úroveň logicej.1. V prípade, že je zbernica uvoľnená uzlom master alebo slave, pripojený pull-up rezistor je zodpovedný za vytiahnutie zbernice na úroveň napájacieho napätia. Keďže žiadne zariadenie nesmie vynucovať vysokú úroveň napätie na linke (teda úroveň pre log.1), znamená to že na zbernici nikdy nedôjde ku komunikačnému problému, keď sa jedno zariadenie pokúsi pripojiť napätie pre úroveň log.1 a iné zariadenie stiahne zbernicu na úroveň log.0, čo by spôsobilo skrat (napájacie napätie na zem). I2C vyžaduje, aby v prípade že master v zapojení s viacerými mastermi vysiela a vidí, že linka je v úrovni log.0 (iné zariadenie ju ťahá nadol - teda iné zariadenie komunikuje), zastaví komunikáciu, pretože zbernicu používa iné zariadenie.

[[Súbor:Mcu_i2c_bidirCom.png|300px|Obr. 1x. Základná štruktúra linky SDA/SCL]]

Obr. 1x. Základná štruktúra linky SDA/SCL

Obr. 1x zobrazuje zjednodušenú schému vnútornej štruktúry master alebo slave zariadenia pre komunikačné linky SDA/SCL. Táto schéma obsahuje vyrovnávaciu pamät (buffer) na čítanie vstupných údajov a znižujúci (pull-down) tranzistor FET na prenos údajov. Zariadenie je schopné meniť napäťovú úroveň iba na log.0 (vytvoriť skrat na zem) alebo uvoľniť linku zbernice (vysoká impedancia voči zemi) a umožniť, aby pull-up rezistor zvýšil napätie. Toto je dôležitý koncept, ktorý si treba uvedomiť pri práci s I2C zariadeniami, pretože žiadne zariadenie nesmie zvyšovať úroveň napätia pre log.1. Táto vlastnosť umožňuje obojsmernú komunikáciu medzi uzlami master a slave.

==Protokol prenášaných údajov<ref name="bpmn"></ref>==

Údaje v rozhraní I2C sa prenášajú v tzv. správach. Každá správa je rozdelená do jednotlivých rámcov, a to: adresný rámec, ktorý identifikuje binárnu adresu Slave zariadenia a následne jeden alebo viacero dátových rámcov, ktoré obsahujú prenášaný obsah. Správy obsahujú aj bity pre čítanie/zápis, bity ACK/NACK a podmienky START a STOP (Obr. 2).

[[Súbor:MCU_I2C_Basic_Address_and_Data_Frames.jpg|1024px|Obr. 2. Štruktúra správy cez I2C rozhranie]]

Obr. 2. Štruktúra správy cez I2C rozhranie<ref name="sparkfun"></ref>

* '''START''' - podmienka štart signalizuje začiatok komunikácie. Linka SDA sa prepne z vysokej (log. 1) na nízku hodnotu (log. 0) ''skôr'', ako sa linka SCL prepne z vysokej na nízku hodnotu.
* '''ADDRESS''' - adresa Slave zariadenia, s ktorým chce Master komunikovať. Adresa predstavuje 7 alebo 10 bitové celé číslo v binárnom tvare, ktoré predstavuje jedinečný identifikátor každého Slave zariadenia. Dve zariadenia by nemali mať tú istú adresu v jednej I2C zbernici.
* '''RW''' - jeden bit, ktorý určuje či sa vykonáva operácia zápisu alebo čítania:
** Ak RW = 0, zápis údajov na Slave zariadenie.
** Ak RW = 1, čítanie údajov zo Slave zariadenia.
* '''ACK/NACK''' nasleduje za každým rámcom v správe. Je to bit potvrdenia/nepotvrdenia:
** Ak bol úspešne prijatý adresný alebo dátový rámec, prijímajúce zariadenie vráti odosielateľovi log. 0 (ACK - Acknowledged).
** Ak nastala chyba v prenose, prijímajúce zariadenie vráti odosielateľovi log. 1 (NACK - Not Acknowledged).
* Existuje niekoľko situácií, ktoré vedú k vytvoreniu NACK:
** Prijímač vykonáva nejakú funkciu v reálnom čase a nie je pripravený začať komunikáciu s Masterom.
** Prijímač odbrží neznáme údaje alebo príkazy.
** Počas prenosu prijímač nemôže prijímať ďalšie dátové bajty.
** Master ukončí čítanie údajov a oznámi to Slave zariadeniu pomocou NACK.

* '''DATA''' - Dátový rámec je vždy dlhý 8 bitov a posiela sa s najvýznamnejším bitom (MSB) ako prvým. Za každým dátovým rámcom bezprostredne nasleduje bit ACK/NACK na overenie, či bol rámec úspešne prijatý. Pred odoslaním ďalšieho dátového rámca musí bit ACK prijať buď master, alebo slave (v závislosti od toho, kto dáta odosiela).
* '''STOP''' - ukončovacia podmienka štart signalizuje koniec komunikácie. Linka SDA sa prepne z nízkej (log. 0) na vysokú hodnotu (log. 1) ''potom'', čo sa linka SCL prepne z nízkej úrovne na vysokú <ref>Scott Campbell. BASICS OF THE I2C COMMUNICATION PROTOCOL. https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/.</ref><ref>Sal Afzal. I2C Primer: What is I2C? (Part 1). https://www.analog.com/en/technical-articles/i2c-primer-what-is-i2c-part-1.html.</ref>.

Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní

===Dátový prenos na zbernici I2C<ref>https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/</ref>===
# Master vyšle štart podmienku každému pripojenému slave prepnutím linky SDA z úrovne vysokého napätia na úroveň nízkeho napätia pred prepnutím linky SCL z vysokej na nízku.
# Master posiela každému uzlu slave 7 alebo 10-bitovú adresu s ktorým chce komunikovať, spolu s bitom pre čítanie/zápis
# Každý slave porovnáva adresu odoslanú od mastera so svojou vlastnou adresou. Ak sa adresa zhoduje, podriadená jednotka vráti bit ACK tým, že potiahne linku SDA na jeden bit. Ak sa adresa od nadradeného zariadenia nezhoduje s vlastnou adresou podriadeného zariadenia, podriadené zariadenie ponechá linku SDA na úrovni log.1.
# Master odošle alebo prijme dátový rámec
# Po prenose každého dátového rámca prijímacie zariadenie vráti odosielateľovi ďalší bit ACK, aby potvrdilo úspešné prijatie rámca
# Ak chcete zastaviť prenos dát, master pošle podriadenému zariadeniu stop podmienku prepnutím SCL na vysokú hodnotu pred prepnutím SDA na vysokú hodnotu.

Na Obr.3 je vyobrazený časový diagram zápisu a čítania údajov s veľkosťou 2B prostredníctvom rozhrania I2C.

[[Súbor:MCU_I2C_3_casovyDiagram.png|600px|Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní]]

===Základné vlastnosti a parametre zbernice I2C===

Základná pracovná frekvencia linky je 100kHz. Špecifikácia I2C dovoľuje zvýšiť túto frekvenciu až na 3.4 MHz. Zvýšenie frekvencie na strane mikrokontroléra je záležitosť konfigurácie. Je potrebné zvoliť takú frekvenciu, ktorú podporuje pripojený senzor alebo zariadenie, s ktorým chceme komunikovať.

{| class="wikitable"
|-
! Časovanie !! SCL
|-
| Standard Mode || 100 kHz
|-
| Fast Mode || 400 kHz
|-
| Fast Mode Plus || 1 MHz
|-
| High Speed Mode || 3.4 MHz
|}

== Zdroje a odkazy ==
<references/>

MCU ARM/I2C

2023-03-25T14:11:36Z

Juraj: Juraj premiestnil stránku MCU ARM/I2C na Komunikačné rozhranie I2C

#presmeruj [[Komunikačné rozhranie I2C]]

Šablóna:MCU ARM Obsah

2023-03-25T14:08:24Z

Juraj:

<div class="sideBox" style="width:250px;background-color:rgb(240,255,190);padding-left:5px;border:2px solid rgb(155,155,100)">
[[Mikrokontroléry ARM]]
----
{{vyuka_tema|Mikrokontroléry ARM|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}

Architektúra ARM mikrokotnrolérov

Vstupno/výstupné piny

Rozhranie UART

[[MCU_ARM/I2C|Rozhranie I2C]]

{{vyuka_tema|MCU_ARM/I2C|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}

Rozhranie SPI

</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Šablóna:MCU ARM Obsah

2023-03-25T13:53:27Z

Juraj:

<div class="sideBox" style="width:250px;background-color:rgb(240,255,190);padding-left:5px;border:2px solid rgb(155,155,100)">
[[Mikrokontroléry ARM]]
----
Architektúra ARM mikrokotnrolérov

Vstupno/výstupné piny

Rozhranie UART

[[MCU_ARM/I2C|Rozhranie I2C]]

{{vyuka_tema|MCU_ARM/I2C|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}

Rozhranie SPI

</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Šablóna:MCU ARM Obsah

2023-03-25T13:43:42Z

Juraj:

<div style="background:none repeat scroll 0 0 white;border:2px solid green; float:right;margin-left:1em; padding:0.3em; position:relative; width:300px; background-color:rgb(240,255,190); padding-left:5px;">
[[Mikrokontroléry ARM]]
----
Architektúra ARM mikrokotnrolérov

Vstupno/výstupné piny

Rozhranie UART

[[MCU_ARM/I2C|Rozhranie I2C]]

{{vyuka_tema|MCU_ARM/I2C|Práca v NetBeans|Práca v SciTe}}

{{vyuka_tema|Rozhranie I2C|Práca v NetBeans|Práca v SciTe}}

{{vyuka_tema|MCU_ARM/I2C|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}

Rozhranie SPI

</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Šablóna:MCU ARM Obsah

2023-03-25T13:40:22Z

Juraj:

<div style="background:none repeat scroll 0 0 white;border:2px solid green; float:right;margin-left:1em; padding:0.3em; position:relative; width:300px; background-color:rgb(240,255,190); padding-left:5px;">
[[Mikrokontroléry ARM]]
----
Architektúra ARM mikrokotnrolérov

Vstupno/výstupné piny

Rozhranie UART

[[MCU_ARM/I2C|Rozhranie I2C]]

{{vyuka_tema|MCU_ARM/I2C|I2C - základné použitie pre STM32|I2C - komunikácia s teplomerom LM75}}

Rozhranie SPI

</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Komunikačné rozhranie I2C

2023-03-25T13:15:17Z

Juraj:

Šablóna:MCU ARM Obsah

2023-03-25T13:13:37Z

Juraj:

Súbor:MCU I2C Basic Address and Data Frames.jpg

2023-03-25T13:03:56Z

Juraj:

Súbor:Mcu i2c 1 schematic.jpg

2023-03-25T12:59:53Z

Juraj:

Komunikačné rozhranie I2C

2023-03-24T22:44:20Z

Juraj:

{{MCU_ARM_Obsah}}

Inter-Integrated Circuit alebo I²C je dvojžilová obojsmerná zbernica vyvinutá firmou Philips začiatkom 90-tych rokov 20. storočia, používaná predovšetkým na prepojenie periférnych zariadení s mikrokontrolérom. Na zbernicu sú pripojené zariadenia rozdelené na riadiace (Master - zahajuje a ukončuje komunikáciu; generuje hodinový signál SCL) a riadené (Slave - zariadenie adresované Masterom) <ref name="upythonUcebnica">Gabriel Gašpar a Juraj Ďuďák. Využitie mikrokontrolérov v automatizovanom riadení. Spektrum, 2023. ISBN: 978-80-227-5283-1.</ref> na Obr. 1 <ref name="bpmn">Matúš Nečas: Multi-displej systém pre embedded aplikácie, Bakalárska práca, MTF STUBA, 2023</ref>

[[Súbor:Mcu_i2c_1_pripojenie.png|600px|Obr. 1. Pripojenie zaradení na zbernicu]]

Obr. 1. Pripojenie zaradení na zbernicu

I2C umožňuje prepojenie až 128 rôznych zariadení s pomocou iba dvoch obojsmerných vodičov. Jeden tvoria hodinový signál SCL (Synchronous Clock) a druhý dátový kanál SDA (Synchronous Data). Maximálna dĺžka vodičov je daná ich najvyššou povolenou kapacitou 400 pF, všeobecne sa uvádza cca 10cm. Každý vodič musí byť pripojený jedným pull-up rezistorom ku kladnému napätiu, čo zaistí vysokú úroveň v pokojovom stave. Pri prebiehajúcom prenose sú na SDA vysielané jednotlivé dátové bity pričom platí pravidlo, že logická úroveň na SDA sa môže nastaviť len ak je SCL v úrovni L. Toto pravidlo je porušené v dvoch špeciálnych prípadoch, a to pri vysielaní podmienok START a STOP, ktoré sa používajú na začatie komunikácie a k ukončeniu prenosu.
Maximálna frekvencia signálu SCL je podľa verzie I2C 100 kHz alebo 400 kHz. Pre obe frekvencie je daná minimálna povolená doba zotrvania SCL v úrovni L a H. Pri komunikácii aj pri prenose dát si jednotlivé stanice synchronizujú generátory hodín tak, že trvanie úrovne H na SCL je odmeriavané vnútorným časovačom každej stanice až od okamihu, keď SCL skutočne úrovne H dosiahne (pretože je SCL typu otvorený kolektor, môže byť v úrovni L držaný aj v situácii kedy sa daná stanica snaží nastaviť úroveň H). Podobne je doba trvania úrovne L na SCL odmeriavaná od zostupnej hrany. Tento mechanizmus umožňuje pre niektoré zo staníc spomaliť prenos: pomalá stanica môže podržať po určitú dobu signál SCL v úrovni L a tým zabrániť vysielajúcej stanici vo vyslaní ďalšieho bitu. Zbernica I2C neumožňuje duplexný prenos, v jednom okamihu vysiela len jedno zariadenie. Všetky zariadenia pripojené na zbernicu musia mať individuálnu adresu a implementovaný mechanizmus komunikácie pomocou I²C zbernice <ref name="upythonUcebnica"></ref><ref name="bpmn"></ref>.

===Princíp obojsmernej komunikácie<ref>Texas Instruments, Understanding the I2C Bus, Application Report SLVA704 - June 2015. https://www.ti.com/lit/slva704</ref>===
Otvorený kolektor označuje typ výstupu, ktorý môže stiahnuť napäťovú úroveň zbernica na nízku úroveň - teda log.0 (vo väčšine prípadov na zem), alebo "uvoľniť" zbernicu a nechať napätie aby pomocou pull-up rezistora stúplo na úroveň logicej.1. V prípade, že je zbernica uvoľnená uzlom master alebo slave, pripojený pull-up rezistor je zodpovedný za vytiahnutie zbernice na úroveň napájacieho napätia. Keďže žiadne zariadenie nesmie vynucovať vysokú úroveň napätie na linke (teda úroveň pre log.1), znamená to že na zbernici nikdy nedôjde ku komunikačnému problému, keď sa jedno zariadenie pokúsi pripojiť napätie pre úroveň log.1 a iné zariadenie stiahne zbernicu na úroveň log.0, čo by spôsobilo skrat (napájacie napätie na zem). I2C vyžaduje, aby v prípade že master v zapojení s viacerými mastermi vysiela a vidí, že linka je v úrovni log.0 (iné zariadenie ju ťahá nadol - teda iné zariadenie komunikuje), zastaví komunikáciu, pretože zbernicu používa iné zariadenie.

[[Súbor:Mcu_i2c_bidirCom.png|300px|Obr. 1x. Základná štruktúra linky SDA/SCL]]

Obr. 1x. Základná štruktúra linky SDA/SCL

Obr. 1x zobrazuje zjednodušenú schému vnútornej štruktúry master alebo slave zariadenia pre komunikačné linky SDA/SCL. Táto schéma obsahuje vyrovnávaciu pamät (buffer) na čítanie vstupných údajov a znižujúci (pull-down) tranzistor FET na prenos údajov. Zariadenie je schopné meniť napäťovú úroveň iba na log.0 (vytvoriť skrat na zem) alebo uvoľniť linku zbernice (vysoká impedancia voči zemi) a umožniť, aby pull-up rezistor zvýšil napätie. Toto je dôležitý koncept, ktorý si treba uvedomiť pri práci s I2C zariadeniami, pretože žiadne zariadenie nesmie zvyšovať úroveň napätia pre log.1. Táto vlastnosť umožňuje obojsmernú komunikáciu medzi uzlami master a slave.

===Protokol prenášaných údajov<ref name="bpmn"></ref>===

Údaje v rozhraní I2C sa prenášajú v tzv. správach. Každá správa je rozdelená do jednotlivých rámcov, a to: adresný rámec, ktorý identifikuje binárnu adresu Slave zariadenia a následne jeden alebo viacero dátových rámcov, ktoré obsahujú prenášaný obsah. Správy obsahujú aj bity pre čítanie/zápis, bity ACK/NACK a podmienky START a STOP (Obr. 2).

[[Súbor:MCU_I2C_2_strukturaSpravy.png|600px|Obr. 2. Štruktúra správy cez I2C rozhranie]]

Obr. 2. Štruktúra správy cez I2C rozhranie

* '''START''' - podmienka štart signalizuje začiatok komunikácie. Linka SDA sa prepne z vysokej (log. 1) na nízku hodnotu (log. 0) ''skôr'', ako sa linka SCL prepne z vysokej na nízku hodnotu.
* '''ADDRESS''' - adresa Slave zariadenia, s ktorým chce Master komunikovať. Adresa predstavuje 7 alebo 10 bitové celé číslo v binárnom tvare, ktoré predstavuje jedinečný identifikátor každého Slave zariadenia. Dve zariadenia by nemali mať tú istú adresu v jednej I2C zbernici.
* '''RW''' - jeden bit, ktorý určuje či sa vykonáva operácia zápisu alebo čítania:
** Ak RW = 0, zápis údajov na Slave zariadenie.
** Ak RW = 1, čítanie údajov zo Slave zariadenia.
* '''ACK/NACK''' nasleduje za každým rámcom v správe. Je to bit potvrdenia/nepotvrdenia:
** Ak bol úspešne prijatý adresný alebo dátový rámec, prijímajúce zariadenie vráti odosielateľovi log. 0 (ACK - Acknowledged).
** Ak nastala chyba v prenose, prijímajúce zariadenie vráti odosielateľovi log. 1 (NACK - Not Acknowledged).
* Existuje niekoľko situácií, ktoré vedú k vytvoreniu NACK:
** Prijímač vykonáva nejakú funkciu v reálnom čase a nie je pripravený začať komunikáciu s Masterom.
** Prijímač odbrží neznáme údaje alebo príkazy.
** Počas prenosu prijímač nemôže prijímať ďalšie dátové bajty.
** Master ukončí čítanie údajov a oznámi to Slave zariadeniu pomocou NACK.

* '''DATA''' - Dátový rámec je vždy dlhý 8 bitov a posiela sa s najvýznamnejším bitom (MSB) ako prvým. Za každým dátovým rámcom bezprostredne nasleduje bit ACK/NACK na overenie, či bol rámec úspešne prijatý. Pred odoslaním ďalšieho dátového rámca musí bit ACK prijať buď master, alebo slave (v závislosti od toho, kto dáta odosiela).
* '''STOP''' - ukončovacia podmienka štart signalizuje koniec komunikácie. Linka SDA sa prepne z nízkej (log. 0) na vysokú hodnotu (log. 1) ''potom'', čo sa linka SCL prepne z nízkej úrovne na vysokú <ref>Scott Campbell. BASICS OF THE I2C COMMUNICATION PROTOCOL. https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/.</ref><ref>Sal Afzal. I2C Primer: What is I2C? (Part 1). https://www.analog.com/en/technical-articles/i2c-primer-what-is-i2c-part-1.html.</ref>.

Na Obr.3 je vyobrazený časový diagram zápisu a čítania údajov s veľkosťou 2B prostredníctvom rozhrania I2C.

[[Súbor:MCU_I2C_3_casovyDiagram.png|600px|Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní]]

Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní

===Základné vlastnosti a parametre zbernice I2C===

Základná pracovná frekvencia linky je 100kHz. Špecifikácia I2C dovoľuje zvýšiť túto frekvenciu až na 3.4 MHz. Zvýšenie frekvencie na strane mikrokontroléra je záležitosť konfigurácie. Je potrebné zvoliť takú frekvenciu, ktorú podporuje pripojený senzor alebo zariadenie, s ktorým chceme komunikovať.

{| class="wikitable"
|-
! Časovanie !! SCL
|-
| Standard Mode || 100 kHz
|-
| Fast Mode || 400 kHz
|-
| Fast Mode Plus || 1 MHz
|-
| High Speed Mode || 3.4 MHz
|}

===Modifikácia I2C protokolu pre displeje===

Pri displejoch treba v prenášanej správe obsiahnuť aj informáciu o tom či sa posiela príkaz alebo dáta. Preto je do správy pridaný 8-bitový DC rámec, ktorý nasleduje vždy za rámcom adresy. DC rámec obvykle nadobúda hodnoty 0 pre príkaz a 64 pre dáta, avšak toto pravidlo nie je pevne dané. Po odoslaní DC rámca sa odošle N rámcov dát (Obr.4).

[[Súbor:MCU_I2C_4_displeje.png|600px|Obr. 4. Štruktúra displejovej správy cez I2C rozhranie]]

Obr. 4. Štruktúra displejovej správy cez I2C rozhranie

== Zdroje a aOdkazy ==
<references/>

Súbor:Mcu i2c bidirCom.png

2023-03-24T22:41:29Z

Juraj:

Komunikačné rozhranie I2C

2023-03-21T22:35:42Z

Juraj:

{{MCU_ARM_Obsah}}

Inter-Integrated Circuit alebo I²C je dvojžilová obojsmerná zbernica vyvinutá firmou Philips začiatkom 90-tych rokov 20. storočia, používaná predovšetkým na prepojenie periférnych zariadení s mikrokontrolérom. Na zbernicu sú pripojené zariadenia rozdelené na riadiace (Master - zahajuje a ukončuje komunikáciu; generuje hodinový signál SCL) a riadené (Slave - zariadenie adresované Masterom) <ref name="upythonUcebnica">Gabriel Gašpar a Juraj Ďuďák. Využitie mikrokontrolérov v automatizovanom riadení. Spektrum, 2023. ISBN: 978-80-227-5283-1.</ref> na Obr. 1 <ref name="bpmn">Matúš Nečas: Multi-displej systém pre embedded aplikácie, Bakalárska práca, MTF STUBA, 2023</ref>

[[Súbor:Mcu_i2c_1_pripojenie.png|600px|Obr. 1. Pripojenie zaradení na zbernicu]]

Obr. 1. Pripojenie zaradení na zbernicu

I2C umožňuje prepojenie až 128 rôznych zariadení s pomocou iba dvoch obojsmerných vodičov. Jeden tvoria hodinový signál SCL (Synchronous Clock) a druhý dátový kanál SDA (Synchronous Data). Maximálna dĺžka vodičov je daná ich najvyššou povolenou kapacitou 400 pF, všeobecne sa uvádza cca 10cm. Každý vodič musí byť pripojený jedným pull-up rezistorom ku kladnému napätiu, čo zaistí vysokú úroveň v pokojovom stave. Pri prebiehajúcom prenose sú na SDA vysielané jednotlivé dátové bity pričom platí pravidlo, že logická úroveň na SDA sa môže nastaviť len ak je SCL v úrovni L. Toto pravidlo je porušené v dvoch špeciálnych prípadoch, a to pri vysielaní podmienok START a STOP, ktoré sa používajú na začatie komunikácie a k ukončeniu prenosu.
Maximálna frekvencia signálu SCL je podľa verzie I2C 100 kHz alebo 400 kHz. Pre obe frekvencie je daná minimálna povolená doba zotrvania SCL v úrovni L a H. Pri komunikácii aj pri prenose dát si jednotlivé stanice synchronizujú generátory hodín tak, že trvanie úrovne H na SCL je odmeriavané vnútorným časovačom každej stanice až od okamihu, keď SCL skutočne úrovne H dosiahne (pretože je SCL typu otvorený kolektor, môže byť v úrovni L držaný aj v situácii kedy sa daná stanica snaží nastaviť úroveň H). Podobne je doba trvania úrovne L na SCL odmeriavaná od zostupnej hrany. Tento mechanizmus umožňuje pre niektoré zo staníc spomaliť prenos: pomalá stanica môže podržať po určitú dobu signál SCL v úrovni L a tým zabrániť vysielajúcej stanici vo vyslaní ďalšieho bitu. Zbernica I2C neumožňuje duplexný prenos, v jednom okamihu vysiela len jedno zariadenie. Všetky zariadenia pripojené na zbernicu musia mať individuálnu adresu a implementovaný mechanizmus komunikácie pomocou I²C zbernice <ref name="upythonUcebnica"></ref><ref name="bpmn"></ref>.

===Protokol prenášaných údajov<ref name="bpmn"></ref>===

Údaje v rozhraní I2C sa prenášajú v tzv. správach. Každá správa je rozdelená do jednotlivých rámcov, a to: adresný rámec, ktorý identifikuje binárnu adresu Slave zariadenia a následne jeden alebo viacero dátových rámcov, ktoré obsahujú prenášaný obsah. Správy obsahujú aj bity pre čítanie/zápis, bity ACK/NACK a podmienky START a STOP (Obr. 2).

[[Súbor:MCU_I2C_2_strukturaSpravy.png|600px|Obr. 2. Štruktúra správy cez I2C rozhranie]]

Obr. 2. Štruktúra správy cez I2C rozhranie

* '''START''' - podmienka štart signalizuje začiatok komunikácie. Linka SDA sa prepne z vysokej (log. 1) na nízku hodnotu (log. 0) ''skôr'', ako sa linka SCL prepne z vysokej na nízku hodnotu.
* '''ADDRESS''' - adresa Slave zariadenia, s ktorým chce Master komunikovať. Adresa predstavuje 7 alebo 10 bitové celé číslo v binárnom tvare, ktoré predstavuje jedinečný identifikátor každého Slave zariadenia. Dve zariadenia by nemali mať tú istú adresu v jednej I2C zbernici.
* '''RW''' - jeden bit, ktorý určuje či sa vykonáva operácia zápisu alebo čítania:
** Ak RW = 0, zápis údajov na Slave zariadenie.
** Ak RW = 1, čítanie údajov zo Slave zariadenia.
* '''ACK/NACK''' nasleduje za každým rámcom v správe. Je to bit potvrdenia/nepotvrdenia:
** Ak bol úspešne prijatý adresný alebo dátový rámec, prijímajúce zariadenie vráti odosielateľovi log. 0 (ACK - Acknowledged).
** Ak nastala chyba v prenose, prijímajúce zariadenie vráti odosielateľovi log. 1 (NACK - Not Acknowledged).
* Existuje niekoľko situácií, ktoré vedú k vytvoreniu NACK:
** Prijímač vykonáva nejakú funkciu v reálnom čase a nie je pripravený začať komunikáciu s Masterom.
** Prijímač odbrží neznáme údaje alebo príkazy.
** Počas prenosu prijímač nemôže prijímať ďalšie dátové bajty.
** Master ukončí čítanie údajov a oznámi to Slave zariadeniu pomocou NACK.

* '''DATA''' - Dátový rámec je vždy dlhý 8 bitov a posiela sa s najvýznamnejším bitom (MSB) ako prvým. Za každým dátovým rámcom bezprostredne nasleduje bit ACK/NACK na overenie, či bol rámec úspešne prijatý. Pred odoslaním ďalšieho dátového rámca musí bit ACK prijať buď master, alebo slave (v závislosti od toho, kto dáta odosiela).
* '''STOP''' - ukončovacia podmienka štart signalizuje koniec komunikácie. Linka SDA sa prepne z nízkej (log. 0) na vysokú hodnotu (log. 1) ''potom'', čo sa linka SCL prepne z nízkej úrovne na vysokú <ref>Scott Campbell. BASICS OF THE I2C COMMUNICATION PROTOCOL. https://www.circuitbasics.com/basics-of-the-i2c-communication-protocol/.</ref><ref>Sal Afzal. I2C Primer: What is I2C? (Part 1). https://www.analog.com/en/technical-articles/i2c-primer-what-is-i2c-part-1.html.</ref>.

Na Obr.3 je vyobrazený časový diagram zápisu a čítania údajov s veľkosťou 2B prostredníctvom rozhrania I2C.

[[Súbor:MCU_I2C_3_casovyDiagram.png|600px|Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní]]

Obr. 3. Časový priebeh zápisu a čítania údajov v I2C rozhraní

===Modifikácia I2C protokolu pre displeje===

Pri displejoch treba v prenášanej správe obsiahnuť aj informáciu o tom či sa posiela príkaz alebo dáta. Preto je do správy pridaný 8-bitový DC rámec, ktorý nasleduje vždy za rámcom adresy. DC rámec obvykle nadobúda hodnoty 0 pre príkaz a 64 pre dáta, avšak toto pravidlo nie je pevne dané. Po odoslaní DC rámca sa odošle N rámcov dát (Obr.4).

[[Súbor:MCU_I2C_4_displeje.png|600px|Obr. 4. Štruktúra displejovej správy cez I2C rozhranie]]

Obr. 4. Štruktúra displejovej správy cez I2C rozhranie

== Zdroje a aOdkazy ==
<references/>

Komunikačné rozhranie I2C

2023-03-21T20:28:34Z

Juraj:

Komunikačné rozhranie I2C

2023-03-21T20:26:41Z

Juraj:

Komunikačné rozhranie I2C

2023-03-21T20:25:25Z

Juraj:

Komunikačné rozhranie I2C

2023-03-21T20:21:49Z

Juraj:

Komunikačné rozhranie I2C

2023-03-21T20:17:16Z

Juraj: Vytvorená stránka „{{MCU_ARM_Obsah}} Inter-Integrated Circuit alebo I²C je dvojžilová obojsmerná zbernica vyvinutá firmou Philips začiatkom 90-tych rokov 20. storočia, používaná…“

Šablóna:MCU ARM Obsah

2023-03-21T19:49:51Z

Juraj: Vytvorená stránka „__NOTOC__ <div style="background:none repeat scroll 0 0 white;border:2px solid green; float:right;margin-left:1em; padding:0.3em; position:relative; width:300px; backgro…“

__NOTOC__
<div style="background:none repeat scroll 0 0 white;border:2px solid green; float:right;margin-left:1em; padding:0.3em; position:relative; width:300px; background-color:rgb(240,255,190); padding-left:5px;">
[[Mikrokontroléry ARM]]
----
Architektúra ARM mikrokotnrolérov

Vstupno/výstupné piny

Rozhranie UART

[[MCU_ARM/I2C|Rozhranie I2C]]

Rozhranie SPI

</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:MCU ARM]]
[[Kategória:Študijné materiály]]

Mikrokontroléry ARM

2023-03-21T19:46:11Z

Juraj: Vytvorená stránka „== Obsah == * Architektúra ARM mikrokotnrolérov * Vstupno/výstupné piny * rozhranie UART * rozhranie I2C * rozhranie SPI“

== Obsah ==

* Architektúra ARM mikrokotnrolérov
* Vstupno/výstupné piny
* rozhranie UART
* [[MCU_ARM/I2C|rozhranie I2C]]
* rozhranie SPI

Podklady k prednáškam a cvičeniam

2023-03-21T19:44:45Z

Juraj:

[[Kategória:Študijné materiály]]
__NOTOC__
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Teoretická informatika a matematika==
* [[Základy informatiky - jazyk C]]
* [[Algoritmy a programovanie]]
* [[Databázové systémy]]
* [[Softvérové inžinierstvo]]
* [[Spolupráca počítača s prostredím]]
* [[Základy informatiky - jazyk Java]]
* [[Základy informatiky - jazyk Python]]
* [[Webovské technológie]]
----
*[[Numerická matematika]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
==Aplikovaná informatika==
* [[Mikrokontroléry ARM]]
* [[Konfigurovateľné mikroprocesorové systémy]]
* [[Logické a číslicové systémy ]]
* [[Simulácie a modelovanie | Simulácie a modelovanie pre elektroniku a elektrotechniku ]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Mechatronika ==
* [[Prevodníky]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Kvalita==
* [[Bezpečnosť technických systémov]]
* [[Kolokviálna skúška]]
* [[Softvérové systémy v manažérstve kvality]] (CAQ)
</div>

Podklady k prednáškam a cvičeniam

2023-03-21T19:35:17Z

Juraj:

[[Kategória:Študijné materiály]]
__NOTOC__
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Teoretická informatika a matematika==
* [[Základy informatiky - jazyk C]]
* [[Algoritmy a programovanie]]
* [[Databázové systémy]]
* [[Softvérové inžinierstvo]]
* [[Spolupráca počítača s prostredím]]
* [[Základy informatiky - jazyk Java]]
* [[Základy informatiky - jazyk Python]]
* [[Webovské technológie]]
----
*[[Numerická matematika]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
==Aplikovaná informatika==
* [[Mikrokontroléry prakticky]]
* [[Konfigurovateľné mikroprocesorové systémy]]
* [[Logické a číslicové systémy ]]
* [[Simulácie a modelovanie | Simulácie a modelovanie pre elektroniku a elektrotechniku ]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Mechatronika ==
* [[Prevodníky]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Kvalita==
* [[Bezpečnosť technických systémov]]
* [[Kolokviálna skúška]]
* [[Softvérové systémy v manažérstve kvality]] (CAQ)
</div>

Podklady k prednáškam a cvičeniam

2023-03-21T19:03:04Z

Juraj:

[[Kategória:Študijné materiály]]
__NOTOC__
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Teoretická informatika a matematika==
* [[Základy informatiky - jazyk C]]
* [[Algoritmy a programovanie]]
* [[Databázové systémy]]
* [[Expertné systémy]]
* [[Softvérové inžinierstvo]]
* [[Spolupráca počítača s prostredím]]
* [[Základy informatiky - jazyk Java]]
* [[Základy informatiky - jazyk Python]]
* [[Webovské technológie]]
----
*[[Numerická matematika]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
==Aplikovaná informatika==
* [[Mikrokontroléry prakticky]]
* [[Konfigurovateľné mikroprocesorové systémy]]
* [[Logické a číslicové systémy ]]
* [[Simulácie a modelovanie | Simulácie a modelovanie pre elektroniku a elektrotechniku ]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Mechatronika ==
* [[Prevodníky]]
</div>
<div style="width:500px; padding:15px; text-align:left;border: 2px solid orange;border-radius: 15px; -moz-border-radius:15px;float:left;margin:16px" >
== Kvalita==
* [[Bezpečnosť technických systémov]]
* [[Kolokviálna skúška]]
* [[Softvérové systémy v manažérstve kvality]] (CAQ)
</div>

Základy informatiky - jazyk C

2023-02-06T13:41:54Z

Juraj:

[[Kategória:Študijné materiály]]
[[Kategória:Teoretická informatika]]
[[Kategória:Základy informatiky]]
{{Draft}}
<properties>
Názov=Základy informatiky
Forma=Podklady k prednáškam a cvičeniam
Abstrakt= Podklady pre kurz programovania v jazyku C, časť 1: základy jazyka.
</properties>

{{Skripta_ZI}}
{{Priklady_ZI}}

=Referenčný manuál: C standard library=
{{Funkcie jazyka c}}

==Referencie==
* Pavel Herout: Učebnice jazyka C, Kopp, EAN 9788072323838
* Mike Banahan, Declan Brady and Mark Doran: The C Book, Addison Wesley in 1991, http://publications.gbdirect.co.uk/c_book/
* Ďuďák J.: Zbierka úloh z algoritmizácie pre predmet Základy informatiky, Fakulta mechatroniky, TnU AD, ISBN 978-80-8075-199-9
* Úvod do programovania v jazyku C - http://people.tuke.sk/igor.podlubny/C/index.htm

Šablóna:Skripta ZI

2023-02-06T13:41:13Z

Juraj:

__NOTOC__
<div class="sideBox" style="width:250px;background-color:rgb(255,240,190);padding-left:5px;border:2px solid rgb(246,188,40)">
[[Základy informatiky - jazyk C]]
----
====Učebné texty====
[[Booleova algebra]]

[[Algoritmus]]

[[Jazyk C - štruktúra kódu|Štruktúra kódu]]

[[Jazyk C - príkazy preprocesora|Príkazy preprocesora]]

[[Jazyk C - dátové typy, premenné|Dátové typy, premenné]]

[[Jazyk C - operátory|Operátory]]

[[Jazyk C - vstupno/výstupné operácie|Vstupno/výstupné operácie]]

[[Jazyk C - podmienky|Podmienky]]

[[Jazyk C - cykly|Cykly]]

[[Jazyk C - polia|Polia]]

[[Jazyk C - reťazce|Reťazce]]

[[Jazyk C - funkcie|Funkcie]]

[[Jazyk C - súbory|Súbory]]

[[Jazyk C - štruktúry|Štruktúry]]

[[Jazyk C - smerník (pointer)|Smerník (pointer)]]

</div>
[[Kategória:Pri tlačení vynechať]]
[[Kategória:Základy informatiky]]
[[Kategória:Študijné materiály]]

Algoritmus

2022-09-19T20:54:53Z

Juraj:

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==<big>Algoritmus</big>==
'''Algoritmus''' znamená proces alebo súbor pravidiel ktoré sa majú dodržiavať pri operáciach alebo riešení problémov. Algoritmus sa preto týka súboru pravidiel,pokynov ktoré postupne definujú, ako sa má práca vykonať, aby sa dosiahli očakávané výsledky.<ref>>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

Práca počítača je presne determinovaná. Počítač je absolútne neiniciatívny a všetko, čo chceme, aby urobil mu musíme nariadiť. Prácu počítaču nariaďujeme programom. K tomu aby sme mohli program zostaviť potrebujeme vytvoriť postupnosť krokov, ktorá v každom okamihu určuje ako postupovať ďalej, tzv. algoritmus. Jedna z definícií algoritmu hovorí, že algoritmus je presný popis definujúci výpočtový proces, vedúci od meniteľných vstupných údajov až k žiadaným výsledkom. Táto definícia síce presne vystihuje podstatu a účel algoritmu, je však úzko špecializovaná Obmedzuje sa len na výpočtový proces. Algoritmy však nepoužívame len pri počítačoch pri príprave programov, ale ich použitie je všeobecné. Pomocou algoritmu totiž môžeme presne definovať akýkoľvek determinovaný proces.

[[Súbor:Univerzalny algoritmus.png|none|240px|]]

Navrhnutý algoritmus je nezávislý od jazyka, tzn. že ide iba o jednoduché pokyny, ktoré je možné implementovať v akomkoľvek jazyku, a napriek tomu bude výstup rovnaký, ako sa očakávalo.

==<big>Vlasnosti algoritmu</big>==

===Hlavné vlasnosti algoritmu===
;Jasný a jednoznačný: Každý krok algoritmu musí byť presne definovaný a nesmie dovoľovať viacej výkladov, teda nesmie pripúšťať pochybnosť o tom, ako postupovať ďalej - t. j. ako jednotlivé kroky nasledujú po sebe,

;Všeobecnosť: Algoritmus musí vyhovovať riešeniu všeobecnej skupiny úloh. Algoritmus musí vychádzať s meniteľných vstupných údajov, t. j. musí to byť popis riešenia nie len jednej úlohy, ale celej skupiny príbuzných úloh líšiacich sa od seba len vstupnými údajmi, <ref>https://spseke.sk/tutor/projekt/algoritmy.htm</ref>. Ako príklad môžeme uviesť riešenie kvadratickej rovnice, kde menitenými vstupnými údajmi sú koeficienty a,b,c a skupina úloh toho istého typu je množina všetkých kvadratických rovníc, kde a,b,c patria do R.

;Rezultatívnosť: Algoritmus musí vždy vyústiť do nejakého riešenia a to po konečnom počte krokov. Podotknime, že výsledok algoritmu môže byť aj "neviem" alebo "riešenie neexistuje", čo sa dá považovať správny výsledok.

;Konečnosť: Počet opakovaní každého kroku je konečný

;Elementárnosť: Algoritmus pozostáva z konečného počtu elementárnych krokov.

===Doplnkové vlasnosti alogritmu===

;Zrozumiteľnosť: Použitie takých prostriedkov na zápis algoritmu, ktoré by mali byť zrozumiteľné rôznym pracovníkom, ktorí budú s algoritmom pracovať (analytik, programátor, používateľ, oponent...).

;Správnosť: Algoritmus musí úplne a správne riešiť danú úlohu.

;Efektívnosť: Algoritmus má byť čo najvýhodnejší (najefektívnejší). Zmyslom efektívnosti je minimalizovať nároky na spracovanie činnosti podľa algoritmu. Efektívnosť môžeme posudzovať z rôznych hľadísk (výpočtový čas a kapacita pamätí počítača, minimalizácia finančných nárokov, minimalizácia spotreby energie, minimalizácia nárokov na personálne alebo materiálne vybavenie, minimalizácia dopadov na životné prostredie a pod.), prípadne sa snažíme optimalizovať vzájomný vzťah viacerých hľadísk. Táto požiadavka je často v rozpore s požiadavkou na štruktúrovanosť (prehľadnosť, modulárnosť, usporiadanosť) algoritmu.

;Modifikovateľnosť: Algoritmus by mal byť vytvorený tak, aby sa dal ľahko modifikovať pri potrebnej zmene vyvolanej zmenou podmienok riešenia (vonkajších a vnútorných).

;Štruktúrovanosť: Požiadavka na vnútornú štruktúru algoritmu, ktorý by mal byť rozdelený na relatívne samostatné, ale logicky nadväzujúce celky, ktoré riešia vždy príslušnú časť algoritmu, požiadavka súvisí so zrozumiteľnosťou a modifikovateľnosťou, dobre štruktúrovaný algoritmus je zrozumiteľný a ľahko modifikovateľný (opraviteľný).

==Riešenie problému pomocou algorimtu==
'''1.''' Problém, ktorý má tento algoritmus vyriešiť.

'''2.''' Obmedzenia problému, ktoré je potrebné zohľadniť pri jeho riešení.

'''3.''' Vstup, ktorý sa má prijať na vyriešenie problému.

'''4.''' Výstup, ktorý možno očakávať, keď sa problém vyrieši.

'''5.''' Riešenie tohto problému v daných obmedzeniach.<ref>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

==Značky vývojových diagramov==
[[Súbor:začiatok.png|100px|none]] Značka sa využíva na začatie alebo ukončenie vývojového diagramu

[[Súbor:Untitled Diagram.png|100px|none]] Výkonný blok na program

[[Súbor:Vstuo.png|100px|none]] Služi na zápis vstup a výstupov vývojoveého diagramu

[[Súbor:Untitled Diagram (3).png|160px|none]] Rozhodovací blok s jedným vstupom a viacerými výstupmi

[[Súbor:Spojka.png|none|30px]] Spojka

[[Súbor:Spojnica.png|none|160px]] Spojnica

==Príklady==
'''Príklady''' na tvorbu vývojových diagramov nájdete v sekcií:
[http://www.kiwiki.info/index.php/Jazyk_C_(príklady)_-_Algoritmy[Príklady algoritmus]]

=Referencie=
<references/>

Triedenie výberom

2021-03-21T19:56:30Z

Juraj: Vytvorená stránka „Kategória:Algoritmy triedenia {{Draft}} {{Skripta programovanie}} __TOC__“

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__

Jazyk C (príklady) - Algoritmy

2021-03-06T18:15:26Z

Juraj: /* Kvadratická rovnica */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Priklady_ZI}}
__TOC__

==Obsah==
V tejto kapitole budú ukázaná tvorba jednoduchých vývojových diagramov. Budú ukázané základné prvky algoritmizácie úloh, použitie rozhodovania, opakovania istého počtu operácií. K zvládnutiu tejto kapitoly sa predpokladá znalosť grafických značiek použitých pri tvorbe vývojových diagramov.

===Grafické značky vývojových diagramov===

Medzi základné stavebné bloky vývojových diagramov (VD) patria bloky, ktoré reprezentujú

*začiatok / koniec VD
*vykonávací blok
*rozhodovací blok
*spojka
*vstup / výstup dát
*orientované spojnice blokov
[http://www.kiwiki.info/index.php/Algoritmus[Vývojové stavebné bloky]]

==Príklady==

===Absolútna hodnota===
;Zadanie: Vieme, že absolútna hodnota je definovaná ako vzdialenosť čísla od začiatku súradnicového systému (resp. od nuly). Nakreslite vývojový diagram, ktorý by znázorňoval výpočet absolútnej hodnoty.

;Analýza problému: Pre absolútnu hodnotu reálnych čísel platí:
* abs(x) = x
* abs(-x) = x
Inak povedané, pre x>=0, je absolútna hodnota x rovná práve x, pre x<0 je absolútna hodnota x rovná -1*x.
Teda, stačí nám zistiť, či je x menšie ako nula.

[[Súbor:78 2 alg1.png|240px|none]]

===Kvadratická rovnica===
;Zadanie: Navrhnite algoritmus výpočtu koreňov kvadratickej rovnice ax2+bx+c=0. Vstupom do algoritmu budú koeficienty a, b, c, a výstupom budú korene kvadratickej rovnice x1,2.

;Analýza problému: Riešenie tejto rovnice je známe, úlohou je tento problém znázorniť v podobe vývojového diagramu. Vieme, že kvadratická rovnica má dva korene (x1 a x2). Tieto korene môžu byť rôzne, alebo riešením je jeden dvojnásobný koreň. Toto zistíme pomocou výpočtu diskriminantu kvadratickej rovnice. Diskriminant je definovaný ako D=b2-4ac
Rozoberme si jednotlivé prípady riešenia.
*D>0 : Rovnica má dva korene: x1=(-b+D1/2)/2a, x2=(-b-D1/2)/2a
*D=0 : Rovnica má jeden dvojnásobný koreň: x1,2=-b/2a
*D<0 : Rovnica má riešenie na množine komplexných čísel:
Vieme, že i2=-1. (i je komplexná jednotka). Potom výpočet druhej odmocniny diskriminantu je (D)1/2=(i2 * (-D))1/2=i*(-D) ½ (poznámka: D<0). Teda korene kvadratickej rovnice budú x1=(-b+iD1/2)/2a, x2=(-b-iD1/2)/2a

[[Súbor:80 2 alg2.png|480px|none]]

===Maximum z 3 hodnôt===
;Zadanie: V predajni skrípt majú 3 skriptá, o ktoré máme záujem. Cena skrípt je a, b, c Sk. Navrhnite algoritmus, ktorý nájde najdrahšie skriptá; teda skriptá s maximálnou cenou.

;Analýza problému: V prípade, ak máme zistiť maximálnu (alebo minimálnu) hodnotu z troch čísel, musíme každé číslo porovnať s každým iným číslom. Teda, spolu budeme robiť 3 porovnania (a<->b, a<->c, b<->c). Nemá zmysel porovnávať ab a ba, lebo toto sú totožné porovnania. Ak teda máme zistiť najväčšie číslo z a, b, c, môžeme postupovať napríklad nasledovne: Najskôr porovnáme : a>b. Ak toto platí, potom porovnáme a>c. V prípade ak aj toto platí, tak maximum je a. Keby platilo že: a>b a c>a, potom vieme, že maximum je c. Takto by sme mohli pokračovať ďalej.

[[Súbor:82 2 alg3.png|360px|none]]

===Opakované načítanie===

;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý vypočíta celkovú sumu položiek faktúry. Prvý vstupný údaj bude číslo pocet, ktoré nám hovorí o počte nasledujúcich položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcim cenu položky). Navrhnite algoritmus, ktorý vypočíta výslednú sumu ceny všetkých položiek.

;Analýza problému: V tomto prípade nikdy popredu nevieme, koľko budeme načítavať položiek. Tento údaj sa dozvieme až v momente, keď načítame prvý údaj. Úlohou bude teda navrhnúť algoritmus, ktorý by načítal požadovaný počet položiek (počet položiek môže byť od 0 až po ľubovoľne veľké konečné číslo). Na riešenie tohto problému využijeme cyklus. Tento cyklus sa bude opakovať toľkokrát, koľko položiek máme načítať. Pri každom opakovaní cyklu načítame jednu položku (položku označme ako premennú a) a jej hodnotu pripočítame k výslednej sume. Ďalším algoritmickým problémom je zabezpečiť, aby sa tento cyklus vykonával presne pocet krát. Tu využijeme prvý vstupný údaj pocet. Pri každej iterácii (opakovaní) cyklu sa hodnota premennej pocet zníži o 1. Cyklus budeme opakovať dovtedy, pokiaľ bude premenná pocet rôzna od nuly. Na výpočet súčtu všetkých položiek využijeme premennú suma, ktorú na začiatku vynulujeme (priradíme jej hodnotu 0).

[[Súbor:84 2 alg4.png|360px|none]]

===Násobenie===

;Zadanie: V počítačoch (na hardvérovej úrovni) sa operácia násobenia vykoná pomocou opakovaného sčítavania dvoch hodnôt. Vytvorte algoritmus, ktorý by násobil dve celé čísla pomocou opakovaného sčítavania.

;Analýza problému: Na riešenie problému nemôžeme použiť operáciu násobenia (*), musíme použiť operáciu sčítavania (+). Zoberme si príklad: x=5*3. Tu budeme 3 krát pripočítame hodnotu 5 do premennej x, ktorú musíme najskôr vynulovať. Teda x=5+5+5=15. Vo všeobecnosti máme x=a*b=a+a+...+a : sčítavanie robíme b krát. Z uvedeného vyplýva, že nemôžeme pevne napísať, koľkokrát sa a pripočíta do premennej x. Tu bude vhodné využiť nejaký cyklus. V každom cykle sa do premennej x pripočíta hodnota a. Počet opakovaní cyklu je b. V každej iterácii cyklu hodnotu premennej b znížime o 1. Cyklus ukončíme, ak sa b=0.

[[Súbor:86 2 alg5.png|300px|none]]

===Prvočíslo===
;Zadanie: Navrhnite algoritmus, ktorý zistí, či zadané číslo a je prvočíslo.

;Analýza problému: Prvočíslo je číslo, ktoré je delitelné iba číslom 1 a sebou samým. Pri testovaní čísla a na prvočíselnosť postupne celočíselne deliť číslo a číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok (a sa nedá deliť číslom del), povieme že číslo a je prvočíslo. Ak v priebehu delenia zistíme, že a je delitené číslom del bezo zvyšku, algoritmus ukončíme, a povieme že a nie je prvočíslo. Ďalší problém je určiť, dokedy má zmysel zväčšovať deliteľ del. V predchádzajúcom texte sme del zvyšovali po hodnotu n. Úlohou je odhadnúť vhodné n. Pokúsme sa postupovať nasledovne: ako prvý deliteľ je del=2. Teda delíme a číslom del=2. Výsledok po tomto delení označme podiel. Ak budeme premennú del zvyšovať, nebude mať zmysel zväčšovať ju nad hodnotu podiel=a/2, pretože číslo a nemôže deliť žiadne číslo, ktoré je väčšie ako a/2. Ďalej, nech del=3. Ak číslo del (del=3) nedelí číslo a, hranica delenia – n sa zníži na hodnotu a/3, pretože žiadne číslo väčšie ako a/3 nemôže deliť a bezo zvyšku. Z uvedeného nám vyplýva, že hranicu n môžeme určiť nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. V algoritme použijeme ešte jednu premennú prvocislo. Táto premenná nám bude hovoriť, či je číslo prvočíslo alebo nie je. Na začiatku má hodnotu 1 – teda predpokladáme, že číslo je prvočíslo. V prípade, ak počas delenia zistíme, že nejaké číslo del delí a bezo zvyšku, premennej prvocislo priradíme hodnotu 0. Vyhlásime, že a nie je prvočíslo.

; Ukážka:
*a=23
*a del podiel
*23 / 2 = 11 zv 1
*23 / 3 = 7 zv 2
*23 / 4 = 5 zv 3
*23 / 5 = 4 zv 3 del > podiel; koniec; a je prvočíslo, pretože ani jeden zvyšok po delení nebol 0
*23 je prvočíslo.

[[Súbor:88 2 alg6.png|480px|none]]

Jazyk C (príklady) - Prvé programy

2021-03-06T17:48:08Z

Juraj:

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Priklady_ZI}}
__TOC__
==Princípy tvorby programov==
V tejto kapitole je ukázaná práca s premnnými a s funkciami na formátovaný vstup a výstup textu.
Na porozumenie danej problematiky je potrebné zvládnuť deklaráciu a základné použitie premených. Pre prácu s funkciami vstupu/výstupu textu je potrebné zvládnuť syntax týchto funkcií.
Pri popise syntaxe funkcií sú niektoré časti uvádzané v hranatých zátvorkách [ ]. Takýto zápis znamená, že časť, ktorá je v hranatej zátvorke je nepovinná a teda sa môže vynechať.
==Priklady==
===Priklad č.1 - Obvod a obsah obdĺžnika===
;Zadanie: Vytvorte program, ktorý po zadaní strán obdĺžnika vypočíta jeho obvod a obsah.

;Analýza problému: Označme si jednu stranu a a druhú stranu b. Pre jednoduchosť a názornosť budeme uvažovať celé čísla. Vzťah pre obvod obdĺžnka je o=2(a+b) a obsah S=ab. Tieto údaje sa následne vypíšu na monitor.

'''Program:'''
<source lang="c" line>
#include<stdio.h>
int main()
{
int a,b;
printf("Zadaj dlzku stran obdlznika (a, b)");
scanf("%d %d",&a,&b);
int o,S;
o=2*(a+b);
S=a*b;
printf("Obvod= %d\nObsah= %d",o,S);
return 0;
}
</source>

===Priklad č.2 - Obvod a obsah kruhu===
;Zadanie:Navrhnite program, ktorý po zadaní priemeru kruhu vypočíta jeho obvod a obsah.

;Analýza problému: Obvod kruhu je definovaný ako o=2Πr, obsah ako S= Πr2. Keďže Π nemá celočíselnú hodnotu, ani obsah a obvod hruhu nebudú celočíselné hodnoty. Preto zvolíme premnné typu float (reálne čísla). V programe si zadefinujme ešte premennú pi (pi=3.14).

'''Program:'''
<source lang="c" line>
#include<stdio.h>
int main()
{
float r,pi=3.14;
printf("Zadaj polomer kruhu (r) ");
scanf("%f",&r);
float o,S;
o=2*pi*r;
S=pi*r*r;
printf("Obvod= %f\nObsah= %f",o,S);
return 0;
}
</source>

===Priklad č.3 - Operátory===
;Zadanie: Precvičiť si operátory jazyka C.

;Analýza problému: Budeme pracovať s tromi premennými (int x=5, y=3; float z=3.0;). Okrem štandardných operátorov (+,-,*,/) ponznáme operátory &,|, ^,%,>>,<<.

'''Význam operátorov'''
* x+y=8 // sčítanie
* x/y=1 // celočíselné delenie
* x / z=1.666666 // reálne delenie
* x & y=1 (lebo 101 & 011 = 001) //bitový logický súčin AND
* x | y=7 (lebo 101 | 011 = 111) //bitový logický súčet OR
* x ^ y=6 (lebo 101 ^ 011 = 110) // bitový exkluzívny logický súčet XOR
* x % y=2 //zvyšok po celočíselnom delení
* x>>2=1 (lebo 101 >> 2 = 001) // bitový posun x doprava o 2 bity
* x<<3=40 (lebo 101 << 3 = 101000) //bitový posun x doľava o 3 bity

'''Program:'''

<source lang="c" line>
#include<stdio.h>
void main()
{
int x=5,y=3;
float z=3.0;
printf("x+y=%d\n",x+y);
printf("x/y=%d\n",x/y);
printf("x/z=%f\n",x/z);
printf("x&y=%d\n",x&y);
printf("x|y=%d\n",x|y);
printf("x^y=%d\n",x^y);
printf("x%y=%d\n",x%y);
printf("x>>2=%d\n",x>>2);
printf("x<<3=%d\n",x<<3);
}
</source>

Rekurzia (riešené príklady)

2021-02-21T19:20:11Z

Juraj:

{{Draft}}
{{Skripta programovanie (zbierka úloh)}}
__TOC__

==Najväčší spoločný deliteľ==
'''Zadanie'''
Nájdite rekurzívny vzťah v Euklidovom algoritme pre výpočet najväčšieho spoločného deliteľa a využite ho vo funkcii, ktorá bude počítať najväčší spoločný deliteľ dvoch čísel, uvedených ako jej parametre. Funkciu použite v programe, ktorý načíta dve čísla a napíše hodnotu ich najväčšieho spoločného deliteľa.

Poznámka:
V Euklidovom algoritme môžete namiesto klasického odpočítavania využiť zvyšok po delení, čo zníži počet krokov výpočtu a nebude potrebné sa zaoberať problémom „nesprávneho poradia“ čísel pri odpočítavaní.

'''Vzorové príklady'''
{|
|-
!vstup
!
!výstup
|-
|36 48
| ->
|12
|-
|576 284
| ->
|4
|-
|2553 7215
| ->
|111
|}

'''Analýza riešenia'''

Hľadaný rekurzívny vzťah je vidieť v postupe prevodu čísel postupným „modulovaním“ (operáciou modulo) – delenec a je nahradený deliteľom b, deliteľ b zase výsledkom a%b, ukončenie je pri nulovom b:
* NSD(a, b) = NSD(b, a%b) pre b>0,
* NSD(a, 0) = a

'''Možné riešenie:'''
<source lang="c" line>
#include <iostream.h>

int NSD(int a, int b)
{
if (b == 0) return a;
return NSD(b, a%b);
}

void main()
{
int a, b;
cin >> a >> b;
cout << NSD(a, b);
}
</source>
==Fibonacciho postupnosť==
'''Zadanie'''
Pre Fibonacciho postupnosť platí, že hodnota ďalšieho jeho prvku je súčtom dvoch predchádzajúcich. Zostavte program, ktorý bude z klávesnice čítať čísla n, kým nenačíta nulu a pre každé číslo n vypíše n-té Fibonacciho číslo v poradí, za predpokladu, že Fib(0) = 0 a Fib(1) = 1.

'''Vzorové príklady'''
{|
|-
!vstup
!
!výstup
|-
|4
| ->
|3
|-
|9
| ->
|34
|-
|20
| ->
|6765
|-
|40
| ->
|102334155
|-
|0
| ->
|
|}

'''Analýza riešenia'''

Fibonacciho postupnosť je rekurzívne definovaná ako:
* fib(0)=0
* fib(1)=1
* fib(i)=fib(i-1)+fib(i-2), pre i<nowiki>></nowiki>1

Na tomto príklade je vhodné demonštrovať, čo sa stane, ak zabudneme v rekurzívnej funkcii uviesť podmienku pre ukončenie rekurzie – program havaruje kvôli pretečeniu zásobníka.

'''Možné riešenie:'''
<source lang="c" line>
#include <iostream.h>
long fib(int n)
{
if (n < 2) return n;
else return fib(n-1) + fib(n-2);
}
void main()
{
int n;
cin >> n;
while (n)
{
cout << fib(n) << endl;
cin >> n;
}
}
</source>
==Prevod čísel z 10-vej sústavy==
'''Zadanie'''

Zostavte program, ktorý bude prevádzať prirodzené čísla do ľubovoľných číselných sústav so základom Z<10, využitím rekurzívnej funkcie. Túto funkciu postupne zdokonaľujte:
#Funkciu vylepšite, aby vedela prevádzať aj do sústav so základom Z<=16.
#Upravte funkciu tak, aby vedela prevádzať všetky celé čísla (čiže aj záporné a nulu).
#Pokúste sa funkciu obohatiť o prevod reálnych čísel (čiže aj desatinných).
V programe načítajte 2 vstupné údaje: číslo N v 10-vej sústave a základ novej sústavy z.

'''Vzorové príklady'''
{|class=wikitable
|-
!vstup
!výstup
|-
|80 2
|1010000
|-
|93 16
|5D
|-
|0 8
|0
|-
| -74 4
| -1022
|-
|3.141592654 16
|3.243F6A8A48AA
|-
| -0.1 2
| -0.0001100110011001100
|}

Je vhodné začať jednoduchou funkciou na prevod prirodzeného čísla. Ak máme základ cieľovej sústavy z<10, môžeme problém vyjadriť aj rekurentným vzťahom v matematickom tvare: P(n, z) = P(n/z, z) * 10 + n%z (pre n > 0), a teda by bolo možné vytvoriť funkciu, ktorej návratovou hodnotou by bolo celé číslo.

V prípade, že uvažujeme o vyššom základe, vo výsledku sa objavia aj symboly A, B, C, ... funkcia by už musela výsledok vracať vo forme reťazca. Pre zjednodušenie nám stačí funkcia, ktorá bude výsledok priamo vypisovať. Je treba si uvedomiť, ako sa počíta prevod čísla – číslo vydelíme základom sústavy, tento podiel prevedieme a za ním bude nasledovať zvyšok po pôvodnom delení.

Na vypísanie zvyšku pre vyššie sústavy by sme mohli pre zvyšky väčšie ako 9 použiť aj inkrementáciu znakového typu:
<source lang="c">
cout << char (‘A’ + n%z – 10);
</source>

Keďže základ sústavy sa počas celého prevodu samozrejme nemení, nemá význam v každom volaní funkcie vytvárať jeho kópiu v podobe vstupnej premennej, ale stačí nám referencia (ušetrí sa pár bajtíkov pri každom vnorení).

Ak chceme, aby funkcia dokázala prevádzať aj nulu a záporné čísla, musíme si pridať akúsi „úvodnú“ funkciu, ktorá ošetrí problematické situácie a až potom zavolá hlavnú rekurzívnu funkciu prevodu.

'''Možné riešenie:'''

<source lang="c">
#include <iostream.h>

const char znaky[] = "0123456789ABCDEF";
void PrevodCele(int n, int &zaklad)
{
if (n == 0) return;
PrevodCele(n/zaklad, zaklad); // prevedie celu cast podielu
cout << znaky[n%zaklad]; // za tym napise zvysok
}

void PrevodReal(double r, int &zaklad, int presnost)
{
if (r == 0) return;
r *= zaklad; // posunie o jeden rad vlavo
cout << znaky[int(r)]; // celu cast vypise
PrevodReal(r - int(r), zaklad, presnost - 1); // zvysok prevedie
}

// uvodna funkcia na specialne pripady
void Prevod(double r, int zaklad, int presnost)
{
// ak je zaporne
if (r < 0)
{
r = -r; cout << '-';
}
// cela cast
int n = int(r);
if (n)
PrevodCele(n, zaklad);
else
cout << 0; // ak je nula, vypise ju

// desatinna cast (ak je)
if (r -= n)
{
cout << '.';
PrevodReal(r, zaklad, presnost);
}
}

void main()
{
double r;
int sustava;
cout << "cislo v 10-kovej sustave: "; cin >> r;
cout << "cielova sustava: "; cin >> sustava;
cout << "prevedene: ";
Prevod(r, sustava, 6);
}
</source>

==Prvočísla==

'''Zadanie:'''

Pomocou rekurzívneho riešenia vytvorte funkciu, ktorá otestuje, či je dané číslo prvočíslo.
===Prvé riešenie - neoptimalizované===

'''Analýza riešenia:'''

Testujeme číslo n na prvočíselnosť. Číslo n budeme postupne deliť číslami od 2 až po (n-1) aby sme zistili zvyšok po delení. Pri prvom zvyšku, ktorý je rovný 0 (teda číslo z delí číslo n bezo zvyšku) funkciu ukončíme a vrátime hodnotu 0 (n nie je prvočíslo). Ak je z<(n-1) tak funkciu is_prime1 voláme rekurzívne a v tomto volaní zvýšime parameter z o 1. (riadok č. 8). V prípade, že neplatí rovnosť z<(n-1) a ani jedno číslo z intervalu <2,n-1> nedelí číslo n bezo zvyšku, vrátime hodnotu 1 (n je prvočíslo).

'''Možné riešenie:'''

<source lang="c" line >
int is_prime1(int n, int z=2)
{
if((n%z)==0)
return 0;
else
{
if(z<(n-1))
return is_prime1(n,z+1);
else
return 1;
}
}
</source>
===Druhé riešenie - čiastočne optimalizované===
Optimalizácia v tomto prípade znamená eliminovať počet delení modulo. Myšlienka nájdenia hornej hranice hodnoty premennej ''z'' z predchádzajúceho príkladu:
*Číslo n delíme modulo hodnotou 2. (výsledok je rôzny od 0)
** nemá zmysel deliť číslom ''z'' väčším ako je n/2, pretože už nám nemôže vyjsť celočíselný podiel. Výsledok takéhoto delenia bude v intervale (0,1)
*Číslo n delíme modulo hodnotou 3. (výsledok je rôzny od 0)
** nemá zmysel deliť číslom ''z'' väčším ako je n/3, pretože už nám nemôže vyjsť celočíselný podiel. Výsledok takéhoto delenia bude v intervale <math>(1,2) \cup (2,3)</math>. Podiel nebude mať hodnotu 2, pretože v tom prípade by bolo číslo n delitelné číslom 3 bezo zvyšku.
*Delitel n budeme zväčšovať až pokiaľ platí <math>\frac {n}{d}>d</math>

Horná hranica hodnoty d sa dá určiť nasledovne: <math>d=\sqrt{n}</math>

'''Možné riešenie:'''

<source lang="c" line >
int is_prime2(int n, int z=2)
{
if((n%z)==0)
return 0;
else
{
if(z<sqrt(n))
return is_prime2(n,z+1);
else
return 1;
}
}
</source>

===Tretie riešenie - viac optimalizované===
V predchádzajúcom príklade sme delili číslo n hodnotami premennej d. Premenná d mala prvú hodnotu 2 a potom sa k nej vždy pripočítala hodnota 1. Teda, číslo n sme postupne delili hodnotami
2, 3, 4, 5, 6, 7, 8, ... <math>d=\sqrt{n}</math>.

Všimnime si, že niektoré delenia sú opäť zbytočné:
*ak delíme číslom 2, potom nemá zmysel deliť žiadnym jeho násobkom
*vo všeobecnosti platí: ak delíme číslom ''j'', potom nemá zmysel deliť žiadnym násobkom čísla ''j''.

Inak povedané, netreba deliť žiadnom zloženým číslom. Stačí deliť prvočíslami. A tu sa dostávame k rekurzívnej definícii prvočísel:

'''Rekurzívna definícia prvočísla''':
* Číslo 2 je najmenšie prvočíslo.
* Prvočíslo je každé celé kladné číslo, ktoré nie je deliteľné žiadnym iným menším prvočíslom ako je toto číslo samotné.

Pri takto stanovenej podmienke je komplikovanejšie vytvoriť podmienku, ktoré by toto spĺňala. Preto skúsme napísať program, ktorý by zbytočne nedelil násobkami čísel 2 a 3.
Ak nechceme deliť násobkami čísla 2, tak potom budeme postupne deliť premennú n hodnotami 3,5,7,9,11,...

Ak nechceme deliť násobkami čísla 3, tak potom budeme postupne deliť premennú n hodnotami 4,5,7,8,10,11,13,14,...

Prienikom týchto dvoch podmienok je, že nám zostava deliť číslami 5,7,11,13,17,19,23, ...

V tejto postupnosti je jednoduché pravidlo: striedavé pripočítavanie hodnoty 2 a 4. Vyjadrené aritmetickou postupnosťou:
*<math>d_0=2</math>
*<math>d_1=3</math>
*<math>d_2=5</math>
*<math>d_n=d_{n-1} + 3-(-1)^{i+1}</math>

'''Možné riešenie:'''

<source lang="c" line >
int is_prime3(int n, int z,int krok)
{
int d=z+3+krok;
if((n%d)==0)
return 0;
else
{
if(d<sqrt(n))
return is_prime3(n,d,-krok);
else
return 1;
}
}

int is_prime(int n)
{
if((n%2)==0) return 0;
if((n%3)==0) return 0;
if((n%5)==0) return 0;
return is_prime3(n,5,-1);
}
</source>

'''Rozbor zdrojového kódu:'''

Pre hľadanie prvočísel použijeme funkciu is_prime, ktorá otestuje číslo n na deliteľnosť číslami 2, 3 a 5. Potom zavoláme pomocnú rekurzívnu funkciu is_prime3(int n, int z,int krok) ktorá bude testovať deliteľnosť čísla n prvkami postupnosti <math>\big\{d_n\big\}</math>. Aby sme sa vyhli zbytočným podmienkam, ktoré môžu celý algoritmus spomaliť, definujeme tretí parameter funkcie is_prime3 ''krok''. Parameter krok je v našej postupnosti výraz <math> 3-(-1)^{i+1}</math>, avšak tu nepočítame hodnotu mocniny <math>(-1)^{i+1}</math> ale využívame skutočnosť že tento výraz nadobúda hodnoty -1,1,-1,1, ... .

V premennej d je vypočítaná hodnota aktuálneho deliteľa podľa vzťahu: <math>d_n=d_{n-1} + 3-(-1)^{i+1}</math>.

===Riešenie s globálnym poľom===
Pre zjednodušenie tvorby programu si vytvorme globálne pole do ktorého uložíme prvých n prvočísel. Potom najväčšie číslo, ktoré môžeme testovať na prvočíselnosť je <math>N=n^2</math>.

'''Analýza riešenia:'''

Testujeme číslo n na prvočíselnosť. Ako prvé vypočítame zvyšok po delení prvým prvočíslom v poli ''pcisla'' (delíme číslom pcisla[0]=2). V prípade, ak je výsledok 0, tak výpočet ukončíme a vrátime hodnotu (0 - nie je prvočíslo). V opačnom prípade rekurzívne zavoláme funkciu jePrvocislo, kde druhý parameter (má význam indexu v poli ''pcisla'') zvýšime o 1. Teda v ďalšom volaní funkcie jePrvocislo už budeme deliť číslom pcisla[1]=3. Musíme však zabezpečiť, aby hodnota pcisla[i] v riadku č. 5 existovala. To zabezpečíme tak, že rekurzívne volanie dovolíme len ak je hodnota indexu i menšia ako počet hodnôt v pole pcisla.

'''Možné riešenie:'''

<source lang="c" line >
int prvocisla[]={2,3,5,7,11,13,17,19,23,29,31,37};

int is_prime4(int n, int i=0)
{
if(n%prvocisla[i]==0)
return 0;
if(i<223 && n>pow(prvocisla[i],2))
return is_prime4(n,i+1);
else
return 1;
}
</source>

'''Vzorové riešenie'''

Uvádzame postupnosť volaní funkcie '''is_prime4(31)'''

{| class=wikitable
|+
!Vnorenie
!Volaná funkcia
!prvocisla[i]
!n%prvocisla[i]
!rekurzívne volanie
|-
|0
|is_prime(31,0)
|2
|31%2=1
|is_prime(31,1)
|-
|1
|is_prime(31,1)
|3
|31%3=1
|is_prime(31,2)
|-
|2
|is_prime(31,2)
|5
|31%5=1
|is_prime(31,3)
|-
|3
|is_prime(31,3)
|7
|31%7=3
|is_prime(31,4)
|-
| 4
| is_prime(31,4)
| 11
| n.a.
| neplatí podmienka n>prvocisla[i]^2<br/>n=31, i=4, prvocisla[i]=11<br/>funkcia vracia hodnotu '''1'''
|-
| 3
| návrat na is_prime(31,3)
| 7
| n.a.
| spätný rekurzívny chod
|-
| 2
| návrat na is_prime(31,2)
| 5
| n.a.
| spätný rekurzívny chod
|-
| 1
| návrat na is_prime(31,1)
| 3
| n.a.
| spätný rekurzívny chod
|-
| 0
| návrat na is_prime(31,0)
| 2
| n.a.
| spätný rekurzívny chod
|}
====Porovnanie efektivity navrhovaných algoritmov====
Skôr ako budeme porovnávať ukázané algoritmy, poznamenajme, že tento spôsob zisťovania prvočíselnosti je pre veľké čísla veľmi neefektívny. Pri 8-cifernom čísle trvá výpočet funkcie is_prime približne 230 s. Pre zisťovanie prvočíselnosti existujú špeciálne algoritmy, napr. [http://en.wikipedia.org/wiki/AKS_primality_test ASK test], [http://en.wikipedia.org/wiki/Solovay%E2%80%93Strassen_primality_test Test Solovay-Strassena], [http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test Test Millera-Rabina] a iné.
V nasledujúcej tabuľke a na obrázku sú výsledky porovnania efektívnosti týchto algoritmov pri hľadaní prvočísel na intervale (100,n) kde n sme menili od 50 000 do 2 000 000. V tabuľke ani v grafe nie je zahrnutá funkcia is_prime1, pretože pri n=100 000 pri rekurzívnom volaní funkcia neočakávane skončila.
Aby sme mohli porovnávať aj funkciu is_prime4, musíme do poľa ''prvocisla'' pridať všetky prvočísla, ktoré sú menšie ako <math>\sqrt{n_{max}}</math>, kde n_max je v našom prípade 2 000 000. Pole ''prvocisla'' obsahuje prvých 233 prvočísel:
<source lang="c">
int prvocisla[]={
2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,
191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,
397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,
617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,
857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,
1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,
1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423};
</source>
Naprogramované funkcie sme testovali nasledovne:

<source lang="c">
#include <iostream.h>
#include <time.h>

int main()
{
clock_t start, end;
double elapsed;
int n;
n=50000; //100000, 200000, ... 2000000
start = clock();
for(int i=100;i<n;i++)
is_prime(i);
end = clock();
elapsed = ((double) (end - start)) / CLOCKS_PER_SEC;
cout<<elapsed<<endl;
}
</source>
{| class=datatable
|+Tabuľka nameraných časov behu funkcií
|-
!n [tisíc]
!is_prime_2 t[s]
!is_prime t[s]
!is_prime4 t[s]
|-
|50
|0,16
|0,086
|0,061
|-
|100
|0,398
|0,134
|0,126
|-
|200
|1,034
|0,345
|0,304
|-
|500
|1,245
|1,237
|0,958
|-
|1000
|3,275
|3,264
|2,349
|-
|1500
|17,203
|5,831
|3,9
|-
|2000
|26
|8,6
|5,82
|}

<pLines ymin=0 ymax=27 colors=FF0000,00FF00,0000FF size=600x250 plots legend>
,is_prime2, is_prime, is_prime4
50 tis, 0.16, 0.08, 0.061
100 tis, 0.398, 0.134, 0.126
200 tis, 1.034, 0.345, 0.304
500 tis, 1.245, 1.237, 0.958
1 mil, 3.275, 3.264, 2.349
1.5 mil, 17.203, 5.831, 3.9
2 mil, 26, 8.6, 5.82
</pLines>

Podobné časy pri nižších hodnotách n sú dané tým, že vzdialenosť susedných prvočísel je väčšia pri vyšších prvočíslach. Z grafu taktiež vidieť účinok optimalizácie algoritmu.

==Odkazy==
*http://sk.wikipedia.org/wiki/Zoznam_prvo%C4%8D%C3%ADsiel
*http://www.prime-numbers.org/

Štruktúry (riešené príklady)

2021-02-13T21:11:34Z

Juraj:

{{Draft}}
{{Skripta programovanie (zbierka úloh)}}
__TOC__

==Štruktúra Zlomok==
'''Úloha:'''

Zostavte program, ktorý pomôže pri práci so zlomkami – bude vedieť zlomok skrátiť a vypísať ho v čo najvhodnejšom tvare. Program načíta dva zlomky, každý hneď po načítaní upravene vypíše, ďalej vypíše ich súčin, súčet a podiel:
#Zostavte funkciu na načítanie zlomku z klávesnice a funkciu, ktorá vypíše zlomok na obrazovku v tvare „a/b“, napr. „3/4“. Postupne ju zdokonaľujte:
##V prípade, že zlomok má celú časť, vypíše ho v tvare „a b/c“, napr. namiesto „9/4“ bude písať „2 1/4“.
##V prípade, že jeho zvyšná časť je nulová, nebude ju vypisovať, napr. namiesto „6/2“ nebude písať „3 0/2“, ale iba „3“ a podobne, namiesto „0/2“ iba „0“.
#Vytvorte si pomocnú funkciu, ktorá zjednoduší (skráti) zlomok, napr. „36/48“ prevedie na „3/4“ a obohaťte ňou funkciu pre vypísanie zlomku (aby sa zlomok vypisoval už v zjednodušenom tvare).
#Zostavte funkcie, ktoré vypočítajú súčin, súčet a podiel dvoch zlomkov a použite ich v hlavnom programe.

'''Vzorový vstup:'''
5 4
1 1/4
6 8
3/4

'''Vzorový výstup:'''
sucin: 15/16
sucet: 2
podiel: 1 2/3

Cieľom je precvičiť si prácu so štruktúrou – bolo by vhodné ju v programe využiť.
Funkcia na načítanie zlomku môže využiť referenciu alebo štruktúru ako návratovú hodnotu. Pre krátenie zlomku môžeme využiť referenciu a pre matematické operácie so zlomkami zase návratovú hodnotu.

Pre krátenie zlomku treba funkciu na najväčší spoločný deliteľ – použijeme Euklidov algoritmus postupného odpočítavania menšieho čísla od väčšieho a jeho zdokonalenie cez operáciu modulo.
Pri matematických funkciách môžeme využiť akýsi „akoby konštruktor“ na vytvorenie zlomku, no nie je to nutné.

'''Možné riešenie:'''
<source lang="c" line>
#include <iostream.h>

using namespace std;

struct TZlomok { int citatel, menovatel; };
void CitajZlomok(TZlomok &z)
{
cin >> z.citatel;
cin >> z.menovatel;
}

int NSD(int a, int b)
{
while (b)
{
int c = a % b;
a = b;
b = c;
}
return a;
}

void SkratZlomok(TZlomok &z)
{
int nsd = NSD(z.citatel, z.menovatel);
z.citatel /= nsd;
z.menovatel /= nsd;
}

void VypisZlomok(TZlomok z)
{
SkratZlomok(z);
int cela_cast = z.citatel / z.menovatel;
if (cela_cast)
{
cout << cela_cast;
int zvysok = z.citatel % z.menovatel;
if (zvysok) cout << " " << zvysok << "/" << z.menovatel;
}
else
{
cout << z.citatel;
if (z.citatel) // ak je nula, napise len ju a nie napr. 0/1
cout << "/" << z.menovatel;
}
cout << endl;
}

TZlomok Zlomok(int cit, int men)
{
TZlomok z;
z.citatel = cit;
z.menovatel = men;
SkratZlomok(z);
return z;
}

TZlomok SucinZlomkov(TZlomok z1, TZlomok z2)
{
return Zlomok(z1.citatel * z2.citatel, z1.menovatel * z2.menovatel);
}

TZlomok SucetZlomkov(TZlomok z1, TZlomok z2)
{
return Zlomok(z1.citatel * z2.menovatel + z2.citatel * z1.menovatel,
z1.menovatel * z2.menovatel);
}

TZlomok PodielZlomkov(TZlomok z1, TZlomok z2)
{
return Zlomok(z1.citatel * z2.menovatel, z1.menovatel * z2.citatel);
}

int main()
{
TZlomok z1, z2;
CitajZlomok(z1); VypisZlomok(z1);
CitajZlomok(z2); VypisZlomok(z2);
cout << "sucin: "; VypisZlomok(SucinZlomkov(z1, z2));
cout << "sucet: "; VypisZlomok(SucetZlomkov(z1, z2));
cout << "podiel: "; VypisZlomok(PodielZlomkov(z1, z2));
return 0;
}
</source>

==Zásobník - pamäť typu LIFO==
===Intepreter postfixových aritmetických výrazov===
'''Zadanie:'''

Vytvorte program v jazyku C, ktorý po spustení načíta od používateľa postfixový aritmetický výraz, vyhodnotí ho, vypíše jeho hodnotu do konzoly (na monitor) a skončí.

'''Analýza:'''

V postfixovom aritmetickom výraze sa operátor zapisuje vždy po svojich dvoch operandoch, ako to môžeme vidieť v nasledujúcom takomto výraze
5 9 8 + 4 6 * * 7 + *
ktorý má hodnotu 2075.
Každý infixový aritmetický výraz, môže byť prepísaný na postfixový. Infixová verzia uvedeného postfixového výrazu je nasledovná:
5 * ( ( (9 + 8) * (4 * 6) ) + 7)
a tá má samozrejme po vyhodnotení rovnakú hodnotu 2075.

Pomocou abstraktného dátového typu (ADT) zásobníka sa dajú veľmi dobre vyhodnocovať práve postfixové aritmetické výrazy. Každý operátor si z vrcholu zásobníka načíta svoje dva operandy a po vykonaní operácie na nich vráti jej výsledok namiesto týchto dvoch operandov na vrchol zásobníka (využitie princípu dátovej štruktúry typu LIFO). Nasledujúci obrázok demonštruje tento jednoduchý princíp na vyhodnocovaní vyššie uvedeného postfixového aritmetického výrazu.

{| border="1" class=wikitable
|+ Spracovanie postfixového výrazu 5 9 8 + 4 6 * * 7 + *
|-
!index v pamati zásobníka<hr/>číslo kroku
! 0
! 1
! 2
! 3
! 4
! operácia
|-
| 1
| 5
|
|
|
|
|
|-
| 2
| 5
| 9
|
|
|
|
|-
| 3
| 5
| 9
| 8
|
|
|
|-
| 4
| 5
|
|
|
|
| 8+9
|-
| 5
| 5
| 17
|
|
|
|
|-
| 6
| 5
| 17
| 4
|
|
|
|-
| 7
| 5
| 17
| 4
| 6
|
|
|-
| 8
| 5
| 17
|
|
|
| 6 * 4
|-
| 9
| 5
| 17
| 24
|
|
|
|-
| 10
| 5
|
|
|
|
| 24*17
|-
| 11
| 5
| 408
|
|
|
|
|-
| 12
| 5
| 408
| 7
|
|
|
|-
| 13
| 5
|
|
|
|
| 408 + 7
|-
| 14
| 5
| 415
|
|
|
|
|-
| 15
|
|
|
|
|
| 415 * 5
|-
| 16
| 2075
|
|
|
|
|
|}
Tabuľka ukazuje použitie zásobníka reprezentovaného celočíselným poľom (zasobnik.pamat[ ]) pre vyhodnotenie postfixového výrazu 5 9 8 + 4 6 * * 7 + * uloženého v znakovom poli (vyraz[ ]). Tento výraz postupne prechádzame zľava doprava. Ak narazíme na znak reprezentujúci číslo, vložíme ho na vrchol zásobníka (zasobnik.pamat[zasobnik.vrchol]), ak narazíme na znak reprezentujúci operátor, potom vyberieme z vrcholu zásobníka 2 operandy, aplikujeme na ne operátor a namiesto týchto dvoch operandov vložíme na vrchol zásobníka výsledok samotnej operácie.
Na reprezentáciu zásobníka použijeme štruktúru LIFO. Pre základné operácie so zásobníkom, vloženie položky na vrchol zásobníka a vybratie položky z jeho vrcholu, si vytvoríme dve funkcie:
<source lang="c">
stav zasobnika push(LIFO &zasobnik, int x);
int pop(LIFO &zasobnik);
</source>
'''Príklad vstupu do programu:'''

5 9 8 + 4 6 * * 7 + *

'''Príklad výstupu z programu:'''

2075

'''Možné riešenie:'''

<source lang="c" line>
#include<iostream>
#include <string.h>
using namespace std;

#define MAX_PAMAT 40

enum stav_zasobnika{OK=-1, FULL=INT_MAX, EMPTY=INT_MIN};

typedef struct {
double pamat[ MAX_PAMAT ];
int vrchol;
} LIFO;

/** pre ucely ladenia */
void show(LIFO &zasobnik){
cout<<"|";
for(int i=0; i<zasobnik.vrchol; i++) {
cout<<zasobnik.pamat[i]<<"|";
}
cout<<endl;
}

//VLOZI novu polozku 'x' do pola 'zasobnik.pamat' (do zasobnika) a zvacsi indexovu premennu //'zasobnik.vrchol' o 1
stav_fronty push(LIFO &zasobnik,double x) {

if(zasobnik.vrchol<MAX_PAMAT)
zasobnik.pamat[zasobnik.vrchol++]=x;
else
return FULL;
return OK;
}

//zmensi indexovu premennu 'zasobnik.vrchol' o 1 a VYBERIE poslednu vlozenu polozku z pola //'zasobnik.pamat' (zo zasobnika)
double pop(LIFO &zasobnik) {
if(zasobnik.vrchol>0)
return zasobnik.pamat[--zasobnik.vrchol];
else
return EMPTY;
}

int main()
{
LIFO f; //deklaracia strukturovej premennej typu 'LIFO' reprezentujucej zasobnik
f.vrchol=0;
int i,j,N;
char vyraz[40];

//cout<<"Vlozte postfixovy vyraz na vyhodnotenie:\n";
cin.getline(vyraz,39)

N=(int)strlen(vyraz); //v 'X' je dlzka nacitaneho retazca zo standardneho vstupu

// v cykle 'for' prechadzame vstupny vyraz ulozeny v poli 'vyraz' zlava doprava.
// Ak narazime na znak reprezentujuci cislo, vlozime ho na vrchol
// zasobnika ('f.pamat[f.vrchol]'), ak narazime na znak
// reprezentujuci operator, potom vyberieme z vrcholu zasobnika 2 operandy, aplikujeme na ne
// operator a namiesto tychto dvoch operandov vlozime na vrchol zasobnika vysledok samotnej
// operacie

for(i=0; i<N; i++)
{
if (vyraz[i]==' ') {
continue;
}
if (vyraz[i]=='+') {
push(f, (pop(f) + pop(f)));
continue;
}

if (vyraz[i]=='*') {
push(f, (pop(f) * pop(f)));
continue;
}

if (vyraz[i]=='/') {
push(f, (pop(f) / pop(f)));
continue;
}

if (vyraz[i]=='-') {
push(f, (pop(f) - pop(f)));
continue;
}

j=0;
while((vyraz[i]>='0' && vyraz[i]<='9') || vyraz[i]=='.') {
buffer[j] = vyraz[i];
i++;
j++;
}
buffer[j]=0;
x = atof (buffer);
if(FULL == push(f,x)){
cout<<"LIFO overflow";
break;
}
}
//na vrchole zasobnika je uz vysledok vyhodnoteneho postfixoveho aritmetickeho vyrazu, takze ho
//vypiseme
cout<<pop(f);
return 0;
}
</source>

Štruktúry (riešené príklady)

2021-02-13T21:10:13Z

Juraj:

{{Draft}}
{{Skripta programovanie (zbierka úloh)}}
__TOC__

==Štruktúra Zlomok==
'''Úloha:'''

Zostavte program, ktorý pomôže pri práci so zlomkami – bude vedieť zlomok skrátiť a vypísať ho v čo najvhodnejšom tvare. Program načíta dva zlomky, každý hneď po načítaní upravene vypíše, ďalej vypíše ich súčin, súčet a podiel:
#Zostavte funkciu na načítanie zlomku z klávesnice a funkciu, ktorá vypíše zlomok na obrazovku v tvare „a/b“, napr. „3/4“. Postupne ju zdokonaľujte:
##V prípade, že zlomok má celú časť, vypíše ho v tvare „a b/c“, napr. namiesto „9/4“ bude písať „2 1/4“.
##V prípade, že jeho zvyšná časť je nulová, nebude ju vypisovať, napr. namiesto „6/2“ nebude písať „3 0/2“, ale iba „3“ a podobne, namiesto „0/2“ iba „0“.
#Vytvorte si pomocnú funkciu, ktorá zjednoduší (skráti) zlomok, napr. „36/48“ prevedie na „3/4“ a obohaťte ňou funkciu pre vypísanie zlomku (aby sa zlomok vypisoval už v zjednodušenom tvare).
#Zostavte funkcie, ktoré vypočítajú súčin, súčet a podiel dvoch zlomkov a použite ich v hlavnom programe.

'''Vzorový vstup:'''
5 4
1 1/4
6 8
3/4

'''Vzorový výstup:'''
sucin: 15/16
sucet: 2
podiel: 1 2/3

Cieľom je precvičiť si prácu so štruktúrou – bolo by vhodné ju v programe využiť.
Funkcia na načítanie zlomku môže využiť referenciu alebo štruktúru ako návratovú hodnotu. Pre krátenie zlomku môžeme využiť referenciu a pre matematické operácie so zlomkami zase návratovú hodnotu.

Pre krátenie zlomku treba funkciu na najväčší spoločný deliteľ – použijeme Euklidov algoritmus postupného odpočítavania menšieho čísla od väčšieho a jeho zdokonalenie cez operáciu modulo.
Pri matematických funkciách môžeme využiť akýsi „akoby konštruktor“ na vytvorenie zlomku, no nie je to nutné.

'''Možné riešenie:'''
<source lang="c" line>
#include <iostream.h>

struct TZlomok { int citatel, menovatel; };
void CitajZlomok(TZlomok &z)
{
cin >> z.citatel;
cin >> z.menovatel;
}

int NSD(int a, int b)
{
while (b)
{
int c = a % b;
a = b;
b = c;
}
return a;
}

void SkratZlomok(TZlomok &z)
{
int nsd = NSD(z.citatel, z.menovatel);
z.citatel /= nsd;
z.menovatel /= nsd;
}

void VypisZlomok(TZlomok z)
{
SkratZlomok(z);
int cela_cast = z.citatel / z.menovatel;
if (cela_cast)
{
cout << cela_cast;
int zvysok = z.citatel % z.menovatel;
if (zvysok) cout << " " << zvysok << "/" << z.menovatel;
}
else
{
cout << z.citatel;
if (z.citatel) // ak je nula, napise len ju a nie napr. 0/1
cout << "/" << z.menovatel;
}
cout << endl;
}

TZlomok Zlomok(int cit, int men)
{
TZlomok z;
z.citatel = cit;
z.menovatel = men;
SkratZlomok(z);
return z;
}

TZlomok SucinZlomkov(TZlomok z1, TZlomok z2)
{
return Zlomok(z1.citatel * z2.citatel, z1.menovatel * z2.menovatel);
}

TZlomok SucetZlomkov(TZlomok z1, TZlomok z2)
{
return Zlomok(z1.citatel * z2.menovatel + z2.citatel * z1.menovatel,
z1.menovatel * z2.menovatel);
}

TZlomok PodielZlomkov(TZlomok z1, TZlomok z2)
{
return Zlomok(z1.citatel * z2.menovatel, z1.menovatel * z2.citatel);
}

void main()
{
TZlomok z1, z2;
CitajZlomok(z1); VypisZlomok(z1);
CitajZlomok(z2); VypisZlomok(z2);
cout << "sucin: "; VypisZlomok(SucinZlomkov(z1, z2));
cout << "sucet: "; VypisZlomok(SucetZlomkov(z1, z2));
cout << "podiel: "; VypisZlomok(PodielZlomkov(z1, z2));
}
</source>

==Zásobník - pamäť typu LIFO==
===Intepreter postfixových aritmetických výrazov===
'''Zadanie:'''

Vytvorte program v jazyku C, ktorý po spustení načíta od používateľa postfixový aritmetický výraz, vyhodnotí ho, vypíše jeho hodnotu do konzoly (na monitor) a skončí.

'''Analýza:'''

V postfixovom aritmetickom výraze sa operátor zapisuje vždy po svojich dvoch operandoch, ako to môžeme vidieť v nasledujúcom takomto výraze
5 9 8 + 4 6 * * 7 + *
ktorý má hodnotu 2075.
Každý infixový aritmetický výraz, môže byť prepísaný na postfixový. Infixová verzia uvedeného postfixového výrazu je nasledovná:
5 * ( ( (9 + 8) * (4 * 6) ) + 7)
a tá má samozrejme po vyhodnotení rovnakú hodnotu 2075.

Pomocou abstraktného dátového typu (ADT) zásobníka sa dajú veľmi dobre vyhodnocovať práve postfixové aritmetické výrazy. Každý operátor si z vrcholu zásobníka načíta svoje dva operandy a po vykonaní operácie na nich vráti jej výsledok namiesto týchto dvoch operandov na vrchol zásobníka (využitie princípu dátovej štruktúry typu LIFO). Nasledujúci obrázok demonštruje tento jednoduchý princíp na vyhodnocovaní vyššie uvedeného postfixového aritmetického výrazu.

{| border="1" class=wikitable
|+ Spracovanie postfixového výrazu 5 9 8 + 4 6 * * 7 + *
|-
!index v pamati zásobníka<hr/>číslo kroku
! 0
! 1
! 2
! 3
! 4
! operácia
|-
| 1
| 5
|
|
|
|
|
|-
| 2
| 5
| 9
|
|
|
|
|-
| 3
| 5
| 9
| 8
|
|
|
|-
| 4
| 5
|
|
|
|
| 8+9
|-
| 5
| 5
| 17
|
|
|
|
|-
| 6
| 5
| 17
| 4
|
|
|
|-
| 7
| 5
| 17
| 4
| 6
|
|
|-
| 8
| 5
| 17
|
|
|
| 6 * 4
|-
| 9
| 5
| 17
| 24
|
|
|
|-
| 10
| 5
|
|
|
|
| 24*17
|-
| 11
| 5
| 408
|
|
|
|
|-
| 12
| 5
| 408
| 7
|
|
|
|-
| 13
| 5
|
|
|
|
| 408 + 7
|-
| 14
| 5
| 415
|
|
|
|
|-
| 15
|
|
|
|
|
| 415 * 5
|-
| 16
| 2075
|
|
|
|
|
|}
Tabuľka ukazuje použitie zásobníka reprezentovaného celočíselným poľom (zasobnik.pamat[ ]) pre vyhodnotenie postfixového výrazu 5 9 8 + 4 6 * * 7 + * uloženého v znakovom poli (vyraz[ ]). Tento výraz postupne prechádzame zľava doprava. Ak narazíme na znak reprezentujúci číslo, vložíme ho na vrchol zásobníka (zasobnik.pamat[zasobnik.vrchol]), ak narazíme na znak reprezentujúci operátor, potom vyberieme z vrcholu zásobníka 2 operandy, aplikujeme na ne operátor a namiesto týchto dvoch operandov vložíme na vrchol zásobníka výsledok samotnej operácie.
Na reprezentáciu zásobníka použijeme štruktúru LIFO. Pre základné operácie so zásobníkom, vloženie položky na vrchol zásobníka a vybratie položky z jeho vrcholu, si vytvoríme dve funkcie:
<source lang="c">
stav zasobnika push(LIFO &zasobnik, int x);
int pop(LIFO &zasobnik);
</source>
'''Príklad vstupu do programu:'''

5 9 8 + 4 6 * * 7 + *

'''Príklad výstupu z programu:'''

2075

'''Možné riešenie:'''

<source lang="c" line>
#include<iostream>
#include <string.h>
using namespace std;

#define MAX_PAMAT 40

enum stav_zasobnika{OK=-1, FULL=INT_MAX, EMPTY=INT_MIN};

typedef struct {
double pamat[ MAX_PAMAT ];
int vrchol;
} LIFO;

/** pre ucely ladenia */
void show(LIFO &zasobnik){
cout<<"|";
for(int i=0; i<zasobnik.vrchol; i++) {
cout<<zasobnik.pamat[i]<<"|";
}
cout<<endl;
}

//VLOZI novu polozku 'x' do pola 'zasobnik.pamat' (do zasobnika) a zvacsi indexovu premennu //'zasobnik.vrchol' o 1
stav_fronty push(LIFO &zasobnik,double x) {

if(zasobnik.vrchol<MAX_PAMAT)
zasobnik.pamat[zasobnik.vrchol++]=x;
else
return FULL;
return OK;
}

//zmensi indexovu premennu 'zasobnik.vrchol' o 1 a VYBERIE poslednu vlozenu polozku z pola //'zasobnik.pamat' (zo zasobnika)
double pop(LIFO &zasobnik) {
if(zasobnik.vrchol>0)
return zasobnik.pamat[--zasobnik.vrchol];
else
return EMPTY;
}

int main()
{
LIFO f; //deklaracia strukturovej premennej typu 'LIFO' reprezentujucej zasobnik
f.vrchol=0;
int i,j,N;
char vyraz[40];

//cout<<"Vlozte postfixovy vyraz na vyhodnotenie:\n";
cin.getline(vyraz,39)

N=(int)strlen(vyraz); //v 'X' je dlzka nacitaneho retazca zo standardneho vstupu

// v cykle 'for' prechadzame vstupny vyraz ulozeny v poli 'vyraz' zlava doprava.
// Ak narazime na znak reprezentujuci cislo, vlozime ho na vrchol
// zasobnika ('f.pamat[f.vrchol]'), ak narazime na znak
// reprezentujuci operator, potom vyberieme z vrcholu zasobnika 2 operandy, aplikujeme na ne
// operator a namiesto tychto dvoch operandov vlozime na vrchol zasobnika vysledok samotnej
// operacie

for(i=0; i<N; i++)
{
if (vyraz[i]==' ') {
continue;
}
if (vyraz[i]=='+') {
push(f, (pop(f) + pop(f)));
continue;
}

if (vyraz[i]=='*') {
push(f, (pop(f) * pop(f)));
continue;
}

if (vyraz[i]=='/') {
push(f, (pop(f) / pop(f)));
continue;
}

if (vyraz[i]=='-') {
push(f, (pop(f) - pop(f)));
continue;
}

j=0;
while((vyraz[i]>='0' && vyraz[i]<='9') || vyraz[i]=='.') {
buffer[j] = vyraz[i];
i++;
j++;
}
buffer[j]=0;
x = atof (buffer);
if(FULL == push(f,x)){
cout<<"LIFO overflow";
break;
}
}
//na vrchole zasobnika je uz vysledok vyhodnoteneho postfixoveho aritmetickeho vyrazu, takze ho
//vypiseme
cout<<pop(f);
return 0;
}
</source>

Jazyk C - reťazce

2020-11-14T18:27:36Z

Juraj:

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
Reťazce sú vlastne jednorozmerné pole znakov ukončené nulovým znakom '\0'. Reťazec teda obsahuje znaky a ako posledný znak je nulový znak '\0'.

Nasledujúce deklarácia a inicializácia vytvoria reťazec pozostávajúci zo slova „Ahoj“. Každý reťazec musí byť ukončený nulovým znakom '\0', preto veľkosť poľa znakov obsahujúceho reťazec je vždy o +1 väčší ako je počet písmen vo výraze.

'''Iniciálizácia'''
<source>
char slovo[5] = {'A', 'h', 'o', 'j','\0'};
</source>

Ak budete postupovať podľa pravidla inicializácie poľa, môžete vyššie uvedený príkaz napísať nasledovne.
<source>
char slovo[5] = "Ahoj";
</source>

Prezentácia pamäte vyššie definovaného reťazca v C.
{|class="wikitable" style="text-align: center;
|-
| Index || 0 || 1 || 2 || 3 || 4
|-
| Premenná || A || h || o || j || \0
|-
|}

V skutočnosti neukladáte nulový znak na koniec reťazcovej konštanty. Keď inicializuje pole, kompilátor C ho automaticky umiestni '\ 0' na koniec reťazca. Pokúsme sa vypísať vyššie uvedený reťazec.
<source lang="c" line>
#include <stdio.h>

int main () {

char slovo[5] = {'A', 'h', 'o', 'j','\0'};
/*poprípade môžme pole inicializovať takto:
char slovo[5] = "Ahoj";
*/

printf("Vypisane slovo: %s\n", slovo);
return 0;
}
</source>
Vystup.
<source>
Vypisane slovo: Ahoj
</source>

C podporuje širokú škálu funkcií, ktoré manipulujú s reťazcami ukončenými nulovou hodnotou.
{|class="wikitable" style="text-align: center;
|-
! !! Funkcia !! Účel
|-
| 1 || [[Strcpy (jazyk C)|strcpy (s1);]] || Skopíruje reťazec s2 do reťazca s1.
|-
| 2 || [[Strcat(jazyk C)|strcat (s1);]] || Pripojí reťazec s2 na koniec reťazca s1.
|-
| 3 || [[Strlen (jazyk C)|strlen (s1);]] || Vráti dĺžku reťazca s1.
|-
| 4 || [[Strcmp (jazyk C)|strcmp (s1);]] || Vráti 0, ak sú s1 a s2 rovnaké; menej ako 0, ak s1 <s2; väčšie ako 0, ak s1> s2.
|-
| 5 || [[Strchr (jazyk C)|strchr (s1);]] || Vracia ukazovateľ na prvý výskyt znaku ch v reťazci s1.
|-
| 6 || [[Strstr (jazyk C)|strstr (s1);]] || Vráti ukazovateľ na prvý výskyt reťazca s2 v reťazci s1.
|-
|}

Nasledujúci príklad používa niektoré z vyššie uvedených funkcií.
<source lang="c" line>
#include <stdio.h>
#include <string.h>
int main () {

char retazec1[12] = "Ahoj";
char retazec2[12] = "svet";
char retazec3[12];
int dlzka;

/* Skopírovanie reťazca 1 do reťazca 3 */
strcpy(retazec3, retazec1);
printf("strcpy( retazec3, retazec1) : %s\n", retazec3);

/* "Prilepenie" retazec2 za retazec1*/
strcat( retazec1, retazec2);
printf("strcat( retazec1, retazec2): %s\n", retazec1);

/* Celková dĺžka reťazca 1 po pripojení reťazca 2*/
dlzka = strlen(retazec1);
printf("strlen(retazec1): %d\n", dlzka);

return 0;
}
</source>
Vystup.
<source>
strcpy( retazec3, retazec1): Hello
strcat(retazec1, retazec2): HelloWorld
strlen(retazec1): 10
</source>

Uvedenie aplikácie eAurela do produkcie

2020-10-19T19:33:52Z

Juraj: Zamkol stránku „Uvedenie aplikácie eAurela do produkcie“ ([Úprava=Povoliť iba správcom] (na neurčito) [Presun=Povoliť iba správcom] (na neurčito))

[[Kategória:Študentské práce]][[Kategória:Bakalárske práce]][[Kategória:Informatika]]

{{Praca_uvod|5|Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému|Informačný systém Sensorical|Analýza požiadaviek a štruktúra klientskej aplikácie|Nástroje použité na vývoj aplikácie eAurela|Implementácia aplikácie eAurela|Uvedenie aplikácie eAurela do produkcie}}

__TOC__

= =

Aby bola aplikácia dostupná a spustiteľná pre bežného používateľa, je potrebné vykonať build aplikácie. Tento proces slúži pre transformáciu zdrojových kódov v spustiteľnú aplikáciu. Keďže na vývoj aplikácie boli použité dva frameworky, build sa musí vykonať pre každý framework zvlášť. V tejto kapitole sú opísané postupy a nástroje použité pri vytváraní spustiteľnej aplikácie pre jednotlivé platformy. Všetky uvedené zmeny v zdrojovom kóde sa týkajú súboru ''package.json''.

== Buildovanie reactovej aplikácie ==

Keďže electron má zobrazovať reactovú časť aplikácie, je potrebné vykonať build reactovej časti ako prvý. React má zabudovaný skript pre vykonanie buildu, takže nie je potrebné pridať ďalšiu knižnicu (viď kód [[#lst:package|[lst:package]]]). Najdôležitejšia vec pri vykonaní buildu reactovej aplikácie je nastavenie vlastnosti ''homepage''. Táto vlastnosť je kľúčová pre React. Vďaka nej presne vie, kde sa spustiteľná aplikácia nachádza. V prípade, že by sa táto vlastnosť neuviedla, nebolo by možné vidieť reactovú časť aplikácie vo vnútri electronovej aplikácie.

<source lang="javascript">
"homepage": "./",
</source>
Kód 5.1: Definovanie vlastnosti homepage v aplikácii eAurela

Po zadefinovaní vlastnosti ''homepage'' je všetko pripravené na spustenie buildovacieho skriptu. Úspešné ukončenie skriptu je zobrazené na obrázku obr. [[#fig:reactBuild|5.1]].

[[File:bpaz_reactBuild.png|thumb|500px|Obr 5.1 Úspešné použitie buildovacieho skriptu pre React<span label="fig:reactBuild"></span>]]

Po úspešnom prebehnutí tohoto skriptu sa v adresári aplikácie eAurela vytvorí nový priečinok s názvom ''build''. Tento priečinok obsahuje všetky statické súbory aplikácie, ktoré sú pripravené na prácu s electronovou časťou aplikácie.

== Buildovanie electronovej aplikácie ==

Po úspešnom prebehnutí buildu v reactovej časti treba vykonať aj build electronovej časti, čo bude mať za výsledok spustiteľnú aplikáciu. Nakoľko Electron neobsahuje žiadny skript určený na buildovanie, bolo nutné použiť externú knižnicu. Použitá bola knižnica ''electron-packager'' (https://github.com/electron/electron-packager). Po nainštalovaní knižnice je potrebné pridať buildovacie skripty do súboru ''package.json'' pre každý operačný systém.

<source lang="javascript">
// buildovací skript pre Mac OS
"package-mac": "electron-packager . --platform=darwin --arch=x64",
// buildovací skript pre Windows
"package-win": "electron-packager . --platform=win32 --arch=x64",
// buildovací skript pre Linux
"package-lin": "electron-packager . --platform=linux --arch=x64"
</source>
Kód 5.2: Skripty pre použitie knižnice electron-packager

Pre zjednodušenie kódu boli uvedené iba povinné parametre jednotlivých skriptov.Prvý parameter (''electron-packager'') hovorí, aby sa spustil práve ''electron-packager''. Druhý parameter (''.'') hovorí, kde sa nachádza zdrojový kód na zverejnenie. Nasledujúce dva parametre označujú práve cieľovú platformu (''–platfrom'') a typ architektúry (''–arch''). Ďalšie voliteľné parametre by mohli byť názov aplikácie (ak nie je uvedený, použije sa názov uvedený pod vlastnosťou ''name'' v súbore ''package.json''), ikona aplikácie a podobne. Úspešný priebeh skriptu ''package-win'' je vyobrazený na obrázku obr. [[#fig:electronBuild|5.2]].

[[File:bpaz_electronBuild.png|thumb|500px|Obr 5.2 Buildovanie aplikácie eAurela pre platformu Windows<span label="fig:electronBuild"></span>]]

Po úspešnom ukončení skriptu sa opäť vytvorí nový priečinok, ktorý obsahuje spustiteľnú aplikáciu, ako aj zdrojový kód.

= Záver =

Výsledkom práce je softvérový produkt s názvom eAurela. Tento softvérový produkt slúži na zobrazenie environmentálnych dát a spravovanie senzorického informačného systému Sensorical.

Aplikácia eAurela je naprogramovaná pomocou moderných internetových technológií. Na vývoj boli použité javascriptové frameworky React.js a Electron.js. Aplikácia je dostupná na operačných systémoch Windows, Linux a Mac OS ako desktopová aplikácia. Po nasadení bude aplikácia dostupná aj ako internetová aplikácia.

Celá aplikácia eAurela pracuje na princípe volania existujúceho API a je určená výhradne používateľom systému Sensorical. Používatelia majú po prihlásení možnosť zvoliť si aplikáciu, respektíve inštaláciu, z ktorej si chcú prezerať namerané senzorické dáta, alebo si administrátori môžu zvoliť aj možnosť spravovania systému. Po vybraní aplikácie si používatelia môžu prezerať buď poslednú dostupnú nameranú hodnotu, alebo si môžu prezrieť grafické vyobrazenie nameraných hodnôt za nimi vybrané obdobie. Zobrazované dáta sú vždy aktuálne, zo servera sa získavajú pri voľbe aplikácie, alebo pri zmenení formy zobrazenia. Administrátori systému môžu spravovať a upravovať údaje uložené na serveri, môžu meniť používateľom prístupové práva v systéme, poprípade heslo. Administrátori majú možnosť spravovať údaje aj v rámci konkrétnej aplikácie. Tam majú možnosť registrovať do systému nových používateľov, alebo z aplikácie nejakého odobrať. Taktiež môžu upravovať prístupové práva v rámci aplikácie, alebo môžu meniť informácie o senzoroch, ako napríklad názov senzora a podobne.

Vzhľadom na vyššie uvedené funkcionality aplikácie eAurela je možné tvrdiť, že aplikácia spĺňa požiadavky, ktoré jej boli určené. V budúcnosti bude aplikácia rozšírená o rôzne funkcie, napríklad budú doplnené funkcionality v časti spravovania systému, ktoré počas vývoja neboli dostupné na strane servera ako napríklad zmenenie rozmiestnenia senzorov v oblasti, vytvorenie novej spoločnosti alebo aplikácie, novej oblasti, sektora alebo senzora. Taktiež, ak to bude vyžadované, bude možné rozšíriť podporu aplikácie eAurela pre ďalšie jazykové mutácie.

=Zoznam použitej literatúry=
[1] G. Gašpar a M. Skovajsa. “WOOD BIOMASS WIRELESS TEMPERATURE MONITORING SYSTEM”. In: Proceedings of INTERNATIONAL MASARYK CONFERENCE FOR PH.D. STUDENTS AND YOUNG RESEARCHERS. 2015, s. 2028–2034. isbn: 978-80-87952-12-2. doi: null.

[2] J. Ďuďák, M. Skovajsa a I. Sládek. “UTILIZATION OF NSORIC SYSTEM FOR MONITORING OF ECOLOGICAL BUILDING INSULATIONS”. In: Proceedings of INTERNATIONAL MASARYK CONFERENCE FOR PH.D. STUDENTS AND YOUNG RESEARCHERS. 2015, s. 2028–2034. isbn: 978-80-87952-12-2. doi: null.

[3] Electronjs. Electron Documentation. url: https://electronjs.org/docs/tutorial/support. (cit: 28.12.2019).

[4] Reactjs. JavaScript Environment Requirements. url: https://reactjs.org/docs/javascript-environment-requirements.html. (cit: 28.12.2019).

[5] David Čápka. Lekce 2 - UML - Use Case Diagram. url: https://www.itnetwork.cz/navrh/uml/uml-use-case-diagram. (cit: 28.12.2019).

[6] Reactjs. Primary Components. url: https://reactjs.org/docs/introducing-jsx.html. (cit: 31.12.2019).

[7] Jindřich Máca. Lekce 1 - Úvod do React. url: https://www.itnetwork.cz/javascript/react/uvod-do-react. (cit: 27.12.2019).

[8] Reactjs. Components and Props. url: https://reactjs.org/docs/components-and-props.html. (cit: 21.05.2020).

[9] Reactjs. JSX In Depth. url: https://reactjs.org/docs/jsx-in-depth.html. (cit: 21.05.2020).

[10] Reactjs. State and Lifecycle. url: https://reactjs.org/docs/state-and-lifecycle.html. (cit: 21.05.2020).

[11] Electronjs. Electron Application Architecture. url: https://electronjs.org/docs/tutorial/application-architecture. (cit: 29.12.2019).

[12] Electronjs. Writing Your First Electron App. url: https://electronjs.org/docs/tutorial/first-app. (cit: 30.12.2019).

[13] React Training. Introducing JSX. url: https://reacttraining.com/react-router/web/guides/primary-components. (cit: 16.05.2020).

[14] MDN. Promise. url: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise. (cit: 17.05.2020).

Implementácia aplikácie eAurela

2020-10-19T19:33:39Z

Juraj: Zamkol stránku „Implementácia aplikácie eAurela“ ([Úprava=Povoliť iba správcom] (na neurčito) [Presun=Povoliť iba správcom] (na neurčito))

[[Kategória:Študentské práce]][[Kategória:Bakalárske práce]][[Kategória:Informatika]]

{{Praca_uvod|4|Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému|Informačný systém Sensorical|Analýza požiadaviek a štruktúra klientskej aplikácie|Nástroje použité na vývoj aplikácie eAurela|Implementácia aplikácie eAurela|Uvedenie aplikácie eAurela do produkcie}}

__TOC__

= =

Celková implementácia všetkých častí aplikácie eAurela vychádza zo špecifikácie požiadaviek a návrhu štruktúry. Sú tu popísané jednotlivé časti aplikácie, ich funkcionalita a implementácia. Prvá časť tejto kapitoly sa bude venovať používateľskému rozhraniu, následne bude vysvetlené, ako funguje navigácia v aplikácií. Ďalšia časť popisuje komunikáciu so serverom, získavanie a uchovávanie dát. Na záver je v kapitole popísaný dizajn aplikácie a zobrazenie dát pomocou dizajnových prvkov a pomocou grafov z knižnice ''recharts''.

== Používateľské rozhranie ==

Všetky časti aplikácie, ktoré spolu vytvárajú používateľské rozhranie (UI), sú implementované v súlade s navrhnutou štruktúrou v časti [[#structure|[structure]]]. Pomocou týchto častí používateľ pracuje a komunikuje s aplikáciou. Každá časť aplikácie je samostatný reactový komponent, ktorý sa môže skladať aj z viacerých komponentov. V princípe rozdeľujú tieto komponenty aplikáciu na tri časti:

* prístup k dátam,
* prezentácia dát používateľovi,
* spravovanie systému (iba pre administrátorov).

'''Prístup k dátam'''

Pre prístup k dátam slúžia komponenty ''Home'' a ''Appilist''. Komponent ''Home'' je prvý vykreslený komponent po spustení aplikácie eAurela. Po prihlásení do systému sa zobrazí komponent ''Applist'' (viď obr. [[#fig:HomeUI|1.1]] a obr. [[#fig:ApplistUI|1.2]]).

[[File:bpaz_HomeUI.png|thumb|500px|Obr 4.1 Prihlasovacia obrazovka (komponent ''Home'')<span label="fig:HomeUI"></span>]]

[[File:bpaz_ApplistUI.png|thumb|500px|Obr 4.2 Obrazovka pre výber aplikácie (komponent ''Applist'')<span label="fig:ApplistUI"></span>]]

'''Prezentácia dát používateľovi'''

Po výbere aplikácie zo spoločnosti v komponente ''Applist'' sa vykresľuje komponent ''Sectors''. V tomto komponente si používateľ môže prezerať poslednú nameranú hodnotu zo senzorov v danom sektore, alebo si môže zvoliť vykreslenie grafu, ktorý zobrazuje krivky zo všetkých senzorov za určité obdobie. Tieto dve časti komponentu ''Sectors'' je možné vidieť na obrázkoch obr. [[#fig:SectorsUI|1.3]]. a obr. [[#fig:GraphsUI|1.4]].

[[File:bpaz_SectorsUI.png|thumb|500px|Obr 4.3 Posledné namerané hodnoty v oblasti ''Letné sídlo'' (komponent ''Sectors'')<span label="fig:SectorsUI"></span>]]

[[File:bpaz_GraphsUI.png|thumb|500px|Obr 4.4 Vykreslenie grafu z oblasti ''Letné sídlo'' (komponent ''Sectors'')<span label="fig:GraphsUI"></span>]]

'''Spravovanie systému'''

Z funkčých požiadaviek R02 a R04 vyplýva, že administrátori systému budú mať možnosť spravovať systém cez aplikáciu eAurela. V prípade, že je používateľ na serveri pre autorizáciu uvedený ako administrátor, v komponente ''Applist'' po kliknutí na ''Možnosti'' sa mu zobrazí možnosť prejsť do časti spravovania tohto serveru. Podobne aj v komponente ''Sectors'' sa používateľovi zobrazí možnosť spravovania danej aplikácie v prípade, že má na serveri aplikácie uvedené administrátorské oprávnenia.

[[File:bpaz_AuthAdminUI.png|thumb|500px|Obr 4.5 Spravovanie serveru pre autorizáciu (komponent ''AuthAdministration'')<span label="fig:AuthAdminUI"></span>]]

[[File:bpaz_ManageAdminUI.png|thumb|500px|Obr 4.6 Spravovanie konkrétnej aplikácie (komponent ''ManageAdministration'')<span label="fig:ManageAdminUI"></span>]]

== Navigácia v aplikácií ==

Jadrom celej aplikácie je knižnica React Router (https://github.com/ReactTraining/react-router). Tá zabezpečuje navigáciu medzi oknami (komponentami) v aplikácii eAurela. Táto knižnica slúži pre vytvorenie navigácie v aplikáciách naprogramovaných vo frameworku React. V jedno-oknových aplikáciach existuje iba jedna HTML stránka. Táto stránka je znovu použitá pri vykreslení rôznych komponentov v závislosti od navigácie. V knižnici React router sú tri primárne kategórie komponentov:

* smerovače (routers), ako <BrowserRouter> a <HashRouter>,
* porovnávače (route matchers), ako <Route> a <Switch>,
* samotná navigácia (navigation), ako <Link>, <NavLink> a <Redirect>.

'''Smerovače'''

Sada ''react-router-dom'' sa používa v internetových projektoch a poskytuje komponenty ''BrowserRouter'' a ''HashRouter''. V aplikácií eAurela je použitá práve sada react-router-dom. Hlavný rozdiel medzi komponentami ''BrowserRouter'' a ''HashRouter'' je spôsob ako pracujú s URL adresou a ako komunikujú s internetovým serverom (Nodejs serverom). ''BrowserRouter'' používa regulárny tvar URL adresy (tak ako ho je možné vidieť v prehliadači). Tento spôsob práce s URL adresou by bol dostačujúci v prípade, že by bola aplikácia zobrazovaná iba v prehliadači. Vzhľadom na to, že aplikácia bude slúžiť aj ako desktopová aplikácia, bolo výhodnejšie použiť práve ''HashRouter''. Ten aktuálnu URL adresu ukladá ako mriežkovú časť (hash portion), teda URL adresa môže vyzerať napríklad '''http://priklad.com/#/hladana/stranka'''. Nakoľko mriežka nie je nikdy posielaná na server, netreba server špeciálne konfigurovať a navigácia bude fungovať v internetovom prehliadači a aj v desktopovej aplikácií. Pre správne použitie smerovača, je potrebné, aby bol umiestnený v jadre komponentovej hierarchie.

'''Porovnávače'''

Existujú dva komponenty pre porovnávanie: ''Switch'' a ''Route''. Keď je vykreslený ''Switch'', prehľadá všetkých potomkov ''Route'', kým nenájde jedného, ktorého adresa sa zhoduje s aktuálnou URL adresou. Ak ho nájde, vykreslí ho a všetky ostatné komponenty ignoruje. Ak nenájde žiadnu zhodu, nevykreslí nič (null).

'''Navigácia'''

React Router poskytuje ''Link'' komponent na vytváranie odkazov v aplikácií. Kedykoľvek je vykreslený ''Link'', vykreslí sa vlastne HTML tag <a>. Komponent ''NavLink'' je špeciálny druh ''Link'' komponentu, ktorému sa môže nastaviť vlastnosť ''active'' v prípade, že sa cesta zhoduje s URL adresou. Kedykoľvek treba vynútiť navigáciu, môže sa použiť komponent ''Redirect''. Keď sa vykreslí, bude navigovať podľa jeho vlastnosti '''to''' . Použitie komponentu ''Redirect'' je ukázané a popísané v kóde [[#lst:ProtectedRoute|[lst:ProtectedRoute]]].

<source lang="javascript">
<HashRouter>
<div className="App">
<Switch>
<Route exact path={"/"} component={Home} />
<ProtectedRoute exact path={"/applist"}
component={AppList}
/>
<ProtectedAppRoute exact path={"/sectors"}
component={Sectors}
/>
</Switch>
</div>
</HashRouter>
</source>
Kód 4.1: Zjednodušená ukážka použitia react-router-dom komponentov v aplikácií

'''Vytvorenie chránenej cesty'''

Ak nastane situácia, kedy je ku komponentu možné pristúpiť iba v určitom prípade (napríklad používateľ musí byť prihlásený, aby získal prístup k určitým častiam aplikácie), treba použiť tzv. chránenú cestu (''ProtectedRoute''). Keďže React Router taký komponent neposkytuje a do aplikácie majú prístup iba prihlásený používatelia, je potrebné chránenú cestu vytvoriť. Chránená cesta sa vytvorí modifikovaním už existujúceho komponentu ''Route''. Vytváranie chránenej cesty je ukázané v kóde [[#lst:ProtectedRoute|[lst:ProtectedRoute]]].

<source lang="javascript">
import React from 'react';
import { Route, Redirect } from 'react-router-dom';
export const ProtectedRoute = ({ component: Component,
path, ...rest }) => {
// v premennej sa uchováva stav, či je používateľ prihlásený
const isAuth = sessionStorage.getItem('isLoggedIn');
return (
<Route // vykreslenie klasického komponentu <Route>
path={path}
{...rest}
render={props => {
return isAuth ?
<Component {...props} {...rest} />
/* ak používateľ nie je prihlásený, vykreslí sa <Redirect>,
ktorý používateľa presmeruje na obrazovku Home */
: <Redirect to="/" />
}} />
)
}
</source>
Kód 4.2: Vytvorenie chránenej cesty z komponentu <nowiki><Route></nowiki>

== Získavanie a uchovávanie dát zo servera ==

Všetky dáta, ktoré aplikácia eAurela získava a prezentuje používateľovi, získava zo vzdialeného servera. Prístup k údajom na serveri zabezpečuje REST API (časť [[#API|[API]]]). Aplikácia neponúka ukladanie dát pre neskoršie zobrazenie, ale vždy zobrazuje aktuálne dáta (funkčné požiadavky R06 a R08).

=== Získavanie dát zo servera ===

Existuje viacero spôsobov, ako komunikovať so vzdialeným serverom v React aplikácií. Väčšina vyžaduje dodatočnú inštaláciu knižnice určenej pre túto komunikáciu. V aplikácii eAurela však bol použitý spôsob priamo dostupný vo frameworku React, bez nutnosti inštalovať dodatočnú knižnicu. Pre túto komunikáciu slúži metóda ''fetch''. Táto metóda preberá minimálne jeden parameter a to práve URL adresu servera. V aplikácii eAurela sa odovzdávajú tejto metóde vždy 2 parametre. Prvý parameter je textový reťazec a predstavuje URL adresu servera. Druhý parameter je objekt, ktorého povinná vlastnosť je metóda (method). Tu sa určí typ metódy (post, get, put alebo delete). Ďalej sa v tomto objekte môže zadefinovať hlavička (headers) a telo (body) požiadavku. Tieto vlastnosti nie sú povinné a zadávajú sa podľa toho, ako je to zadefinované na strane servera. Obsahujú informácie, ktoré sú nevyhnutné pre správne odoslanie požiadavku. V hlavičke to môžu byť napríklad prihlasovacie údaje používateľa, JWT token pre autorizovanie, alebo aj meno aplikácie, do ktorej sa používateľ snaží prihlásiť. Pri vytváraní alebo upravovaní používateľa, spoločnosti, senzora a podobne, sa v tele požiadavku odošle táto informácia ako JSON objekt konvertovaný na textový reťazec.

<source lang="javascript">
body: JSON.stringify({
login: this.state.login,
password: sha256(this.state.password),
firstname: this.state.firstname,
surname: this.state.surname,
isAdmin: this.state.isAdmin,
enabled: this.state.enabled,
Companies: this.state.Companies
})
</source>
Kód 4.3: Príklad požiadavky pri vytváraní nového používateľa

<source lang="javascript">
fetch("http://login.nsoric.com/nsoric/auth/login/",
{
method: 'POST',
headers: { login: name, password: sha256(password) }
}
)
.then(response => response.json())
.then(result => {
if (result.user.enabled)
this.props.handleSuccessfulAuth(result.user, result.JWT);
else {
if (result.message === "user does not exists")
alert("Zle zadané prihlasovacie údaje!");
}
</source>
Kód 4.4: Ukážka metódy fetch (zjednodušené prihlásenie používateľa do aplikácie)

Metóda fetch je asynchrónna a teda vracia dátový typ ''promise''. To znamená, že metóda vráti synchrónne objekt promise ako dočasnú návratovú hodnotu predtým, než bude známa reálna hodnota. Potom, čo sa asynchrónna operácia dokončí, objekt zavolá callbak s výsledkom alebo chybou. Je to z toho dôvodu, aby aplikácia mohla normálne fungovať, kým získa odpoveď zo servera. Promise môže nadobúdať 3 stavy:

* '''Čakajúci (Pending)''' - v tomto stave je zahájená asynchrónna operácia, ale ešte nie je známy výsledok,
* '''Splnený (Resolved alebo aj Fulfilled)''' - v tomto stave je asynchrónna operácia dokončená úspešne a objekt volá úspešný callback,
* '''Zamietnutý (Rejected)''' - v tomto stave je asynchónna operácia dokončená neúspešne a objekt volá neúspešný callback. .

Konkrétne príklady dátového typu promise z aplikácie je možné vidieť v časti [[#serverResponses|[serverResponses]]] na obrázku [[#fig:response1|[fig:response1]]] (splnený stav) a na obrázkoch [[#fig:response404|[fig:response404]]] a [[#fig:response500|[fig:response500]]] (zamietnutý stav). Na obrázku [[#fig:response2|[fig:response2]]] je vidieť hodnotu, ktorú vrátila callback funkcia po úspešnom dokončení asynchrónnej funkcie.

V kóde [[#fetchRequest|[fetchRequest]]] sú v premennej ''response'' uložené práve informácie o promise objekte (stav a hodnota). V premennej ''result'' je už uložená finálna hodnota zo serveru vo formáte JSON.

=== Uchovávanie dát ===

Ako bolo spomenuté v časti [[#sec:IntroToReact|[sec:IntroToReact]]], komponenty v React aplikácií majú svoje vlastnosti (props) a spravujú svoj vnútorný stav (state). Na základe stavu a vlastností je postavená komunikácia medzi jednotlivými komponentmi v aplikácií. Vo vnútri jedného komponentu sa definuje stav a ten sa odovzdá druhému komponentu ako jeho vlastnosť. Problém nastáva pri obnovení stránky (okna aplikácie). Pri obnovení stránky sa obnovuje aj stav komponentov (a teda s tým spojené aj vlastnosti). Aby sa zabránilo strate dát uchovaných v stave komponentu, existujú 2 možnosti:

* ukladanie dát do lokálneho úložiska prehliadača (localStorage a sessionStorage),
* nastavovanie stavu po každom vykreslení komponentu (metóda componentDidMount).

'''Lokálne úložisko prehliadača'''

Internetové aplikácie môžu ukladať dáta lokálne do úložiska používateľovho prehliadača. Tieto úložiská sú takmer rovnaké, jediným rozdielom je, že dáta uložené v localStorage nemajú žiadnu expiračnú dobu. V aplikácií eAurela je používaný sessionStorage, ktorý je automaticky vymazaný pri zatvorení prehliadača (v tomto prípade aj pri zatvorení Electron aplikácie). Ten v aplikácii uchováva dôležité informácie zo servera, ktoré nemôžu byť počas chodu aplikácie stratené. Jedná sa napríklad o údaje prihláseného používateľa (aplikácia tak vie, kto je prihlásený), JWT token, ktorý je posielaný v každej požiadavke na server. Pri strate týchto údajov po obnovení stránky, by sa aplikácia stala nefunkčnou. Tieto úložiská uchovávajú dáta vo forme textového reťazca. Preto dáta iného dátového typu treba vždy pred uložením konvertovať na textový reťazec.

<source lang="javascript">
sessionStorage.setItem('user', JSON.stringify(res1));
sessionStorage.setItem('JWT', res2);
</source>
Kód 4.5: Príklad uloženia hodnôt do sessionStorage

V kóde [[#sessionStorage.setItem|[sessionStorage.setItem]]] sú prvé parametre (’user’ a ’JWT’) názov, pod ktorým budú dáta dostupné a druhé parametre sú samotné dáta, ktoré sa ukladajú. Získanie dát zo sessionStorage je ukázané v kóde [[#sessionStorage.getItem|[sessionStorage.getItem]]].

<source lang="javascript">
const user = JSON.parse(sessionStorage.getItem('user'));
const jwt = sessionStorage.getItem('JWT');
</source>
Kód 4.6: Príklad použitia hodnôt zo sessionStorage

Síce sa sessionStorage vymaže automaticky pri zatvorení aplikácie, treba ho manuálne vymazať v prípade, že sa používateľ odhlási zo systému, no aplikáciu eAurela nechá otvorenú. Pre manuálne vymazanie celého obsahu úložiska slúži metóda ''sessionStorage.clear()''.

'''Metóda ''componentDidMount'' '''

Ďalšou možnosťou, ako predísť strate údajov, je posielanie požiadaviek a následné nastavovanie stavu v metóde ''componentDidMount''. Táto metóda prebehne vždy, keď je komponent vykreslený. Posielanie požiadaviek na server (fetch) je doporučené robiť práve v tejto metóde.

<source lang="javascript">
componentDidMount() {
this.setState({ isLoading: true })
const ID = this.props.activeSector.id;
fetch(this.state.url + "/manage/sector/" + ID + "/last-values/",
{
method: 'GET',
headers: {Authorization: "Bearer " + this.state.jwt}
}
)
.then(response => response.json())
.then(result => {
// nastavenie stavu z odpovede zo servera
this.setState({ Sensors: result, isLoading: false })
})
.catch(error => console.log(error))
}
</source>
Kód 4.7: Odoslanie požiadavku v metóde componentDidMount()

Keďže namerané hodnoty zo senzorov majú byť vždy aktuálne, získavajú sa v tejto metóde. Komponent tak vždy po obnovení stránky má novú odpoveď zo servera s aktuálnymi nameranými hodnotami. Komponent obsahujúci metódu ''componentDidMount'' sa vždy vykresľuje na dvakrát. Napríklad v komponente ''Sectors'' sa najskôr vykreslia základné informácie o oblastiach a sektoroch a ikona načítavania, ktorá hovorí o tom, že aplikácia komunikuje so serverom (prebieha metóda componentDidMount).

[[File:bpaz_componentDidMount.png|thumb|500px|Obr 4.7 Vykreslenie komponentu bez dát zo servera<span label="fig:DidMount"></span>]]

Hneď ako aplikácia dostane odpoveď zo servera, ktorá obsahuje aktuálne údaje, na obrazovku sa dodatočne vykreslia tieto údaje bez toho, aby sa ostatné časti komponentu znovu vykresľovali.

[[File:bpaz_componentDidMount1.png|thumb|500px|Obr 4.8 Vykreslenie komponentu s dátami zo servera<span label="fig:DidMount1"></span>]]

== Návrh dizajnu aplikácie ==

Komponenty v aplikácií sú základným stavebným blokom používateľského rozhrania. Ich vzhľad tvorí veľkú časť toho, ako bude aplikácia nakoniec vyzerať, ako ju bude vidieť samotný používateľ. Možností, ako upravovať štýl a vzhľad komponentov, je viacero. V aplikácií sú používané dva spôsoby úpravy vzhľadu komponentov: pomocou štylizovaných komponentov a pomocou CSS.

=== Štylizované komponenty ===

Tento spôsob úpravy dizajnu je v aplikácií využívaný najviac. Pre jednoduchosť bola použitá knižnica ''reactstrap'' (http://reactstrap.github.io/), ktorá obsahuje už vytvorené komponenty s hotovým dizajnom. Tie sú jednoducho vložené do vnútra komponentu, kde majú byť použité. Reactstrap je knižnica obsahujúca komponenty z ''React Bootstrap 4''. Knižnica nie je závislá na jQuery alebo na Bootstrap javascript.

'''Komponenty pre interakciu s používateľom: <Input>, <Table> a <Form> '''

Keďže React používa syntax JSX (časť [[#sec:IntroToReact|[sec:IntroToReact]]]), pre interakciu s používateľom boli použité komponenty Input a Form. Tieto komponenty fungujú na podobnom princípe, ako v jazyku HTML. Input slúži ako vstup, kam používateľ zadáva údaje (text, heslo a podobne). Form je formulár, v ktorom sa nachádza viacero vstupných polí a potvrdením tohto formulára sa odosiela požiadavka na server.

[[File:bpaz_LoginForm.png|thumb|500px|Obr 4.9 Formulár pre prihlásenie do aplikácie<span label="fig:LoginForm"></span>]]

V časti spravovania systému boli údaje pre ich sprehľadnenie vypísané na obrazovku do tabuľky. Pri upravovaní údajov zo servera bol použitý formulár, ktorý obsahoval tabuľku so vstupnými poľami (viď obrázok [[#fig:Table|1.10]]).

[[File:bpaz_Table.png|thumb|500px|Obr 4.10 Formulár s tabuľkou pre vytvorenie používateľa<span label="fig:Table"></span>]]

'''Komponenty pre zobrazenie informácií: <Card>, <ListGroup> '''

Komponent Card (karta) v aplikácií zobrazuje informácie získané zo servera. Karta sa skladá z viacerých ďalších komponentov (potomkov), ktoré slúžia pre presné zadefinovanie miesta, kde bude údaj zobrazený. To slúži pre prehľadné zobrazenie dát. Prvý doplňujúci komponent karty je hlavička karty (CardHeader). V komponente Applist sa do hlavičky vypisuje názov spoločnosti, spolu aj s malým logom. Pri údajoch zo senzorov (obrazovka Sectors) sa do hlavičky vypisuje názov senzora a stav batérie (ak daný senzor batériu má). Ďalší dôležitý komponent pri vykresľovaní karty je jej telo (CardBody). V okne Applist je do tela karty vložený titulok (CardTitle). Ten zobrazuje doplňujúce informácie o spoločnosti, ako adresu a podobne. Najdôležitejší komponent v tele karty je ListGroup. Tento komponent slúži pre vypísanie zoznamu aplikácií v danej spoločnosti, z ktorej si používateľ môže vybrať a prihlásiť sa do nej. V časti ''Sectors'' je telo karty použité na zobrazenie ID senzora, poslednej nameranej hodnoty zo senzora spolu s dátumom a časom, kedy bola táto hodnota nameraná.

[[File:bpaz_Cards.png|thumb|500px|Obr 4.11 Použitie karty pre výpis údajov<span label="fig:Cards"></span>]]

''' Komponenty pre navigáciu: <Navbar>, <Nav>, <NavLink> '''

Tieto komponenty slúžia pre jednoduchú navigáciu, či už medzi jednotlivými časťami aplikácie, alebo pri prechádzaní informácií. Za zmienku stojí v tejto časti komponent ''NavLink''. Komponent s takým istým názvom je aj v knižnici ''react-router-dom'' (časť [[#navigation|1.2]]). Tieto komponenty vykonávajú v podstate to isté, rozdiel je v dizajne. Nevýhoda tohto komponentu je obnovenie obrazovky po kliknutí na tento odkaz, s čím môžu nastať problémy, ako boli popísané v časti [[#subsec:propsandstate|1.3.2]]. Aby sa odstránilo obnovovanie stránky pri kliknutí na odkaz, priradí sa mu funkcionalita komponentu ''Link'' z knižnice ''react-router-dom'', ktorý presmeruje používateľa bez obnovenia stránky. Takto zapísaný ''NavLink'' sa správa ako ''Link'', pričom mu zostane jeho dizajn. Takisto obsahuje vlastnosť ''active'', ktorá v aplikácií slúži na zvýraznenie časti, v ktorej sa používateľ nachádza (viď obr. [[#fig:navbar|1.12]]).

<source lang="javascript">
<NavLink
tag={Link} // priradenie funkcionality komponentu <Link>
to={props.path} // cesta, kam bude používateľ presmerovaný
onClick={handleClick} // funkcia vykonaná po kliknutí
>
{props.link} // hodnotu vlastnosti vidí používateľ ako odkaz
</NavLink>
</source>
Kód 4.8: Príklad prepojenia komponentov <nowiki><NavLink> a <Link></nowiki>

Komponenty ''Nav'' a ''Navbar'' slúžia ako rodičovské komponenty pre zoskupenie viacerých prvkov na navigáciu, alebo zobrazenie rôznych informácií. Rozdiel je v tom, že ''Navbar'' má viacero možností nastavenia vzhľadu (od ktorých sa odvíja aj vzhľad "potomkov"), ale dá sa použiť iba horizontálne, pričom ''Nav'' sa dá použiť aj vertikálne.

[[File:bpaz_SectorsNavbar.png|thumb|500px|Obr 4.12 Komponenty <NavLink>, <Nav> a <Navbar><span label="fig:navbar"></span>]]

=== Úprava vzhľadu pomocou CSS ===

V aplikácií bol taktiež na úpravu vzhľadu použitý jazyk CSS. Pre nastavenie základných vlastností aplikácie eAurela, ako štýl písma a podobne, bol použitý klasický spôsob vloženia odkazu na externý .css súbor do koreňového komponentu aplikácie. Taktiež aj pre dodatočnú úpravu niektorých komponentov z knižnice ''reactstrap'' bol zvolený tento spôsob. React dovoľuje ale aj používanie CSS priamo vo vnútri komponentov. Tento spôsob bol použitý v aplikácií najmenej a bol použitý hlavne na prvky, ktorých vzhľad bolo treba dynamicky meniť (ako napríklad komponent ''NavLink'' pri nastavení spomenutej vlastnosti ''active'').

<source lang="javascript">
<NavLink
tag={Link}
/* štýl sa bude meniť vzhľadom na pravdivostnú
hodnotu premennej props.Graphs */
style={!props.Graphs ? {
color: "black",
backgroundColor: "white",
boxShadow: "0px 0px 0px 1px lightgrey"
} : style}
to="sectors"
active={!props.Graphs}
</NavLink>
</source>
Kód 4.9: Dynamické nastavenie štýlu komponentu <nowiki><NavLink></nowiki>

== Vykreslovanie grafov ==

Vzhľadom na funkčnú požiadavku R08 bolo potrebné v aplikácií eAurela zabezpečiť prácu s grafmi. Pre framework React existuje viacero knižníc pre prácu a zobrazenie grafov. V aplikácii eAurela je použitá knižnica ''recharts'' (http://recharts.org/en-US/) pre jej bezplatnú dostupnosť a veľmi dobre vypracovanú dokumentáciu. Graf sa vykresľuje v samostatnom komponente ''SensorGraphs'', ktorý je následné vykreslený v komponente ''Sectors'' po zvolení možnosti ''"Časový záznam"''. Na nasledujúcom obrázku je zobrazený graf v aplikácii eAurela s hodnotami z časového intervalu tridsať dní.

[[File:bpaz_SensorGraphs.png|thumb|500px|Obr 4.13 Vykreslenie grafu v komponente <Sectors><span label="fig:Graph"></span>]]

Knžinica recharts ponúka veľké množstvo grafov, či už čiarové, stĺpcové, koláčové a podobne. Keďže má aplikácia vykresľovať zmenu nameraných hodnôt z časového intervalu všetkých senzorov nachádzajúcich sa v sektore, bol použitý základný čiarový graf (LineChart). Vzhľadom na to, že v jednom grafe sa bude nachádzať viacero kriviek (podľa počtu senzorov), z dokumentácie ''recharts'' bol vybraný čiarový graf s názvom ''"LineChartHasMultiSeries"''. Aby boli jednotlivé krivky správne vykreslené, komponent LineChart musí prevzať dáta upravené do správneho formátu.

<source lang="javascript">
const series = [
{
name: 'Senzor 1',
data: [
{
date: "",
value:
},
{ ... }, ...
],
},
{ ... }, ...
];
</source>
Kód 4.10: Vzor formátu dát pre LineChart

Konštanta ''series'' je pole, kde každý prvok poľa predstavuje objekt s dvoma vlastnosťami: ''name'' a ''data''. Vlastnosť ''name'' obsahuje názov senzora, ktorý bude vypísaný v legende spolu s odpovedajúcou farbou krivky. Vlastnosť ''data'' obsahuje konkrétne namerané dáta. ''Data'' je taktiež pole objektov, kde jednotlivé objekty obsahujú taktiež dve vlastnosti: ''date'' (dátum, kedy bola hodnota nameraná) a ''value'' (nameraná hodnota). Táto konštanta je zadefinovaná vo funkcii pre vykreslenie komponentu (render).

<source lang="javascript">
render() {
const series = this.getChartData(Sensors, Measurements);
return ( ... )
}
</source>
Kód 4.11: Zadefinovanie konštanty series

V odpovedi zo servera dostaneme dve polia: ''sensors'', kde sú uložené všeobecné informácie o senzoroch a ''measurements'', kde sú namerané hodnoty za dané obdobie. Takáto odpoveď zo serveru vyzerá podobne ako na obrázku obr. [[#fig:ServerValues|1.14]].

[[File:bpaz_ServerValues.png|thumb|500px|Obr 4.14 Odpoveď zo servera pri vykreslovaní grafu<span label="fig:ServerValues"></span>]]

O spracovanie údajov zo servera do správneho formátu sa v aplikácií starajú dve metódy. Prvá metóda je ''getChartData'', ktorá ako parametre preberá namerané údaje zo servera (measurements), a taktiež všetky údaje o senzoroch (sensors). Táto metóda prechádza pole všetkých senzorov a pre vyhovujúce senzory (nevyhovujúce sú v tomto prípade senzory snímajúce stav batérie) priradí názov senzora.

<source lang="javascript">
getChartData(sensors, measurements) {
let chartData = [];
for (let i = 0; i < sensors.length; i++) {
if (isNaN(sensors[i].uid) || this.DecToBin(sensors[i].uid).substring(0, 8) !== "00000000") {
chartData[i] = {
name: sensors[i].name,
data: this.getData(sensors[i].uid, measurements)
}
}
}
return chartData;
}
</source>
Kód 4.12: Metóda getChartData

Pre zjednodušenie ukážky boli z kódu odstránené dodatočné podmienky ošetrujúce výnimočné stavy, ktoré môžu nastať pri komunikovaní so serverom. Práve v týchto podmienkach je použitý parameter ''measurements''. Taktiež je použitý ako vstupný parameter funkcie ''getData'', ktorá vyplní vlastnosť ''data'' konkrétnymi hodnotami (dátumom, časom a konkrétnou hodnotou). Táto metóda preberá ako vstupný parameter aj ID senzora, aby bolo možné prideliť namerané hodnoty k správnemu senzoru. Táto metóda prechádza všetky namerané údaje a hľadá tie, ktoré boli namerané senzorom s príslušným ID.

<source lang="javascript">
getData(id, measurements) {
let data = [];
let k = 0;
for (let i = (measurements.length - 1); i >= 0; i--) {
for (let j = 0; j < measurements[i].values.length; j++) {
if (id === measurements[i].values[j].sid) {
data[k] = {
date: measurements[i].date.substring(0, 10) + " " + measurements[i].date.substring(11, 19),
value: measurements[i].values[j].value !== null ? measurements[i].values[j].value : null
}
break;
}
}
k++;
}
return data;
}
</source>
Kód 4.13: Metóda getData

Aj v tejto ukážke boli pre zjednodušenie kódu vynechané podmienky ošetrujúce stavy, spôsobujúce chyby v aplikácií.

Samotný komponent ''LineChart'' sa skladá z viacerých ďalších komponentov, ktoré upresňujú rozloženie jednotlivých prvkov grafu a umiestnenie údajov. ''ResponsiveContainer'' definuje šírku a výšku grafu. Komponenty ''XAxis'' a ''YAxis'' určujú, ktoré dáta sú vykreslené na každej z osí, či sa jedná o textové, alebo číselné údaje. Komponent ''Legend'' vykresľuje legendu ku grafu, ''Tooltip'' zobrazí nápovedu o konkrétnom dátume (nápovedu používateľ zobrazí prejdením kurzora do časti grafu, kde si chce prezrieť konkrétne hodnoty). ''Line'' je samotná krivka, ktorej sa definujú dáta, ktoré sa použijú na vykreslenie. Keďže v aplikácií sa vykresľuje viacero kriviek do jedného grafu, bola použitá javascriptová metóda ''map'' pre prechádzanie konštanty ''series'' a pre každý jej prvok sa vykreslí vlastná krivka. Kód [[#LineChart|[LineChart]]] zobrazuje implementáciu grafu v aplikácií aj s popisom jednotlivých častí a výsledný graf je možné vidieť na obrázku [[#fig:TooltipGraph|1.15]].

<source lang="javascript">
<ResponsiveContainer width="95%" height="90%">
<LineChart>
<CartesianGrid strokeDasharray="3 3" />
<XAxis
dataKey="date" // dáta zobrazené na osi X
type="category" // textový údaj (dátum a čas)
allowDuplicatedCategory={false} // údaj sa nesmie opakovať
minTickGap={10} /> // medzera medzi údajmi v popise
<YAxis dataKey="value" />
<Tooltip />
<Legend />
{series.map((s, index) => (
<Line
key={index}
dataKey="value" // kľúčová hodnota
data={s.data} // pôvod dát
name={s.name} // názov senzoru
stroke={this.getRandomColor()} // farba krivky
dot={false} />
))}
</LineChart>
</ResponsiveContainer>
</source>
Kód 4.14: Implementácia grafu LineChart

Vzhľadom na to, že ''recharts'' pri vykreslení viacerých kriviek do jedného grafu priradí všetkým základnú (rovnakú) farbu, bola pre lepšie rozlíšenie kriviek implementovaná funkcia ''getRandomColor'', ktorá každej krivke priradí náhodnú farbu.

[[File:bpaz_TooltipGraph.png|thumb|500px|Obr 4.15 Ukážka grafu s popisom jednotlivých komponentov<span label="fig:TooltipGraph"></span>]]

Nástroje použité na vývoj aplikácie eAurela

2020-10-19T19:33:31Z

Juraj: Zamkol stránku „Nástroje použité na vývoj aplikácie eAurela“ ([Úprava=Povoliť iba správcom] (na neurčito) [Presun=Povoliť iba správcom] (na neurčito))

[[Kategória:Študentské práce]][[Kategória:Bakalárske práce]][[Kategória:Informatika]]

{{Praca_uvod|3|Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému|Informačný systém Sensorical|Analýza požiadaviek a štruktúra klientskej aplikácie|Nástroje použité na vývoj aplikácie eAurela|Implementácia aplikácie eAurela|Uvedenie aplikácie eAurela do produkcie}}

__TOC__

= =

Vo vývoji aplikácie eAurela boli použité viaceré nástroje. Keďže má byť aplikácia eAurela dostupná na platformách Windows, Linux, Mac OS a aj ako internetová aplikácia (nefunkčná požiadavka R01), je naprogramovaná pomocou dvoch javascriptových frameworkov: ''React.js'' a ''Electron.js''. Keďže je Electron postavený na ''Node.js'', bolo počas vývoja potrebné použiť aj toto javascriptové behové prostredie.

== Framework React.js ==

React je javascriptová knižnica s otvoreným zdrojovým kódom (open-source) od spoločnosti Facebook. Slúži na tvorbu používateľského rozhrania (UI). Od rôznych iných javascriptových frameworkov sa React odlišuje tým, že sa sústredí iba na jednu špecifickú oblasť a tvorí iba vrstvu pohľadu (view), ktorá prezentuje dáta používateľovi. Jednou z najväčších výhod Reactu je, že povoluje JSX syntax. Táto syntax je rozšírením javascriptu a umožňuje nám písať HTML kód priamo do javascriptového kódu, čo zjednodušuje celý proces . Základným stavebným prvkom React aplikácie sú tzv. komponenty (components). Komponenty sú rôzne znovu použiteľné JSX elementy so zapuzdrenou funkcionalitou. Ich skladaním vzniká komplexná UI aplikácia. Tieto komponenty majú svoje vlastnosti (props) a spravujú svoj vnútorný stav (state). Tento spôsob práce s dátami vedie k viac predvídateľnému správaniu a aj ľahšiemu ladeniu. React je možné používať aj s ďalšími podobne zameranými knižnicami, ako je napríklad Redux, alebo Electron .

=== Komponenty a vlastnosti ===

Komponenty nám umožňujú rozdeliť používateľské rozhranie na nezávislé, znovu použiteľné časti. Koncepčne sú ako javascriptové funckie. Prijímajú ľubovoľné vstupy (props) a vracajú reactové elementy, popisujúce, čo by sa malo zobraziť na obrazovke. Komponenty môžu byť funkcionálne alebo triedne.

'''Funkcionálne komponenty '''

Najjednoduchší spôsob, ako zadefinovať komponent, je napísať javascriptovú funkciu (viď kód [[#functionalComponent|[functionalComponent]]]).
<source lang="javascript">
function Welcome(props) {
return <h1>Hello, {props.name}</h1>;
}
</source>
Kód 3.1: Príklad funkcionálneho komponentu [8]

Táto funkcia je plnohodnotný komponent, pretože prijíma vlastnosť (props ako properties) s dátami a vracia reactový element.

'''Triedny komponent'''

Pre zadefinovanie komponentu sa môže taktiež použiť trieda z ES6 (verzia javascriptu ECMAScript 6).

<source lang="javascript">
class Welcome extends React.Component {
render() {
return <h1>Hello, {this.props.name}</h1>;
}
}
</source>
Kód 3.2: Príklad triedneho komponentu [8]

Takto zadefinovaný komponent je rovnaký ako uvedený funkcionálny komponent v kóde [[#functionalComponent|[functionalComponent]]].

'''Vykreslenie komponentu'''

Spomenuté elementy, popisujúce čo by sa malo na obrazovke vykresliť môžu byť buď reactové elementy, ktoré reprezentujú DOM (Document Object Model) značky (tagy). Každopádne elementy môžu reprezentovať aj používateľom zadefinované komponenty .

<source lang="javascript">
// DOM tag
const element = <div />;
// používateľom definovaný komponent
const element = <Welcome name="Sara" />;
</source>
Kód 3.3: Dom tag a používateľom definovaný komponent [8]

Keď React uvidí element reprezentujúci používateľom zadefinovaný komponent, podá tomuto komponentu JSX atribúty a všetkých potomkov ako jeden objekt. Tento objekt sa nazýva ''props'' (vlastnosti). React sa ku komponentom začínajúcim malým písmenom správa ako k DOM značkám (napríklad <div /> reprezentuje HTML div tag). Používateľom definovaný komponent musí začínať veľkým písmenom. Je to z toho dôvodu, že React predáva tieto elementy metóde ''React.createElement(parameter)''. V prípade, že sa jedná o element začínajúci malým písmenom, tejto metóde sa ako parameter podá názov elementu ako textový reťazec. Ak element začína veľkým písmenom, tejto metóde sa podá celý komponent ako objekt .

'''Vlastnosti v komponentoch'''

Konfiguráciu a predávanie dát do komponentu majú na starosti vlastnosti (props). Vlastnosti sú dáta určené iba na čítanie (read-only). Či je komponent definovaný ako trieda alebo funkcia, nikdy nesmie modifikovať a meniť hodnotu vlastnostiam. Funkcie, ktoré nikdy neprepisujú svoje vstupné parametre sa nazývajú čisté (pure) funkcie. Takáto funkcia vráti pri rovnakom vstupe vždy ten istý výsledok. Opakom takejto funkcie je funkcia nečistá (impure), ktorá môže meniť svoj vstup. Všetky reactové komponenty sa musia správať ako čisté funkcie vzhľadom na ich vlastnosti .

=== Stav aplikácie ===

Stav (state) je podobný vlastnostiam. Používa sa ale výhradne vo vnútri komponentu pre riadenie toku dát. Sú to teda privátne dáta komponentu. Stav sa deklaruje v konštruktore triedneho komponentu. V konštruktore sa nastaví počiatočný stav, ktorý môže byť počas behu aplikácie menený. Pre zmenu stavu sa používa metóda ''setState()'', a teda stav nikdy nie je menený priamo.

<source lang="javascript">
// Wrong
this.state.comment = 'Hello';
// Correct
this.setState({ comment : 'Hello' }) ;
</source>
Kód 3.4: Aktualizovanie stavu [10]

Výraz ''this.state'' môže byť pre nastavenie stavu použitý iba v konštruktore komponentu. Aktualizovanie stavu spolu s vlastnosťami môže byť asynchrónne, a preto by sa nemalo spoliehať na ich hodnoty pre výpočet nového stavu. Aby sa zabránilo tomuto správaniu, používa sa druhý spôsob zápisu metódy ''setState'', ktorý prijíma funkciu a nie objekt. Táto funkcia dostane ako prvý parameter predchádzajúci stav a ako druhý parameter dostane vlastnosť, v čase kedy je vykonaná aktualizácia. V kóde [[#setStateFunction|[setStateFunction]]] je použitá šípková funkcia, každopádne to tiež správne funguje s regulárnou funkciou .

<source lang="javascript">
this.setState((state , props ) => ({
counter : state.counter + props.increment
})) ;
</source>
Kód 3.5: Použitie šípkovej funkcie vo vnútri setState [10]

== Framework Electron.js ==

Electron je open-source projekt, ktorý slúži na vývoj a implementáciu multiplatformných desktopových aplikácií. Aplikácie naprogramované pomocou Electronu sú kompatibilné s operačnými systémami Mac, Windows a Linux.

Electron používa Chromium, čo je open-source verzia prehliadača Google Chrome. Ďalej používa Node.js, čo umožňuje vyvíjať desktopové aplikácie pomocou HTML, CSS a javascriptu. V tomto frameworku sú naprogramované populárne aplikácie, ako napríklad Visual Studio Code, Atom editor, Discord a mnoho ďalších.

=== Vývoj Electron aplikácie ===

Pokiaľ ide o vývoj, Electron aplikácia je v podstate Node.js aplikácia. Východiskovým súborom je ''package.json'', ktorý je totožný s východiskovým modulom Node.js. Súbor ''package.json'' obsahuje informácie o hlavnom procese a taktiež všetky závislosti aplikácie.

<source lang="javascript">
{
"name": "eaurela",
"version": "0.1.0",
"main": "./main.js",
"private": true,
"dependencies": {
"react": "^16.12.0"
},
"scripts": {
"start": "react-scripts start",
"build": "react-scripts build",
"electron-win": "set ELECTRON_DISABLE_SECURITY_WARNINGS=true && set ELECTRON_START_URL=http://localhost:3000/ && electron .",
"dev-win": "concurrently -k \"npm start\" \"wait-on http://localhost:3000 && npm run electron-win\"",
"package-win": "electron-packager . --platform=win32 --arch=x64"
},
},
"devDependencies": {
"concurrently": "^5.0.0",
"electron": "^9.0.0",
"wait-on": "^3.3.0"
}
}
</source>
Kód 3.6: Vzor súboru package.json

Súbor ''package.json'' je vlastne javascriptový objekt, pričom jednotlivé vlastnosti musia byť v úvodzovkách. Skladá sa z viacerých častí. Prvok ''"name"'' je názov aplikácie, ''"version"'' hovorí o verzii aplikácie. Jedna z najdôležitejších vlastností je ''"main"''. Tá odkazuje na hlavný proces, ktorý sa spustí pri spustení aplikácie. Ďalšie dôležité prvky sú ''"dependencies"'' a ''"scripts"''. Dependencies hovoria o nainštalovaných knižniciach a ich verziách. Scripts sú skripty dôležité napríklad pre spúšťanie, testovanie alebo buildovanie aplikácie (buildovanie aplikácie je popísané v časti [[#build|[build]]]). Skripty sa spúšťajú z príkazového riadku (respektíve terminálu) pomocou príkazu ''npm'' (node package manager). Vlastnosť ''"devDependencies"'' hovorí o nainštalovaných závislostiach dostupných iba vo fáze vývoja aplikácie.

=== Procesy Electron aplikácie ===

Electron aplikácia má viacero procesov. Hlavný proces (main process) má na starosti prácu so súbormi, komunikáciu s operačným systémom.

Vykreslovacie procesy (renderer processes) vytvárajú obsah aplikácie v oknách prehliadača.

V Electron aplikácií, súbor ''package.json'' spustí hlavný skript nazývaný hlavný proces. V našom prípade sa hlavný proces nazýva ''main.js'' a nachádza sa v rovnakom priečinku ako súbor ''package.json'' (viď kód [[#lst:package|[lst:package]]], vlastnosť ''"main"''). Skript, ktorý beží v hlavnom procese môže zobrazovať grafické programové rozhranie (Graphical User Interface) vytváraním webových stránok. Electron aplikácia má vždy práve jeden hlavný proces.

Nakoľko Electron používa Chromium pre zobrazovanie webových stránok, jeho viac procesová architektúra je tiež použitá. Každá webová stránka v Electron aplikácií spúšťa jej vlastný proces. Tento proces sa nazýva vykresľovací proces.

'''Modul BrowserWindow a rozdiel medzi hlavným a vykresľovacím procesom'''

Modul BrowserWindow nám umožňuje vytvoriť nové okno prehliadača, alebo spravovať už existujúce okno. Každé okno prehliadača je separátny proces - vykresľovací proces.

Hlavný proces vytvára webové stránky vytváraním ''BrowserWindow'' inštancií. V každej inštancií ''BrowserWindow'' beží webová stránka vo svojom vlastnom vykresľovacom procese.

Hlavný proces spravuje všetky webové stránky a ich korešpondujúce vykresľovacie procesy. Každý vykresľovací proces je izolovaný a stará sa iba o webovú stránku bežiacu v ňom .

<source lang="javascript">
const electron = require('electron');
const { app, BrowserWindow} = electron;
let mainWindow;
const createWindow = () =>
{
mainWindow = new BrowserWindow({
width: 1250,
height: 750,
title: "eAurela",
resizable: true,
});
app.on('ready', createWindow);
</source>
Kód 3.7: Vytvorenie inštancie BrowserWindow v hlavnom procese main.js

Hlavný proces ''main.js'' by mal vytvárať všetky okná a mal by obsluhovať všetky systémové udalosti, ktoré sa v aplikácií môžu vyskytnúť, napríklad vytvorenie okna, ak je obsah aplikácie načítaný (viď kód [[#lst:BrowserWindow|[lst:BrowserWindow]]]).

Analýza požiadaviek a štruktúra klientskej aplikácie

2020-10-19T19:23:34Z

Juraj: Zamkol stránku „Analýza požiadaviek a štruktúra klientskej aplikácie“ ([Úprava=Povoliť iba správcom] (na neurčito) [Presun=Povoliť iba správcom] (na neurčito))

[[Kategória:Študentské práce]][[Kategória:Bakalárske práce]][[Kategória:Informatika]]

{{Praca_uvod|2|Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému|Informačný systém Sensorical|Analýza požiadaviek a štruktúra klientskej aplikácie|Nástroje použité na vývoj aplikácie eAurela|Implementácia aplikácie eAurela|Uvedenie aplikácie eAurela do produkcie}}

__TOC__

= =

Táto kapitola popisuje špecifikáciu funkčných a nefunkčných požiadaviek, z ktorých vyplývajú prípady použitia. Ďalej je v kapitole opísaný návrh štruktúry aplikácie, popis jednotlivých častí a priblíženie, ako aplikácia eAurela funguje, pomocou diagramov aktivít.

== Požiadavky aplikácie ==

Známe sú dva základné typy požiadaviek: funkčné a nefunkčné. Funkčné požiadavky dávajú prehľad o softvérovej funkcionalite, ktorá musí byť implementovaná. Sú to požiadavky na správanie systému. Nefunkčné požiadavky sa môžu tiež nazvať systémové požiadavky. Sú to požiadavky, ktoré sa zaoberajú vlastnosťami systému, výkonom, bezpečnosťou a podobne. Ďalej sú popísané minimálne požiadavky na spustenie aplikácie a požiadavky týkajúce sa bezpečnosti systému.

=== Funkčné požiadavky ===

{| class=wikitable
|-
!
!Funkčné požiadavky
!Doplňujúce informácie
|-
|R01 || Prihlásenie do systému || Každému používateľovi systému Sensorical je vytvorený vlastný login a heslo. Pomocou týchto údajov sa používateľ prihlási.
|-
|R02 || Spravovanie systému || Ak má používateľ pridelené administrátorské práva, môže spravovať údaje uložené na serveri.
|-
|R03 || Voľba aplikácie zberu dát || Možnosť výberu aplikácie zberu dát, ku ktorému sa eAurela pripojí. Aplikácia eAurela sa pripája k serveru, na ktorom sa vybraná aplikácia nachádza.
|-
|R04 || Spravovanie informačného systému || Ak má používateľ pridelené práva na spravovanie aplikácie, môže meniť napríklad nastavenie senzorov, zapnúť alebo vypnúť meranie a podobne.
|-
|R05 || Výber z povolených údajov || Používateľ vidí iba údaje, ku ktorým má pridelené oprávnenia.
|-
|R06 || Zobrazenie hodnôt || Zobrazenie poslednej nameranej hodnoty na každom senzore vo vybranej oblasti. Hodnoty sú zobrazené spolu s fyzikálnou jednotkou, dátumom a časom.
|-
|R07 || Umiestnenie senzorov || Jednotlivé senzory sú zaradené do oblastí a sektorov.
|-
|R08 || Zobrazenie grafov || Zobrazenie nameraných hodnôt vo forme grafu časovej závislosti.
|-
|R09 || Výber časového intervalu || Výber časového intervalu, v ktorom aplikácia zobrazí namerané hodnoty.
|-
|R10 || Odhlásenie z aplikácie. ||
|}
Tabuľka 2.1 Funkčné požiadavky aplikácie eAurela

=== Nefunkčné požiadavky ===

{| class=wikitable
|-
!
!Nefunkčné požiadavky
!Doplňujúce informácie
|-
|R01 || Aplikácia vo forme desktopovej aplikácie a internetovej aplikácie || Aplikácia eAurela bude dostupná v dvoch formách. Dostupná bude ako desktopová aplikácia podporovaná operačnými systémami Mac, Windows a Linux. Taktiež bude fungovať ako internetová aplikácia dostupná v internetovom prehliadači.
|-
|R02 || Implementovaná v jazyku javascript, HTML a CSS || Na implementáciu budú použité dva javascriptové frameworky: Electron.js a React.js.
|-
|R03 || Bezpečné overovania || Používateľovi bude po každom prihlásení vygenerovaný JWT token, ktorý sa používa pri každej požiadavke na server a je platný po dobu jednej hodiny. Po odhlásení bude JWT token deaktivovaný a ďalej neplatný.
|-
|R04 || Aplikácia sa bude dať vylepšiť || Aplikácia bude implementovaná tak, aby bolo možné v budúcnosti pridať nové, alebo vylepšiť staré funkcie.
|}
Tabuľka 2.2 Nefunkčné požiadavky aplikácie eAurela

=== Minimálne požiadavky pre spustenie aplikácie ===

Nakoľko je aplikáciu možné spustiť na viacerých operačných systémoch (Windows, Mac OS a Linux) a zároveň je dostupná aj v internetovom prehliadači ako internetová aplikácia, je potrebné definovať minimálne požiadavky pre oba typy.

* '''Podporované operačné systémy'''
** Minimálna podporovaná verzia operačného systému Windows je '''Windows 7'''. Staršie verzie tohto operačného systému nie sú podporované,
** Pre operačný systém Mac OS je minimálna podporovaná verzia '''Mac OS 10.10''' (Yosemite). Pre operačný systém Mac OS sú podporované iba 64-bitové verzie,
** Minimálne podporované verzie operačného systému Linux pre spustenie Electron aplikácie sú '''Ubuntu 12.04''', '''Fedora 21''' a '''Debian 8''' ,
* '''Internetový prehliadač'''
** Aplikácia vyvíjaná vo frameworku React závisí od typov javascriptových kolekcií ''Map'' a ''Set''. Niektoré internetové prehliadače tieto kolekcie nemusia poskytovať, napríklad '''Internet Explorer 11''' a staršie verzie tohto prehliadača .

=== Bezpečnosť systému a vplyv na aplikáciu eAurela ===

Bezpečnosť systému zabezpečujú dva prvky. Prvým je, že každý používateľ má priradené meno (login) a heslo (password), pomocou ktorých sa prihlasuje do systému. Po prihlásení sa používateľovi vygeneruje tzv. JWT token, ktorý je platný 1 hodinu. Vygenerovaný JWT token musí byť použitý pre prihlásenie sa do konkrétneho informačného systému, bez neho prihlásenie nie je možné. Po prihlásení do informačného systému sa generuje nový JWT token, ktorý platí iba v danom informačnom systéme a je taktiež platný po dobu jednej hodiny. JWT musí byť odosielaný v každej požiadavke na server, inak je požiadavka neplatná. Po používateľovom odhlásení zo systému, sa JWT token stáva neplatný, tým pádom ho nie je možné znovu použiť.

== Diagram prípadov použitia a návrh štruktúry ==

Táto podkapitola je venovaná diagramu prípadov použitia a ďalej návrhu štruktúry aplikácie, ktoré vyplývajú z funkčných požiadaviek aplikácie. Sú tu popísaní všetci aktéri, ktorí môžu vykonávať v aplikácií rôzne aktivity. Taktiež je tu podrobne popísaná štruktúra aplikácie eAurela.

=== Diagram prípadov použitia ===

Diagram prípadov použitia (Use Case Diagram) zobrazuje správanie systému tak, ako ho vidí používateľ. Účelom je popísať funkcionalitu systému, teda to, čo od neho klient očakáva. Diagram prípadov použitia sa skladá z prípadov použitia (use case), aktérov (actors) a vzťahov medzi nimi.

'''Prípad použitia'''

Prípad použitia je sada niekoľkých akcií, ktoré vedú k dosiahnutiu určitého cieľa. Definuje teda funkcionalitu, ktorú by mal navrhovaný systém obsahovať. Prípady použitia vychádzajú zo zadania systému od zákazníka.

'''Aktér'''

Aktér je rola, ktorá komunikuje s jednotlivými prípadmi použitia. V tejto roli môže byť používateľ, alebo aj externý systém. Aktérom môže byť napríklad Administrátor alebo dokonca aj Čas .

[[File:bpaz_UseCase.png|thumb|500px|Obr. 2.1 Diagram prípadov použitia aplikácie eAurela<span label="fig:usecase"></span>]]

'''Popis aktérov a prípadov použitia'''

* Používateľ:
** každý používateľ, o ktorom sú zaznamenané údaje v databáze na vzdialenom serveri Auth API,
** sú mu zobrazené iba tie údaje zo systému, ku ktorým má pridelené oprávnenia,
** môže si vybrať informačný systém, ku ktorému sa aplikácia pripojí,
** má možnosť si prezerať poslednú nameranú hodnotu zo senzora, prezerať namerané hodnoty vo forme grafu, v časovom intervale, ktorý si zvolí,
** môže si vybrať oblasť a sektor,
* Manage API Admin:
** administrátor konkrétneho informačného systému (Manage API),
** dedí z aktéra ''Používateľ'', teda môže vykonávať rovnaké aktivity ako on,
** navyše môže spravovať porty, sektory, senzory,
** má možnosť zapnúť alebo vypnúť meranie v informačnom systéme,
** taktiež si môže zobraziť všetkých používateľov, ktorí majú k informačnému systému prístup,
* Auth API Admin:
** administrátor serveru slúžiaceho na autorizáciu (Auth API),
** dedí z aktéra ''Manage API Admin'',
** okrem vyššie spomenutých aktivít môže pridať a odstrániť používateľov zo systému, alebo im môže meniť údaje,
** tiež môže spravovať spoločnosti a informačné systémy v nich.

=== Štruktúra aplikácie eAurela ===

Návrh štruktúry aplikácie vychádza z určených funkčných požiadaviek a jednotlivých prípadov použitia. Každý prípad použitia nám určuje samostatnú časť aplikácie. Štruktúra aplikácie eAurela nám popisuje jednotlivé časti a navigáciu medzi nimi. Aplikácie sa skladá z nasledovných častí:

* Home - časť pre prihlasovanie sa do systému,
* AppList - časť pre výber aplikácie,
* AuthAdministration - časť pre správu serveru ''Auth API'',
* ManageAdministration - časť pre správu konkrétnej aplikácie (''Manage API''),
* ManageAddUser - časť pre vytvorenie nového používateľa v aplikácií,
* Sectors - časť pre zobrazenie nameraných hodnôt v sektoroch.

=== Funkcionalita častí aplikácie ===

'''Home'''

Predtým, než si používateľ vyberie aplikáciu a získa prístup k dátam, musí sa prihlásiť. Obrazovka Home slúži pre prihlásenie do systému. Obrazovka Home sa vždy zobrazí hneď po spustení aplikácie eAurela. Používateľ uvidí textové polia pre zadanie prihlasovacích údajov (login a heslo). Po zadaní údajov a kliknutí na tlačidlo prihlásiť, sa pošle na server požiadavka o prihlásenie so zadanými údajmi. V prípade, že sú údaje nesprávne, zobrazí sa upozornenie o zle zadaných údajoch. V prípade, že sú zadané údaje správne, používateľ bude prihlásený a bude presmerovaný do časti Applist. V tejto časti aplikácia komunikuje so serverom pre autorizáciu (''Auth API''). Proces prihlasovania je vyobrazený v diagrame aktivít [[#fig:HomeActivity|2.2]].

[[File:bpaz_LoginActivity.png|thumb|500px|Obr. 2.2 Diagram aktivít časti Home<span label="fig:HomeActivity"></span>]]

'''Applist'''

Táto obrazovka sa zobrazí ako prvá obrazovka ihneď po úspešnom prihlásení. Používateľovi sú zobrazené spoločnosti, ku ktorým má pridelené prístupové práva. V týchto spoločnostiach sa nachádzajú aplikácie, ktoré obsahujú namerané údaje z konkrétnych senzorov, nachádzajúcich sa v danej aplikácii. Po výbere aplikácie bude odoslaná požiadavka o prihlásenie do konkrétnej aplikácie. Údaje zobrazené v tomto okne sú údaje, ktoré sa nachádzajú na serveri pre autorizáciu. Požiadavka o prihlásenie do aplikácie ale smeruje na server konkrétnej aplikácie (''Manage API''). Ak má používateľ pridelené administrátorské práva, môže si taktiež zvoliť možnosť pre prístup do časti AuthAdministration.

[[File:bpaz_ApplistActivity.png|thumb|500px|Obr. 2.3 Diagram aktivít časti Applist<span label="fig:ApplistActivity"></span>]]

'''AuthAdministration'''

Táto časť aplikácie je sprístupnená výhradne administrátorom systému. Sú tu zobrazené informácie o všetkých používateľoch systému a ich prístupových právach k spoločnostiam, zoznam všetkých spoločností a k nim priradených aplikácií. Administrátor systému môže tieto údaje upravovať, ako napríklad meniť práva používateľom, zmeniť používateľovi heslo, meniť a aktualizovať informácie o spoločnostiach a ich aplikáciách. Taktiež môže zmazať existujúcu, alebo vytvoriť novú spoločnosť, či aplikáciu. Táto časť slúži pre spravovanie serveru ''Auth API'' (kapitola [[#sub:auth|[sub:auth]]]).

'''Sectors'''

Táto obrazovka je zobrazená po úspešnom prihlásení používateľa do aplikácie. Pri prihlasovaní do aplikácie sa znovu overuje, či má používateľ administrátorské práva (administrátor na serveri ''Manage API'' nemusí byť aj administrátor na serveri ''Auth API''). Používateľovi sú zobrazené oblasti a sektory, ktoré sa nachádzajú v aplikácií, a zároveň k nim má používateľ prístupové práva. Taktiež sú tu zobrazené aj posledné namerané hodnoty zo senzorov nachádzajúcich sa v sektore. Používateľ si bude môcť vybrať oblasť a sektor, ktorého hodnoty si chce prezerať. V prípade, že si bude chcieť pozrieť časový záznam zo všetkých senzorov daného sektora, môže si zvoliť zobrazenie údajov vo forme časového záznamu. V tomto prípade bude zobrazená časová závislosť (graf) všetkých nameraných údajov zo sektora vo vybranom časovom intervale. Používateľ má možnosť zvoliť časový interval, z ktorého budú následne zobrazené namerané hodnoty. Ak má používateľ administrátorské práva v danej aplikácií, môže si tiež zvoliť prechod do časti ManageAdministration.

[[File:bpaz_SectorsActivity.png|thumb|500px|Obr. 2.4 Diagram aktivít časti Sectors<span label="fig:SectorsActivity"></span>]]

'''ManageAdministration'''

Podobne ako v prípade AuthAdministration, aj k tejto časti majú prístup iba administrátori. Sú tu zobrazené informácie o používateľoch aplikácie, oblastiach, sektoroch a senzoroch. Taktiež tu je možné zastaviť, alebo spustiť meranie. Z tejto obrazovky je možné prejsť k obrazovke pre vytvorenie nového používateľa systému. Táto časť slúži pre spravovanie serveru ''Manage API'' (kapitola [[#sub:manage|[sub:manage]]]).

'''ManageAddUser'''

V tomto okne môže administrátor systému vytvoriť nového používateľa. Pri otvorení tohto okna je zobrazený formulár obsahujúci polia pre vstup údajov nového používateľa. Po vyplnení údajov a potvrdení formulára sa odošle požiadavka na server o vytvorenie nového používateľa. Server skontroluje, či používateľ existuje. Môžu nastať tri možnosti:

# používateľ neexistuje na žiadnom serveri,
# používateľ existuje na serveri pre autorizáciu, ale neexistuje na serveri aplikácie,
# používateľ existuje na obidvoch serveroch.

V prvom prípade sa používateľ vytvorí na obidvoch serveroch. Na oboch serveroch bude mať používateľ priradené najnižšie prístupové práva a bude mať prístup k jednej spoločnosti a jednej aplikácií (tej, z ktorej bol vytváraný). V druhom prípade sa používateľ vytvorí iba na serveri informačného systému, pričom na serveri pre autorizáciu sa používateľovi priradí aplikácia, v ktorej bol vytvorený. Ak používateľ existuje na obidvoch serveroch, ukáže sa informácia, že daný používateľ už existuje. Nakoniec nasleduje presmerovanie do časti ManageAdministration. V nasledujúcom diagrame je zobrazené vytváranie nového používateľa.

[[File:bpaz_AddUserActivity.png|thumb|500px|Obr. 2.5 Diagram aktivít pre vytvorenie nového používateľa<span label="fig:AddUserActivity"></span>]]

Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému

2020-10-19T19:23:26Z

Juraj: Zamkol stránku „Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému“ ([Úprava=Povoliť iba správcom] (na neurčito) [Presun=Povoliť iba správcom] (na neurčito))

{{Hlavička_MTF|{{PAGENAME}}|Adam Zverbík|Ing. Juraj Ďuďák, PhD.|
2019/2020
|Bakalárska práca
|Aplikovaná informatika a automatizácia v priemysle
}}
[[Kategória:Študentské práce]][[Kategória:Bakalárske práce]][[Kategória:Informatika]]

{{Praca_uvod|1|Klientská aplikácia pre zobrazenie dát ako súčasť senzorického informačného systému|Informačný systém Sensorical|Analýza požiadaviek a štruktúra klientskej aplikácie|Nástroje použité na vývoj aplikácie eAurela|Implementácia aplikácie eAurela|Uvedenie aplikácie eAurela do produkcie}}

__TOC__

{{Abstrakt
|Cieľom záverečnej práce je vyvinúť a implementovať multiplatformnú desktopovú aplikáciu a web aplikáciu. Výsledkom tejto práce je funkčná klientská aplikácia pre zobrazenie dát a spravovanie senzorického informačného systému Sensorical. V prvej kapitole je opísaný systém Sensorical, jeho dátový model a komunikácia so serverom. Druhá kapitola sa venuje analýze požiadaviek a štruktúre aplikácie. V tretej kapitole sú popísané nástroje, ktoré boli použité pri vývoji aplikácie. Štvrtá kapitola pojednáva o implementácií a piata kapitola je venovaná buildovaniu aplikácie.
<br />|The aim of the bachelor thesis is to develop and implement multiplatform desktop application and web application. The result of this thesis is functional client application, which shows and manages data of the sensoric information system Sensorical. Data model of sensorical system and communication with server is described in the first chaper. The second chapter is dedicated to analyze requirements and structure of the application. The tools used in development process are described in the third chapter. The fourth chapter is about implementation and the fifth chapter describes building of the final application.<br />
}}

'''Úvod'''

Internet. Dnes si život bez neho vieme iba ťažko predstaviť. Obrovské množstvo ľudí sa pripojí na internet každý jeden deň. Či už si chcú nájsť nejakú informáciu, objednať niečo z internetového obchodu, pozrieť seriál, film, alebo chcú komunikovať s ďalšími ľuďmi, pripojenými na druhom konci sveta. Internet je stále dostupnejší. Vďaka novým, vyspelejším technológiám sa stáva pripojenie stabilnejšie a rýchlejšie. Práve kvôli tomu sú internetové aplikácie stále populárnejšie. Takáto aplikácia je plnohodnotná aplikácia, ale používateľ si nemusí nič inštalovať do svojho počítača, jednoducho sa pripojí na internet a v pohodlí internetového prehliadača si aplikáciu spustí.

Vzhľadom na neustály pokrok technológií sú stále výkonnejšie a dostupnejšie aj samotné počítače. S rastúcim výkonom počítačov rastie aj popularita jazyka JavaScript a jeho frameworkov, nakoľko moderné počítače si s ním hravo poradia. To umožňuje vývoj moderných, dynamických aplikácií s použitím internetových technológií. Takýmito frameworkami sú aj React a Electron. React umožňuje beh jedno-oknovej (single-page) aplikácie v internetovom prehliadači, Electron zase v okne operačného systému. Kombináciou týchto dvoch frameworkov vznikne multiplatformná desktopová aplikácia dostupná aj z internetového prehliadača.

Senzorický informačný systém Sensorical je systém, ktorý zaznamenáva a analyzuje namerané environmentálne dáta. Dáta sú zaznamenávané meracími zariadeniami, ktoré merajú hodnoty v určitých časových intervaloch a po zaznamenaní tejto hodnoty komunikujú so vzdialeným serverom, kde sa tieto dáta ukladajú. Tento informačný systém obsahuje desktopovú aplikáciu, internetovú aplikáciu a aplikáciu pre operačný systém Android.

Cieľom práce je naprogramovať a implementovať multiplatformnú desktopovú aplikáciu, ktorá dostala názov eAurela. Aplikácia eAurela bude dostupná aj z internetového prehliadača, čo značne zjednoduší spravovanie celého systému Sensorical. Aplikácia bude zobrazovať posledné namerané hodnoty z meracích zariadení a grafické výstupy z vybraných časových intervalov. Administrátori informačného systému budú mať možnosť z aplikácie spravovať celý systém.

= Informačný systém Sensorical =

Informačný systém Sensorical je systém, ktorý bol navrhnutý v spoločnosti TNTech s.r.o. a je to ucelený systém pre zber a analýzu environmentálnych dát. Tento systém sa skladá z hardvérovej a softvérovej časti.

==== Hardvérová časť ====

Skladá sa z meracích zariadení (senzorov), ktoré vysielajú namerané dáta a z jedného alebo viacerých prijímacích modulov, ktoré pokrývajú monitorovanú oblasť.

Meracie zariadenie má za úlohu spracovať namerané hodnoty, pripraviť telemetrické dáta, formátovať dáta podľa určeného kľúča a odoslať spracované údaje prostredníctvom rádiového rozhrania.

Modul prijímača je určený pre bezdrôtový príjem dát odoslaných meracími zariadeniami. Obsahuje tiež modul komunikačného rozhrania RS485, čo umožňuje zaradiť viac prijímacích modulov na jeden káblový rozvod.

==== Softvérová časť ====

Merací systém je určený pre dlhodobé merania. Softvérovú časť môžeme ďalej rozdeliť na dátovú a aplikačnú časť.

Dátová sa skladá z dvoch databázových modelov a z aplikačného programového rozhrania (API).

Prvý databázový model predstavuje databázu, ktorá slúži pre uchovávanie informácií potrebných na autorizáciu, a taktiež informácie o aplikáciach pre zber environmentálnych dát, s ktorými systém pracuje (viď [[#sub:auth|1.1.1]]). Táto databáza je uložená na serveri, ktorý bol pomenovaný ''Auth API''.

Druhý databázový model je reprezentovaný databázou, ktorá uchováva údaje o konkrétnej aplikácii zberu dát (viď [[#sub:manage|1.1.2]]). Pre každú aplikáciu je vytvorená vlastná databáza, ktorá môže byť uložená na serveri ''Auth API'' alebo na ľubovoľnom inom. Pre jasnú identifikáciu sa tieto servery nazývajú ''Manage API''. Informácie o serveroch sa nachádzajú v prvom databázovom modeli.

V aplikačnej časti sa nachádza viacero softvérových produktov. Tieto produkty slúžia na prístup a analýzu nameraných údajov , .

== Dátový model ==

Pre systém Sensorical boli vytvorené dva databázové modely. Prvý model sa týka autorizácie používateľov. Databáza sa delí na časti: časť definujúca používateľov systému, časť definujúca spoločnosti a aplikácie, časť s obmedzeniami používateľov.

Druhý model sa týka konkrétnych aplikácií zberu dát. Aplikácia môže byť spustená na serveri, kde je spustená autorizácia používateľov, ale taktiež môže byť spustená aj na inom serveri. Tento model sa delí na časti: časť rozmiestnenia senzorov, časť s informáciami o senzoroch, časť pre ukladanie nameraných hodnôt.

=== Dátový model pre autorizáciu ===

Tento model definuje všetkých používateľov systému Sensorical. Pri prihlasovaní do systému prebieha porovnávanie údajov s údajmi uloženými v tejto databáze. Štruktúra tabuliek, označenie primárnych kľúčov a dátových typov jednotlivých atribútov je zobrazená na obrázku obr. [[#fig:dblogin|1.1]].

'''Štruktúra dátového modelu pre autorizáciu'''

[[File:bpaz_login.png|thumb|500px|Entitno-relačný diagram dátového modelu pre autorizáciu používateľov<span label="fig:dblogin"></span>]]

'''Časti dátového modelu pre autorizáciu'''

* časť definujúca všetkých používateľov systému:
** entitná množina '''Users''',
* časť definujúca spoločnosti a aplikácie:
** entitné množiny '''Companies, Apps, Servers''',
* časť s obmedzeniami používateľov:
** entitné množiny '''Restrictions, AppRestrictions'''.

=== Časť definujúca používateľov systému ===

Systém Sensorical môže používať viacero používateľov, preto je nevyhnutné zaznamenávať informácie o používateľoch, ich údaje a práva.

'''Users'''

Každému používateľovi je vytvorené prihlasovacie meno (login) a heslo (password), ktorými sa prihlasuje do systému. Atribút isAdmin hovorí, či má používateľ administrátorské práva.

=== Časť definujúca spoločnosti a aplikácie ===

Entitné množiny v tejto časti obsahujú informácie o spoločnostiach a aplikáciách, ku ktorým sa dá pripojiť, a taktiež o serveroch, na ktorých sa dané aplikácie nachádzajú.

'''Companies'''

Zoznam všetkých spoločností. Entitná množina ''UserCompanies'' určuje, ktorý používateľ má prístup k spoločnosti.

'''Apps'''

Zoznam všetkých aplikácií zberu dát, ku ktorým sa dá prihlásiť. Vzťah medzi entitnými množinami ''Companies'' a ''Apps'' je 1:N, teda spoločnosť môže mať viacero aplikácií, ale aplikácia sa môže nachádzať iba v jednej spoločnosti.

'''Servers'''

Každá aplikácia sa môže nachádzať na inom serveri. Táto entitná množina definuje práve informácie o serveroch a ich URL adrese.

=== Časť s obmedzeniami používateľov ===

Tieto entitné množiny nám upresňujú určité obmedzenia práv používateľov.

'''Restrictions a AppRestrictions'''

Definujú obmedzenia používateľov do konkrétnych aplikácií.

=== Dátový model aplikácie zberu dát ===

Tento dátový model definuje konkrétnu aplikáciu zberu dát. Daná databáza môže byť spustená na rovnakom serveri, ako je hlavný server systému Sensorical (''Auth API''), alebo na ľubovoľnom inom. Pre jasnú identifikáciu sa tieto servery nazývajú ''Manage API''. Štruktúra tabuliek, označenie primárnych kľúčov a dátových typov jednotlivých atribútov je zobrazená na obrázku obr. [[#fig:dbnsoric|1.2]].

'''Štruktúra dátového modelu informačných systémov'''

[[File:bpaz_nsoric.png|thumb|500px|Entitno-relačný diagram dátového modelu aplikácie zberu dát<span label="fig:dbnsoric"></span>]]

'''Časti dátového modelu aplikácie zberu dát'''

* časť definujúca rozmiestnenie senzorov v oblasti:
** entitné množiny '''Areas, Sectors, Sensors, SensorSectors, GroupViews,'''
* časť pre ukladanie nameraných hodnôt:
** entitné množiny '''MeasuredValues, MeasuredDates''',
* časť s informáciami o senzoroch:
** entitné množiny '''SensorProperties, Types, TypesGroup1, TypesGroup2''',
* časť definujúca používateľov informačného systému:
** entitné množiny '''Users, UserGroups'''.

=== Časť definujúca používateľov systému ===

K danej aplikácií nemusí mať prístup každý používateľ systému Sensorical.

'''Users'''

V tejto entitnej množine sú informácie o používateľoch, ktorý majú prístup k danej aplikácii. Na serveri je každému používateľovi vygenerovaný dočasný JWT token, ktorý je používaný v ďalších požiadavkách na server ako autorizačný kľúč.

'''UserGroups'''

Táto entitná množina definuje práva používateľa.

=== Časť rozmiestnenia senzorov ===

Umiestnenie meracích zariadení je zabezpečené hierarchickou štruktúrou. Najvyššia časť tejto štruktúry je oblasť (''Areas''). V oblasti sa nachádzajú sektory (''Sectors''), v ktorých sa nachádzajú dané senzory (''Sensors'').

'''Areas'''

Zoznam všetkých oblastí v konkrétnej aplikácií. Počet oblastí je neobmedzený. Používateľ musí mať definované práva pre prístup k danej oblasti. Tieto práva definuje entitná množina ''GroupViews''

'''Sectors'''

Definuje zoznam všetkých sektorov. Jeden sektor sa môže nachádzať iba v jednej oblasti, ale oblasť môže obsahovať niekoľko sektorov.

'''Sensors'''

Táto entitná množina definuje zoznam meracích zariadení v danom informačnom systéme.

'''SensorSectors'''

Upresňuje vzťah medzi entitnými množinami ''Sectors'' a ''Sensors''. Nakoľko do sektoru môže byť umiestnených viacero senzorov a môže sa stať, že jeden senzor je priradený do viacerých sektorov, je tu použitý vzťah M:N.

=== Časť pre ukladanie nameraných hodnôt ===

Táto časť zabezpečuje ukladanie nameraných hodnôt. Okrem nameraných hodnôt sa ukladá aj dátum a čas merania, ktorý je potrebný kvôli zobrazeniu časovej závislosti.

'''MeasuredDates'''

V tejto entitnej množine prebieha ukladanie dátumu a času merania. Vďaka tomu možno vidieť, kedy ktoré meranie prebehlo.

'''MeasuredValues'''

V tejto entitnej množine prebieha ukladanie hodnôt nameraných senzormi. Táto množina je prepojená s množinami ''Sensors'' a ''MeasuredDates'', čo zabezpečuje priradenie hodnoty k senzoru a tiež aj k dátumu a času merania.

=== Časť s informáciami o senzoroch ===

V tejto časti modelu je definovaná kategorizácia senzorov, ich vlastnosti a typy.

'''SensorProperties'''

Definícia vlastností meracích zariadení. Každý senzor má svoju maximálnu a minimálnu prípustnú hodnotu. Táto entitná množina slúži pre zobrazenie týchto hodnôt.

'''Types'''

Určuje typ daného senzora.

'''TypesGroup1'''

Keďže senzory môžu merať rôzne fyzikálne veličiny, v tejto entitnej množine sú zadefinované všetky fyzikálne jednotky senzorov.

== Komunikácia so serverom ==

Na komunikáciu so serverom bol použitý dátový prenos s architektúrou klient-server. Jedná sa o dvojvrstvovú architektúru, kde klient obsahuje používateľské rozhranie a aplikačnú logiku, pričom na serveri beží relačná databáza.

K prístupu údajov, ktoré sú na serveri uložené, slúži aplikačné programové rozhranie (REST API) a komunikačný protokol definovaný práve nad týmto API.

=== Požiadavky posielané na server ===

Požiadavky, ktoré sú aplikáciou odosielané na server musia byť posielané vo formáte JSON.

'''Údaje, ktoré môžu byť odosielané pre Auth API'''

* ''login'' - prihlasovacie meno používateľa,
* ''password'' - prihlasovacie heslo používateľa,
* ''company ID'' - ID spoločnosti,
* ''application ID'' - ID aplikácie.

'''Údaje, ktoré môžu byť odosielané pre Manage API'''

* ''Authorization''
** v tomto parametri je uvedený JWT token vygenerovaný serverom (viac v kapitole [[#bezpecnost|[bezpecnost]]]),
** povinný údaj, ktorý treba uvádzať v každej požiadavke na Manage API,
** slúži pre autorizáciu používateľa,
* ''application''
** názov aplikácie zberu dát,
** povinný údaj pri prihlasovaní sa k vybranej aplikácií,
* ''user-login''
** prihlasovacie meno používateľa
* ''area/sector/sensor ID''
** ID oblasti/sektoru/senzoru
* ''interval''
** časový interval pri zobrazovaní nameraných hodnôt vo forme grafu,
* ''factor''
** doplnenie parametru interval,
** je to celé číslo, základná hodnota je 1
** slúži pri vysokých intervaloch, server bude posielať iba každú n-tú hodnotu, kde n je práve hodnota parametra factor

=== Odpovede zo servera ===

Odpovede, ktoré aplikácia obdrží zo servera sú tiež vo formáte JSON. Odpovede sa delia na dve fázy.

'''Prvá fáza: stav'''

Stav definuje úspešnosť alebo neúspešnosť pripojenia (vlastnosť ''status'') Môžu nastať 3 variácie stavov. Stav 200 hovorí o úspešne spracovanej požiadavke.

[[File:bpaz_response1.png|thumb|250px|Odpoveď 200 zo servera<span label="fig:response1"></span>]]

Stav 4XX je chybový stav. Pri tomto type stavu je chyba na strane klienta (nesprávne prihlasovacie údaje, nesprávna URL adresa, chýbajúci JWT token a podobne). Môže nadobúdať hodnoty od 400 do 499 vrátane (Obr. [[#fig:response404|[fig:response404]]]).

Stav 5XX je taktiež chybový stav. V tomto prípade je chyba ale na strane servera a nie u klienta. Môže nadobúdať hodnoty od 500 do 599 vrátane (Obr. [[#fig:response500|[fig:response500]]]).

[[File:bpaz_response404.png|thumb|250px|Odpoveď 404<span id="fig:response404" label="fig:response404">[fig:response404]</span>]]

[[File:bpaz_response500.png|thumb|250px|Odpoveď 500<span id="fig:response500" label="fig:response404">[fig:response500]</span>]]

'''Druhá fáza: konkrétne hodnoty'''

Ak bola posielaná požiadavka úspešná (status: 200), potom druhá fáza odpovede zo serveru obsahuje konkrétne hodnoty, ktoré boli v požiadavke zažiadané.

[[File:bpaz_response2.png|700px|alt=Odpoveď obsahujúca konkrétne hodnoty<span label="fig:response2"></span>|Odpoveď obsahujúca konkrétne hodnoty<span label="fig:response2"></span>]]