APLIKACE PRO VÝPOČET FREKVENČNÍCH CHARAKTERISTIK PRO MOBILNÍ ZAŘÍZENÍ S ANDROIDEM

APLIKACE PRO VÝPOČET FREKVENČNÍCH CHARAKTERISTIK PRO MOBILNÍ ZAŘÍZENÍ

S ANDROIDEM

Diplomová práce

Studijní program: N2301 – Strojní inženýrství

Studijní obor: 2301T049 – Výrobní systémy a procesy

Autor práce: Bc. Martin Sova

Vedoucí práce: Ing. Michal Moučka, Ph.D.

Liberec 2015

Poděkování

Chtěl bych poděkovat vedoucímu mé diplomové práce Ing. Michalu Moučkovi, Ph.D. za jeho cenné rady, konzultace, trpělivost a ochotu při zpracování této diplomové práce.

Dále bych chtěl poděkovat mé rodině a kolegům za podporu v kombinované formě studia.

Anotace

Diplomová práce se zabývá vývojem aplikace pro výpočet frekvenčních charakteristik pro mobilní zařízení s operačním systémem Android. Aplikace využívá technologie programovacího jazyka Java. Práce sumarizuje dostupné alternativní aplikace v dané problematice, a zároveň může sloužit jako návod, jak vytvořit jiné aplikace pro analýzu systémů. Výsledek práce by měl sloužit k rychlému výpočtu a analýze frekvenční charakteristiky s možností exportu dat.

Annotation

The thesis deals with the development of an application for the calculation of frequency characteristics for mobile devices with the Android. The application uses the Java programming language. The work summarizes the available alternative applications in the topic and can serve as a guide on how to create other applications for system analysis.

The work result should help to quick calculating and analyzing the frequency characteristics with data export options.

1 OBSAH

1 ÚVOD ... 2

2 VÝVOJ PRO ANDROID ... 3

2.1 Instalace Android Studia ... 3

2.2 Nastavení SDK ... 5

2.3 Základní pojmy ... 7

2.4 Vytvoření prvního projektu ... 10

2.5 Struktura projektu a životní cyklus Activity ... 12

2.6 Časté problémy a jejich řešení ... 16

3 PRŮZKUM ALTERNATIV ... 19

4 FREKVENČNÍ CHARAKTERISTIKY ... 24

4.1 Frekvenční přenos ... 24

4.2 Frekvenční charakteristika ... 28

4.3 Asymptoty amplitudové a fázové charakteristiky ... 30

5 REALIZACE APLIKACE ... 33

5.1 Návrh uživatelského rozhraní a zadávání dat ... 33

5.2 Používané třídy a popis hlavních tříd ... 37

5.3 Pomocné třídy ... 48

5.4 Vykreslovací třídy ... 55

5.5 Doplňkové třídy ... 62

6 OVĚŘENÍ FUNKČNOSTI ... 64

7 ZÁVĚR ... 68

Seznam obrázků ... 69

Seznam tabulek ... 70

Seznam použité literatury ... 71

Obsah přiloženého CD ... 73

2

1 ÚVOD

Tato diplomová práce popisuje tvorbu aplikace pro výpočet frekvenčních charakteristik pro mobilní operační systém Android. Aplikace využívá možností prostředí Android a programovacího jazyka Java. Práce se zabývá prvními kroky ve vývoji pro Android, jako je představení základních pojmů a konfigurace vývojového prostředí Android Studio, které je oficiálním Android vývojářským prostředím. V této práci jsou také shrnuty poznatky autora o vzhledu a funkčnosti dostupných aplikací, které umožňují vykreslování frekvenčních charakteristik. Rešerše je zahrnuta proto, aby bylo jisté, že tvorba nové aplikace pro vykreslování frekvenčních charakteristik má smysl. Důležitá je zejména pro uvědomění si případných nedostatků, které dostupné aplikace obsahují, a případné navržení možného rozšíření vytvořené aplikace. Dále je v práci nastíněna teorie o frekvenčních charakteristikách, o jejich výpočtu a kreslení asymptot. Aplikace by měla sloužit zejména pro rychlé a jednoduché určení frekvenčních charakteristik. Nelze ovšem předpokládat, že aplikace pro mobilní zařízení nahradí možnosti komerčních produktů, jako je např. Matlab.

Pro splnění daného úkolu je potřeba držet se určeného plánu:

1. Nastudování prostředí Android

a. Nastudování dostupných metod a seznámení se s Android prostředím b. Tvorba základních programů

2. Rešerše dostupných aplikací

3. Nastudování frekvenčních charakteristik a. Výpočet hodnot

b. Vykreslování asymptot 4. Vývoj jednotlivých komponent 5. Zprovoznění a odladění aplikace

Hlavním cílem práce je vytvořit mobilní aplikaci, která umožní snadný a rychlý výpočet frekvenční charakteristiky, zobrazení grafů, asymptot a možností uložení výsledků.

3

2 VÝVOJ PRO ANDROID

Android je v současnosti nejrozšířenější a stále expandující mobilní operační systém. Návodů jak začít s vývojem pro tuto platformu je v dostupné literatuře i na internetu k dispozici velmi mnoho. Programátor začínající s touto platformou se však může setkat s celou řadu úskalí, které by tato práce měla objasnit a urychlit tak seznamování s platformou Android.

V době psaní této práce je dostupné vývojové API (Application Programming Interface) ve verzi API Android 22 (Android 5.1), ale vývoj Androidu je neuvěřitelně rychlý, takže to co je dnes nejvhodnější způsob použití, může být například za rok od dokončení této práce již zastaralé. Ovšem s ohledem na kompatibilitu sice všechno bude fungovat, ale nemusí to odpovídat novým trendům.

Nástrojů pro vývoj je dostupných mnoho. Mezi nejvhodnější nástroje patří Android Studio nebo Eclipse s ADT (Android Development Tools) pluginem. Jelikož Android Studio je zároveň v době psaní této práce oficiálním vývojovým prostředím, tak se tato práce bude zabývat prací s tímto IDE (Integrated Development Environment).

Tento popis se bude zabývat použitím vývojového nástroje s operačním systémem Windows, v případě této práce konkrétně Windows 8.1 64bitová edice. Důležité je zmínit, že vývoj pro platformu Android vyžaduje alespoň základní znalost anglického jazyka.

Autorem je doporučeno vyvíjet pro Android na modernějším PC. Konfigurace notebooku s 4GB operační paměti a mobilní verzí procesoru Intel Core i5, se ukázala jako nevhodná pro pohodlný vývoj. Je doporučena konfigurace počítače s minimálně 8 GB operační paměti.

V praxi se také ukázalo, že moderní SSD disk ušetří při vývoji spoustu času a zpříjemní práci.

2.1 Instalace Android Studia

Tato práce předpokládá alespoň základní znalost jazyka Java a nainstalované prostředí Java JDK (Java Development Kit), které je nezbytné pro běh Android Studia (pro Eclipse IDE také).

Pouze nainstalované JRE (Java Runtime Environment), které slouží pouze ke spouštění Java aplikací, nestačí. Java JDK lze nejlépe stáhnout přímo z oficiálních stránek http://www.oracle.com/technetwork/java/javase/downloads/index.html. Minimální verze pro používání Android Studia je v současné době JDK verze 6. Pro vývoj pro Android 5.0 je minimální JDK verze 7. Na 64bitových operačních systémech je potřeba nainstalovat 64bitovou

4

verzi JDK, která musí být zařazena v systémových proměnných. Android Studio by si mělo samo ověřit správnost verze JDK. Pokud je na počítači správná verze Java JDK instalace by měla probíhat bez problémů. Android Studio lze stáhnout z oficiálních stránek http://developer.android.com/sdk/index.html.

Pokud Android Studio nenalezne JDK, je potřeba vložit správnou cestu JDK do systémových proměnných. Toto lze nejlépe ve Windows 8.1 provést takto: Pravý klik na tlačítko Start >

Upřesnit nastavení systému > Proměnné prostředí a zde se cesta vloží jako systémová proměnná s názvem JAVA_HOME. Pokud není nainstalovaná žádná verze JDK, Android Studio samo nabídne odkaz ke stažení JDK verze 7.

JAVA_HOME

Tato proměnná musí obsahovat kořenový adresář instalace Javy (obr. 2.1-1):

c:\Program Files\Java\jdk1.7.0_25\

Obr. 2.1-1: Vložení nové systémové proměnné

Po nastavení této proměnné a potvrzení dialogového okna tlačítkem „OK“ je Java nakonfigurovaná. Po znovuspuštění instalátoru by se automaticky měla znovu zkontrolovat správnost JDK a bez problémů pokračovat v instalaci.

Při instalaci je nutné nainstalovat Android Virtual Device, které umožní ověření funkčnosti aplikace na různých rozlišení a zařízení. Také je potřeba na počítačích s procesorem Intel s podporou virtualizace nainstalovat hypervizor (Performance (Intel® HAXM)), který zajistí optimalizaci výkonu spuštěného virtuálního Android zařízení (obr. 2.1-2).

5

Obr. 2.1-2: Android Studio Setup

Jak již bylo zmíněno, Android Studio při instalaci nabídne konfiguraci a nainstalování virtuálního Android zařízení. Je zde přednastaveno 2 GB operační paměti. Autor této práce doporučuje zachovat tuto hodnotu, je však potřeba mít počítač s alespoň 6 GB operační paměti.

Jinak se vývoj aplikací pro Android stane velice nekomfortním.

2.2 Nastavení SDK

Důležitá věc pro vývoj je volba SDK a API pro které se bude aplikace vyvíjet. Proto se po prvním spuštění Android Studia klikne na Configure > SDK Manager (obr. 2.2-1).

6

Obr. 2.2-1: První nastavení

V nově otevřeném okně je potřeba zkontrolovat zda jsou všechny potřebné komponenty zatržené a nainstalované. Pro pohodlný vývoj je autorem doporučeno mít nainstalované tyto komponenty (obr. 2.2-2):

a. Tools

1. Android SDK Tools

2. Android SDK Platform-tools b. Android 5.1 (API 22)

1. Všechny možnosti v rozbalovacím seznamu c. Extras

1. Android Support Repository 2. Android Support Library 3. Google Repository 4. Google USB Driver

5. Intel x86 Emulator Accelerator (HAXM installer)

7

Obr. 2.2-2: SDK Manager

Po nainstalování se již může kliknout na „Start a new Android Studio project“ a nerušeně se zabývat vývojem.

2.3 Základní pojmy

Před samotnou tvorbou první aplikace je potřeba objasnit některé pojmy, které se v operačním systému Android používají.

Activity

Hlavní částí programu, bez níž by nešla aplikace ani spustit, je tzv. activity. Activity je pro představu takzvaná prezentační vrstva aplikace. Hlavním úkolem této vrstvy je zajistit, aby se všechna data, která získá od nižších vrstev, správně zobrazila uživateli. Každá activity je potomkem třídy Activity [10],[11].

8

View

View je pro představu něco jako HTML. Každá activity si vytváří všechny instance view, které potřebuje, případně využije XML souboru, kde jsou všechna potřebná view uložená. Ta potom activity naplňuje daty, mění je, maže atd. Každé view je potomkem třídy View.

V naprosté většině případů se view specifikují staticky v XML souborech, které jsou ve složce

„/res/layout“. Každý XML soubor má volitelný název, který musí začínat malým písmenem a končit koncovkou „.xml“. Jméno tohoto XML souboru se dále využívá v celém projektu jako identifikátor. Pokud je tedy potřeba nějaké view použít v projektu, lze se na něj snadno odkázat před identifikátor.

View má velice důležitou podtřídu, a to ViewGroup. Na rozdíl od View dokáže ViewGroup obalovat jednu nebo více instancí view. Nejdůležitějšími ViewGroup jsou třídy končící na Layout, které se liší tím, jak rozmisťují své potomky.

V Android Studiu je k dispozici tzv. WYSIWYG (What You See Is What You Get) editor, ve kterém lze pohodlně rozmístit veškeré view, které jsou v projektu potřeba. Ovšem je nutno zmínit, že to co může vypadat v editoru dobře, se může za určitých okolností při používání aplikace rozbít, a celý layout nebude fungovat [10],[11].

Identifikátory

Důležitými prvky jsou již zmíněné také tzv. identifikátory. Ty jsou v Androidu statickými vlastnostmi třídy R. R třída, která je generována automaticky na základě obsahu složky „res“.

Například pomocí R.drawable.new_draw se může odkázat na soubor new_draw.xml ve složce „/drawable/“ [10],[11].

Manifest

Manifest je XML soubor, ve kterém jsou uloženy všechny Activity, informace o aplikaci, téma aplikace atd. Je potřeba vždy pamatovat na to, že po přidání jakékoliv Activity do projektu, se musí tato informace uložit i do manifestu. Jinak bude aplikace nefunkční [10],[11].

9

Jednotky

Každé zařízení může mít jinou velikost displeje a jiné rozlišení. Jako velikost displeje se udává velikost úhlopříčky v palcích. Každé zařízení má také specifické rozlišení, které udává, kolik pixelů (elementárních obrazových bodů) má. Udává se také tzv. pixel density, které pod zkratkou DPI určuje jemnost zobrazení displeje. Má-li displej hustotu například 440 DPI, znamená to, že na každý palec fyzické velikosti displeje připadá 440 pixelů.

Protože existuje mnoho velikostí zařízení s Android OS, je zavedena jednotka DP, která znamená density-independent pixel. Je to virtuální jednotka, která je definována vztahem (1) [10],[11].

1 𝑑𝑝 = 160𝑝𝑥/𝑑𝑝𝑖 (1)

Intent

Intent-y jsou asynchronním můstkem mezi jednotlivými stavebními prvky jako např.

activity či services. Umožňuje interakci s komponenty jak v rámci jedné aplikace, tak i s komponenty obsažené v jiných aplikacích. Například activity může spustit jinou activity, která umožňuje pořízení obrázku.

Intent-y jsou jednoduché objekty typu android.content.Intent. V samotném kódu se tak může definovat, které komponenty jsou cílem. Například metoda startActivity() může definovat, že intent by měl spustit jinou activity. Intent obsahuje data přes tzv.

Bundle. Ten právě může být použit k přijmutí dat obsažených v intentu [11].

Android podporuje tzv. explicitní a implicitní intenty:

Explicitní intenty:

1. Explicitní intenty definují komponentu, která by se měla zavolat přímo Androidem použitím Java třídy jako identifikátoru.

2. Takto může vypadat explicitní intent:

Intent intent = new Intent(this, GraphScreens.class);

intent.putExtra(GraphScreens.NUMERATOR, numerator);

intent.putExtra(GraphScreens.DENUMERATOR, denumerator);

Explicitní intenty jsou typicky používány jako třídy řízené vývojářem.

10 Implicitní intenty:

Implicitní intenty specifikují přímo záměr (akci), která by se měla provést a volitelná data, která zprostředkují obsah pro záměr. Nespecifikují tedy přesný způsob, jak intent provést. Tím v mnoha případech zjednodušují práci a také umožňují vzájemnou interoperabilitu aplikací v rámci Android OS.

V případě, že si vývojář přeje zobrazit stránku http://www.fs.tul.cz, musí při použití explicitního intentu vyzkoušet přítomnost všech možných prohlížečů a spustit ten, který by se ukázal jako první dostupný. Použitím implicitního intentu se tento případ zjednodušuje:

Intent i = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.fs.tul.cz"));

startActivity(intent);

Na základě dat v intentu a použitím metody startActivity(), Android zjistí, které Activity mají nastavený takový intent filter, že je slučitelný s daty v intentu. Pokud je jich více, Android uživateli zobrazí dialog s výběrem té, která daný intent splní. V opačném případě se objeví ActivityNotFoundException [11].

2.4 Vytvoření prvního projektu

Po kliknutí na „Start a new Android Studio project“ se objeví nové okno „Create New Project“, kde se vyplní „Application name“, „Company domain“ tak jako je to na obrázku 2.4-1, a může se ponechat defaultní lokace. Kliknutím na „Next“ se vytvoří nové okno s podtitulkem „Target Android Devices“, kde vývojář nastavuje cílová zařízení, na které může být aplikace nainstalována. V tomto případě se ponechá zaškrtnuté políčko „Phone and Tablet“, protože i tato práce je zaměřena jen právě na mobilní zařízení, jako je tablet či mobilní telefon.

Vývojář má také možnost nastavit, jaká nejnižší verze Androidu musí být na zařízení k dispozici, aby mohla být aplikace nainstalována. Toto rozhodnutí ovlivní kolik procent zařízení, může aplikaci nainstalovat, a také jaké moderní nástroje může vývojář používat.

Například u vyššího API se můžou používat nejen nějaké pokročilé animace, ale také si vývojář velice usnadní programování. Například u nízkého API se musí řešit zákaz změny orientace nebo možnost uspávání Activity přímo v Java kódu, což je značně složitější oproti řešení stejného problému ve vyšším API, kde stačí mnohdy jen jeden řádek v XML kódu. Pokud je

11

tedy potřeba vyvíjet nějakou složitější hru či aplikaci, která potřebuje nějaké komplikovanější animace atd., je obecně vhodnější zvolit vyšší hodnotu API kvůli více funkcím. Na obrázku 2.4-2 je možno vidět zvolené API 15, které podporuje, v době psaní práce, přes 90% zařízeních [10],[11].

Obr. 2.4-1: Nový projekt

12

Obr. 2.4-2: Výběr API

Pokud bylo vše nastaveno jak je potřeba, tak po kliknutí opět na „Next“ následuje přesun do zvolení „Activity“. V ukázkovém případě se ponechá „Blank Activity“ a po opětovném zvolení

„Next“ následuje okno s tlačítkem „Finish“. Zde je možnost upravit názvy základní activity, rozložení či menu. Po potvrzení následuje krátké vytváření projektu a po dokončení se již může tvořit aplikace.

Pro ověření funkčnosti se klikne na Run > Run ‘app’, následně se potvrdí spuštění emulátoru tlačítkem “OK” a vyčká se na spuštění. Po několika minutách se spustí Android OS s defaultní nainstalovanou aplikací a textem “Hello World”.

2.5 Struktura projektu a životní cyklus Activity

Pro další případný vývoj je potřeba znát strukturu celého projektu. Je to obzvlášť důležité v případě obsahově náročných aplikací. Vývojář by měl mít na paměti, že do XML souborů si může ukládat texty, styly, položky menu i samotný vzhled aplikace.

Na obrázku 2.5-1 je vidět zjednodušená struktura projektu. Pokud je potřeba vidět složitější verzi, nechá se přepnout volba zobrazení tlačítkem „Android“ a změnou na hodnotu „Project“.

Složka „app“ se větví na:

1. manifest – zde jsou zapsány informace o aplikaci, activity atd.

2. java – obsahuje zdrojové Java kódy

13

3. res – tato složka obsahuje veškeré resources (suroviny), které se využívají v projektu a. drawable – může obsahovat bitmapové obrázky nebo speciální XML soubory,

které Android umí převést na obrázek b. layout – obsahuje layoutové soubory

c. menu – obsahuje XML soubory s definovanými menu.

d. mipmap – obsahuje obrázky ikon pro různá zařízení

e. values – obsahuje určité XML soubory ve speciálním formátu s různými hodnotami používanými napříč celou aplikací

Obr. 2.5-1: Struktura projektu

Těchto složek si vývojář může vytvořit více, například pro vložení externích knihoven atd. Je potřeba ale ještě objasnit složku values, která má velký význam [10],[11].

14

VALUES

Složka values, jak již bylo řečeno, obsahuje XML soubory ve speciálním formátu. V podstatě se jedná o jednoduché „suroviny“, jako jsou textové řetězce, čísla, styly a tak dále. Je možné mít všechna potřebná data v jednom XML souboru, ale všeobecná konvence radí mít data separovaná a soubory pojmenovat podle typu obsahu, tzn. strings.xml, styles.xml nebo arrays.xml.

Každý obsažený soubor má kořenový element <resources>, který může mít potomky jako

<color>, <string> atp., které definují dané hodnoty. Podle toho se také vytváří identifikátor. Tedy například R.string bude obsahovat řetězce a R.color bude obsahovat barvy. Každá hodnota musí mít „attribut name", jehož hodnota je poslední částí identifikátoru, která se může volat.

Například tedy řetězec s atributem name=“hello_string“ bude mít identifikátor R.string.hello_string. Jiný soubor s řetězci může vypadat například takto:

<?xml version="1.0" encoding="utf-8"?>

<resources>

<string name="app_name">TULBode</string>

<string name="action_settings">Settings</string>

<string name="decade_count">Počet dekád</string>

<string name="radhz_count">Jednotky</string>

<string-array name="radHz">

<item>[rad/sec]</item>

<item>[Hz]</item>

</string-array>

<string name="about">TULBode. Vyrobeno pro TUL 2015.</string>

</resources>

Způsob zadávání té určité resource s daným identifikátorem se liší, většinou jsou to ale tagy párové, např. <string></string> a hodnotou je tedy položka mezi těmito dvěma tagy.

Zjednodušeně jde tedy o to, aby byla proměnná na jednom místě. V případě, kdy by se jedna proměnná musela volat například 100x, tak tímto způsobem lze přepsat proměnná na jednom místě, místo 100x přepisovat text. Další výhodou je snadné vytvoření vícejazyčné aplikace.

15

Životní cyklus activity

Android jakožto operační systém určený primárně pro moderní chytré telefony, sám zodpovídá za activity a vše co s nimi souvisí. Například v případě používání nějaké aplikace majitel telefonu raději odpoví na příchozí hovor nebo odepíše na textovou zprávu. Může tedy nastat několik situací pozastavení aplikace, jako například právě příchozí hovor, přechod do hlavní nabídky atd.

Z toho vyplívá, že není vždy jasné, jak dlouho activity poběží, a proto existují různé metody, které se volají v různých situacích. Na schématu 2.5-2 je vidět, jak takový životní cyklus activity probíhá [11].

Obr. 2.5-2: Životní cyklus activity

Každá activity se nachází současně jen v jednom z následujících stavů:

1. Obnoveno – lze také chápat jako trvalé „Spuštěno“. V tomto stavu je activity v popředí a lze s ní pracovat.

2. Pauza – v tomto stavu je activity částečně zakryto jinou activity – tedy je polo-průhledná nebo nepokrývá celou obrazovku. Acitivty v tomto stavu také nepřijímá žádné vstupy od uživatele a nemůže spustit žádný kód.

3. Zastaveno – Activity existuje na pozadí (například pokud byla spuštěná jiná aplikace a původní nebyla ukončena). V tomto stavu activity zachovává všechny instance a proměnné v paměti, ale nevykonává žádný kód.

16

Jiné stavy (Vytvořeno a Spuštěno) jsou pouze přechodné. Systém rychle přejde z jejich stavu životního cyklu do jiného stavu životního cyklu voláním metod jako je jako např. onStart().

Tedy když systém zavolá onCreate(), ihned zavolá onStart(), které je rychle následováno metodou onResume().

Při programování není nutné brát zřetel na všechny zmíněné metody. Někdy je totiž není potřeba použít. Jedinou výjimkou je metoda onCreate().

V metodě onCreate() Android nadefinuje vše potřebné, aby se activity mohla spustit.

Například nastavení globálních proměnných, vytvoření grafického rozhraní atd. Příklad onCreate() metody:

public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

Toast.makeText(this, R.string.wellcome_toast, Toast.LENGTH_LONG).show();

}

V tomto příkladu metoda onCreate() nastaví svůj vzhled řádkem:

setContentView(R.layout.activity_main);

Odkazuje tedy na layout activity_main, který je ve složce „„res/layout““. Metoda setContentView() pak přebírá buď nějaké view nebo identifikátor některého layoutu. Ve většině případů je vhodné použít právě identifikátor.

onCreate() také v tomto případě vygeneruje informační dialog při spuštění aplikace:

Toast.makeText(this, R.string.wellcome_toast, Toast.LENGTH_LONG).show();

2.6 Časté problémy a jejich řešení

Bohužel vývoj pro Android OS provází problémy, jako je náročnost prostředí Java, chyby v Android Studiu nebo (ne)komunikace s virtuálním či fyzickým zařízením.

Paměťová náročnost je v textu již zmíněna, ale možným řešením problému je vytvoření virtuálního zařízení s méně operační paměti či použití fyzického zařízení.

17

Pokud nebyl nainstalován Google USB driver, tak zde může nastat problém s ovladači, který lze vyřešit jedině instalací ovladače přes SDK Manager, jak již bylo zmíněno v kapitole 1.2.

Při vytvoření nového projektu se může objevit zpráva s „Rendering Problems“ textem. Tj.

problém, kdy došlo k nesprávnému načtení témat. Nejlepším řešením je odinstalování a opětovné nainstalování Android Studia. Nebo v XML souboru, kde došlo k problémům, se klikne na „AppTheme“ a zvolí se jedno ze zobrazených témat (obr. 2.6.1). Například

„Base.Theme.App.Compat.Light“.

Obr. 2.6-1: Volba témat

Častým problémem je také komunikace vývojového prostředí s virtuálním zařízením. Zde pomůže trpělivost, vypnutí a zapnutí virtuálního zařízení. V extrémním případě je potřeba vytvořit zcela nové virtuální zařízení. V dřívějších verzí Android Studia byl problém s odpojováním ladící relace, kde se při volbě zobrazení hodnoty v proměnné zařízení odpojilo.

Tento problém byl nejspíše s novou verzí Android Studia odstraněn, ale opět pomůže pře restartování zařízení. Je také doporučeno ukončit zbytečné běžící aplikace na pozadí.

Dále se objevují problémy s vytvořením instalačního balíčku „.apk“. Řešením je smazání složek s názvem „build“ v projektu. Složky „build“ lze najít v systému Windows 8.1

„C:\Users\UzivatelskeJmeno\AndroidStudioProjects\MujProjekt\“. V této složce a ve všech

18

podsložkách se smaže obsah složky „build“ a restartuje se Android Studio. Pak by již měl jít v projektu vytvořit instalační balíček.

Obecně platí, že pokud se objeví nějaký problém, řešením je restartování vývojového prostředí, virtuálního zařízení a ukončení nepotřebných aplikací na pozadí. Doporučeno je rovněž udržovat celé Android Studio a jeho plug-iny, aktualizované.

19

3 PRŮZKUM ALTERNATIV

Před vytvářením aplikace pro zobrazování frekvenčních charakteristik je nutné si ověřit, zda stejné aplikace již existují a pokud ano, tak v jaké jsou kvalitě a zda má význam se zabývat vývojem aplikace. Tato rešerše se zaměří na dostupné produkty na trhu. Komerční aplikace jsou zmíněny pouze pro úplnost a srovnání.

AndroBode

Obr. 3-1: AndroBode

Na obrázku 3-1 lze vidět hlavní obrazovku aplikace Androbode. Aplikace AndroBode byla vytvořena autorem Paolo Lorrai, z italské University of Cagliari na pomoc studentům při kreslení frekvenčních charakteristik. Aplikace umí vykreslovat frekvenční charakteristiku jak amplitudově-fázovou charakteristiku v komplexní rovině, tak i pouze jako amplitudovou nebo jen fázovou charakteristiku. Bohužel zadávání hodnot je zbytečně komplikované a nelze jednoduše zadat požadovaný obrazový přenos. Odečítání hodnot z grafu není možné. Aplikace ale umí zobrazit i asymptoty jak pro amplitudovou, tak i pro fázovou charakteristiku.

Výhody:

1. Zobrazení všech požadovaných charakteristik 2. Zobrazení asymptot

3. Grafické zobrazení požadovaného obrazového přenosu 4. Zdarma

20 Nevýhody:

1. Komplikované zadávání hodnot 2. Složité ovládání

3. Nemožnost odečítání hodnot z grafu 4. Nemožnost uložení výstupu

ControlCalc

Obr. 3-2: ControlCalc

Aplikace na obrázku 3-2 je ControlCalc vytvořená autorem A.DeCarvalho. Autor má v obchodě Google Play více podobných užitečných aplikací, které mohou najít využití při studiu či navrhování regulátoru nebo jiného systému automatického řízení. Zmíněná aplikace je určena pro simulaci automatického řízení zpětnovazebních systémů, včetně uzavřené a otevřené smyčky.

Výhody:

1. Možnost odečítání hodnot z grafu 2. Výpočet pólů systému

3. Možnost uložení grafického výstupu na SD kartu 4. Zdarma

21 Nevýhody:

1. Nepřehledné ovládání 2. Primární zaměření aplikace

3. Nezobrazuje amplitudově-fázovou charakteristiku v komplexní rovině.

4. Nezobrazuje asymptoty

Matlab Mobile

Tuto aplikaci sice lze stáhnout z Google Play obchodu zdarma, ale lze používat pouze, pokud uživatel vlastní licenci pro Matlab, proto autor práce neměl možnost tuto mobilní aplikaci vyzkoušet. Testována byla pouze plná PC verze. Matlab pro Windows je velice schopný nástroj, ve kterém lze vytvořit téměř cokoliv. PC verze umí vykreslit jakoukoliv požadovanou charakteristiku, včetně možnosti odečítání hodnot. Tomu ovšem také odpovídá cena. Bohužel, PC verze neumí vykreslovat asymptoty.

Výhody (PC verze):

1. Téměř dokonalý nástroj na výpočty a zobrazování grafů 2. Obrovská variabilita použití

Nevýhody (PC verze):

1. Cena

2. Nutno doprogramovat vykreslování asymptot

22

Octave

Obr. 3-3: Octave

Mobilní verze Octave (obr. 2-3) je plně zdarma s možností přispění určité částky autorovi na podporu vývoje. Hlavním autorem je John W. Eaton. Instalační balíček je nutný rozšířit o požadované funkcionality, např. pro vykreslování grafů a vlastností řídicích systémů je potřeba doinstalovat zdarma dostupné balíčky z Google Play obchodu. Po spuštění aplikace se objeví okno terminálu, kde lze zadávat příkazy jako např. v Matlabu. Vykreslování charakteristik je tedy velice podobné jako na PC verzi. Ovšem na platformě Android se grafy zobrazují jako obrázek, tedy není možné odečítání hodnot. Asymptoty rovněž nejdou zobrazit. Celkově je to velice schopný nástroj limitovaný pouze mobilním prostředím.

Výhody:

1. Obrovská variabilita použití 2. Zdarma (s možností příspěvku)

3. Zobrazení všech požadovaných charakteristik

23 Nevýhody

1. Komplikované terminálové ovládání 2. Nelze odečítat hodnoty

3. Nelze zobrazit asymptoty

Z tohoto srovnání vyplívá, že mobilních aplikací s tak specifickým zaměřením jako vykreslování frekvenčních charakteristik na dostupném trhu není mnoho. Dostupné aplikace mají vesměs zbytečně komplikované ovládání nebo nějaké jiné zmíněné nedostatky. Proto vytvoření vlastní aplikace, která by vhodně kombinovala výše zmíněné výhody a pokusila se eliminovat nevýhody, je vhodné. Jak již bylo nastíněno v Úvodu, od aplikace nelze čekat, že plně nahradí takové nástroje jako je Matlab nebo Octave. Jsou to komerční, nebo open source nástroje, které mají velice širokou uživatelskou základnu, vývojářskou komunitu nebo společnost, kterou vývoj a prodej takových profesionálních nástrojů živí. Na druhou stranu tato aplikace bude napsána v programovacím jazyce Java, takže bude snadno rozšiřitelná. Jedinou limitací je právě samotný jazyk Java, který není tolik přizpůsoben k matematicko-technickým výpočtům.

24

4 FREKVENČNÍ CHARAKTERISTIKY

Frekvenční charakteristika je grafické vyjádření frekvenčního přenosu 𝐺(𝑗𝜔) v komplexní rovině (nebo v logaritmických souřadnicích), kde za úhlovou frekvenci 𝜔 jsou dosazeny hodnoty 0 až ∞ [2].

Frekvenční charakteristiky mohou popisovat například:

- Jaké frekvence propustí filtr

- Jaké frekvenční pásmo je schopen zpracovat audio zesilovač

- Kolik snímků za sekundu a v jakém rozlišení může zobrazit analogový monitor

4.1 Frekvenční přenos

Frekvenční přenos 𝐺(𝑗𝜔) je definován poměrem vektoru odezvy k vektoru harmonického budícího (vstupního) signálu v ustáleném stavu po odeznění přechodového děje [2].

Vstupní funkcí je 𝑢(𝑡) = 𝐴₁sin 𝜔𝑡.

Výstupní funkcí je 𝑦(𝑡) = 𝐴₂sin(𝜔𝑡 + 𝜑) se stejnou frekvencí, ale odlišnou amplitudou 𝐴₂ a s fázovým posunutím 𝜑.

Harmonickou funkci je možné pomocí Eulerova vztahu vyjádřit ve tvaru (2) a (3).

𝒖(𝑡) = 𝐴₁𝑒^𝑗𝜔𝑡 (2)

𝒚(𝑡) = 𝐴₂𝑒^{𝑗(𝜔𝑡+𝜑)} (3)

To jsou v komplexní rovině vektory, které se otáčejí úhlovou rychlostí 𝜔. Poměr těchto vektorů definuje frekvenční přenos (4) [2].

|𝐺(𝑗𝜔)| =𝒚(𝑡)

𝒖(𝑡)=𝐴₂𝑒^{𝑗(𝜔𝑡+𝜑)} 𝐴₁𝑒^𝑗𝜔𝑡 =𝐴₂

𝐴₁𝑒^𝑗𝜑 = 𝐴𝑒^𝑗𝜑 (4)

25 Kde A= 𝐴₂/𝐴₁ - je poměr amplitud – modul

𝜑 - je fázové posunutí – argument [°]

𝜔 - je kruhový kmitočet 𝜔 =^2𝜋_𝑇 [𝑟𝑎𝑑/𝑠]

Souvislost mezi diferenciální rovnicí a frekvenčním přenosem vychází z obecného tvaru diferenciální rovnice systému (5) [3].

𝑎_𝑛𝑦^(𝑛)(𝑡) + ⋯ + 𝑎₂𝑦^′′(𝑡) + 𝑎₁𝑦^′(𝑡) + 𝑎₀𝑦(𝑡) =

= 𝑏_𝑚𝑢^(𝑚)(𝑡) + ⋯ + 𝑏₂𝑢^′′(𝑡) + 𝑏₁𝑢^′(𝑡) + 𝑏₀𝑢(𝑡)

(5)

Pokud se za rovnici (5) dosadí vstupní a výstupní veličina harmonického kmitání v komplexním tvaru i s příslušnými derivacemi, dostane se vztah, umožňující převádět diferenciální rovnici systému na frekvenční přenos a naopak [3].

|𝐺(𝑗𝜔)| = 𝑏(𝑗𝜔)

𝑎(𝑗𝜔) =𝑏_𝑚(𝑗𝜔)^𝑚+ ⋯ + 𝑏₁(𝑗𝜔) + 𝑏₀ 𝑎_𝑛(𝑗𝜔)^𝑛+ ⋯ + 𝑎₁(𝑗𝜔) + 𝑎₀

(6)

Když se první 4 členy v čitateli a jmenovateli lomeného polynomu (6) postupně upraví, dostane se (7) [3].

|𝐺(𝑗𝜔)| = 𝑏₀+ 𝑗𝑏₁𝜔 − 𝑏₂𝜔²− 𝑗𝑏₃𝜔³+ 𝑏₄𝜔⁴+ ⋯ 𝑎₀+ 𝑗𝑎₁𝜔 − 𝑎₂𝜔²− 𝑗𝑎₃𝜔³+ 𝑎₄𝜔⁴+ ⋯=

= 𝑏₀− 𝑏₂𝜔²+ 𝑏₄𝜔⁴− ⋯ + 𝑗(𝑏₁𝜔 − 𝑏₃𝜔³+ ⋯ ) 𝑎₀− 𝑎₂𝜔²+ 𝑎₄𝜔⁴− ⋯ + 𝑗(𝑎₁𝜔 − 𝑎₃𝜔³ + ⋯ )

(7)

Pokud se pak označí polynomy přenosu písmeny c, d, e a f [3],

𝑐(𝜔) = 𝑏₀− 𝑏₂𝜔²+ 𝑏₄𝜔⁴− ⋯ , 𝑑(𝜔) = 𝑏₁𝜔 − 𝑏₃𝜔³+ ⋯ (8) 𝑒(𝜔) = 𝑎₀− 𝑎₂𝜔²+ 𝑎₄𝜔⁴− ⋯ , 𝑓(𝜔) = 𝑎₁𝜔 − 𝑎₃𝜔³+ ⋯

26 lze přenos (7) přepsat ve tvaru (9) [3].

|𝐺(𝑗𝜔)| =𝑐(𝜔) + 𝑗𝑑(𝜔) 𝑒(𝜔) + 𝑗𝑓(𝜔)

(9)

Tvar (9) se pak rozdělí na reálnou a imaginární část (vynásobením čitatele i jmenovatele výrazem komplexně sdruženým ke jmenovateli (10)).

|𝐺(𝑗𝜔)| =𝑐(𝜔) + 𝑗𝑑(𝜔)

𝑒(𝜔) + 𝑗𝑓(𝜔)×𝑒(𝜔) − 𝑗𝑓(𝜔) 𝑒(𝜔) − 𝑗𝑓(𝜔)=

=𝑐(𝜔)𝑒(𝜔) + 𝑑(𝜔)𝑓(𝜔) 𝑒²(𝜔) + 𝑓²(𝜔) + 𝑗𝑑(𝜔)𝑒(𝜔) − 𝑐(𝜔)𝑓(𝜔)

𝑒²(𝜔) + 𝑓²(𝜔) = 𝑃(𝜔) + 𝑗𝑄(𝜔)

(10)

Je tedy zřejmé, že 𝑃(𝜔) tvoří reálnou část frekvenčního přenosu a 𝑄(𝜔) jeho imaginární část.

Obě 𝑃(𝜔) i 𝑄(𝜔) jsou racionální funkce v 𝜔 [3].

Frekvenční přenos ve tvaru

|𝐺(𝑗𝜔)| = 𝑅𝑒[𝐺(𝑗𝜔)] + 𝑗𝐼𝑚[𝐺(𝑗𝜔)] = 𝑃(𝜔) + 𝑗𝑄(𝜔) (11) je tzv. kartézský tvar frekvenčního přenosu.

Pro konstantní hodnotu 𝜔 budou 𝑃(𝜔) i 𝑄(𝜔) čísla. Obrazem komplexního čísla v komplexní rovině je bod. Pro absolutní hodnotu (modul) komplexního čísla, která je na obrázku (obr. 4.1-1) označena jako 𝐴(𝜔), podle Pythagorovy věty, platí

𝐴(𝜔) = √𝑃²(𝜔) + 𝑄²(𝜔) (12)

27

Obr. 4.1-1: Bod frekvenčního přenosu

a pro úhel 𝜑 pak platí (13).

𝑡𝑔𝜑(𝜔) =𝑄(𝜔)

𝑃(𝜔) => 𝜑(𝜔) = 𝑎𝑟𝑐𝑡𝑔𝑄(𝜔) 𝑃(𝜔)

(13)

Frekvenční přenos je tedy možné popsat pomocí 𝐴 a 𝜑 jako

𝐺(𝑗𝜔) = 𝑃(𝜔) + 𝑗𝑄(𝜔) = 𝐴(𝜔)𝑐𝑜𝑠𝜑(𝜔) + 𝑗𝐴(𝜔)𝑠𝑖𝑛𝜑(𝜔)

= 𝐴(𝜔)[𝑐𝑜𝑠𝜑(𝜔) + 𝑗𝑠𝑖𝑛𝜑(𝜔)

(14)

a tedy opět

𝐺(𝑗𝜔) = 𝐴(𝜔)𝑒^{𝑗𝜑(𝜔)} (15)

Reprezentace (14) je tedy tzv. polární tvar frekvenčního přenosu. Veličina 𝐴(𝜔) je amplituda a úhel 𝜑(𝜔) je fází.

S měnícím se 𝜔 se mění 𝑃(𝜔) i 𝑄(𝜔) resp. 𝐴(𝜔) a 𝜑(𝜔) a koncový bod (obr. 4.1-2) bude opisovat křivku v komplexní rovině. Tato křivka se nazývá frekvenční charakteristika systému [3].

28

4.2 Frekvenční charakteristika

Frekvenční charakteristika jako grafické znázornění frekvenčního přenosu, tj. závislost obvodové funkce na frekvenci, lze zobrazit dvěma způsoby:

1. V komplexní rovině, kde na ose x je vynesena reálná část frekvenčního přenosu a na ose y je imaginární část frekvenčního přenosu, což je vlastně hodograf komplexní funkce |𝐺(𝑗𝜔)|. Z této amplitudově-fázové charakteristiky lze například posoudit stabilitu systému Nyquistovým kritériem stability. Na obr. 4.2-1 je zobrazena Nyquistova křivka – frekvenční charakteristika pro kladné, ale i záporné frekvence.

Obr. 4.2-1: Amplitudově-fázová charakteristika

2. V logaritmických souřadnicích, kde na ose x je vynesena kruhová frekvence 𝜔 a na ose y je vynesena:

a. Amplituda frekvenčního přenosu |𝐺(𝑗𝜔)| v decibelech tj. amplitudová charakteristika (obr. 4.2-2).

b. Fáze frekvenčního přenosu 𝜑 v radiánech či ve stupních tj. fázová charakteristika (obr. 4.2-2).

29

Obr. 4.2-2: Amplitudová a fázová charakteristika

Logaritmická charakteristika se liší od charakteristiky v komplexní rovině tím, že nelze současně zobrazit jak reálnou tak i imaginární část a tedy není možné současně zobrazit amplitudu (modul) a fázi frekvenčního přenosu.

V amplitudové charakteristice se na osu y vynáší hodnota modulu |𝐺(𝑗𝜔)| v dB a to v lineární stupnici. V logaritmické stupnici je vynesena jen veličina – decibely.

Pro převod hodnoty modulu |𝐺(𝑗𝜔)| na hodnotu modulu v decibelech platí

|𝐺(𝑗𝜔)|_𝑑𝐵 = 20 log|𝐺(𝑗𝜔)| = 20 log𝐴₂ 𝐴₁

(16)

30

Fázovou charakteristiku lze vypočítat pomocí rovnice (13). Pro většinu technických systémů (tzv. minimálně fázových, to jest s kladnou reálnou částí setrvačných a zrychlujících členů) však lze charakteristiku určit přímo z logaritmické amplitudové charakteristiky [4].

4.3 Asymptoty amplitudové a fázové charakteristiky

Asymptoty slouží zejména pro analytické a demonstrativní účely. Podle nich se snadno nechají odečíst nuly a póly přenosu, tedy zlomové frekvence a podle asymptot je možno odvodit předpokládané chování systému.

Zlomové frekvence se snadno zjistí vypočítáním kořenů polynomu, kde v čitateli jsou tzv. nuly a ve jmenovateli jsou póly. Samotné kreslení asymptot se pak řídí pravidly vypsanými v tabulce (Tabulka 4.3-1) [5].

Tabulka 4.3-1

Název Modul (sklon asymptoty) Fáze (spojení v bodech)

Zesílení: K 20𝑙𝑜𝑔₁₀(|𝐾|) 𝐾 > 0: 0°

𝐾 < 0: ±180°

Pól v počátku -20 dB/dekádu −90°

1 𝑠

Nula v počátku + 20 dB/dekádu +90°

𝑠

Reálný pól -20dB/dekádu od 𝜔₀ Od 0° do 0.1 𝜔₀ Od 10𝜔₀ do -90°

𝑠 1 𝜔₀+ 1

Reálná nula +20dB/dekádu od 𝜔₀ Od 0° do 0.1 𝜔₀ Od 10𝜔₀ do +90°

𝑠 𝜔₀+ 1

31

Komplexní pól -40dB/dekádu od 𝜔₀ Od 0° do ₁₀^𝜔0_ζ

Od 𝜔₀10^ζ do -180°

1 ( 𝑠

𝜔₀)²+ 2ζ( 𝑠 𝜔₀) + 1 Kde 0 < ζ < 1

Komplexní nula +40dB/dekádu od 𝜔₀ Od 0° do ₁₀^𝜔0_ζ

Od 𝜔₀10^ζ do +180°

( 𝑠

𝜔₀)²+ 2ζ( 𝑠

𝜔₀) + 1 Kde 0 < ζ < 1

Dvojité póly a nuly ±40dB/dekádu od 𝜔₀ Od 0° do 0.1 𝜔₀ Od 10𝜔₀ do ±180°

1 ( 𝑠

𝜔₀+ 1)²

Příklad sestrojení asymptot v několika krocích:

Nechť existuje obrazový přenos 𝐺(𝑠) =_5𝑠+1² .

1. Jako první krok je potřeba zjistit zesílení systému a jeho póly a nuly:

Zesílení je zjevně K = 2.

Ve jmenovateli je pouze jeden pól, který se zjistí jednoduchým výpočtem (17).

5𝑠 + 1 = 0

𝑠 = −1 5

(17)

2. Zesílení se převede pomocí 20 log₁₀(𝐾) na decibely.

𝐾_𝑑𝐵 = 20 log₁₀(𝐾) (18)

Což je přibližně 6 dB. Tento údaj říká, kde na logaritmické ose bude počátek křivky 3. Nakreslí se asymptoty podle pravidel uvedených v tabulce (Tabulka 4-1):

a. Zesílení má velikost přibližně 6 dB

32

b. Pól je v 0,2 rad/s. Je to sklon 0 dB/dek až do zlomové frekvence, kde pak klesá -20 dB/dek. Fáze je 0° až do 1/10 zlomové frekvence (0,02 rad/sec) a pak lineárně klesá až do desetinásobku zlomové frekvence (2 rad/sec).

c. Výsledek je vidět na obrázcích 4.3-1 a 4.3-2.

Obr. 4.3-1: Amplituda - Asymptota

Obr. 4.3-2: Fáze – Asymptota

33

5 REALIZACE APLIKACE

Naprogramovat aplikaci pro operační systém Android nemusí být pro začátečníka vůbec jednoduché. Pro pochopení prostředí Android, které využívá programovací jazyk Java, by měl mít programátor osvojené znalosti alespoň nějakého objektově orientovaného jazyka..

V případě tvorby aplikace, která se zabývá výpočtem a vykreslováním frekvenčních charakteristik, jsou dále nutné znalosti o dané problematice, matematice a geometrii.

5.1 Návrh uživatelského rozhraní a zadávání dat

První úkol, který bylo potřeba vyřešit, je vzhled aplikace. Android umožňuje prakticky neomezenou tvorbu uživatelského rozhraní, ale s ohledem na obrovské množství zařízení na trhu bylo potřeba zvolit rychlé a přehledné rozhraní.

Pro zachování přehlednosti postačilo mít na hlavní obrazovce editovatelné textové pole pro zadání čitatele a jmenovatele přenosu. Dále bylo nutné umístit rozbalovací menu, kterým uživatel může zvolit jednotky pro vykreslování. V tomto případě jsou v rozbalovacím menu jednotek volby „rad/s“ a „Hz“. Jako poslední ovládací prvek bylo umístěno tlačítko pro potvrzení zadaných údajů (obr. 5.1-1).

Obr. 5.1-1: Hlavní obrazovka

34

Ovládání systému Android umožňuje zobrazení tzv. Menu, kam má vývojář možnost umístit případné další ovládací prvky nebo tlačítka. Zde se vložily položky „O TULBode“,

„Nápověda“, „Export“ a „Zobrazení dat“ (obr. 5.1-2).

Obr. 5.1-2: Menu

Prvky „Nápověda“ a „O TULBode“ jsou uloženy ve složce „res/layout“ jako soubory s koncovkou „.XML“. Pro „Export“ a „Zobrazení dat“ žádný XML layout nebyl vytvořen, protože se vytváří dynamicky.

Tedy:

activity_about.xml activity_help.xml activity_main.xml Pro demonstrativní účely je vložena ukázka aktivit_main.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical">

<TextView

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:textAppearance="?android:attr/textAppearanceLarge"

android:text="TULBode"

android:id="@+id/textView6"

android:autoText="false"

android:textAlignment="center" />

<TextView

android:text="@string/edittext_label"

35

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

<EditText

android:inputType="text"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:id="@+id/editNumerator" />

<TextView

android:text="@string/edittext2_label"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

<EditText

android:id="@+id/editDenumerator"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:inputType="text" />

<TextView

android:text="@string/edittext5_label"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:id="@+id/textView3" />

<Spinner

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:entries="@array/radHz"

android:prompt="@string/decade_count"

android:id="@+id/spinnerRadHz" />

<Button

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:onClick="buttonClickedAll"

android:text="@string/button_main"

android:id="@+id/buttonVse"

/>

</LinearLayout>

Layout „activity_main.xml“ se volá ve třídě MainActivity.java, kde dochází také k základním úkonům jako je např. ošetření vstupů atd.

Layout pro vykreslování grafů se vytváří dynamicky ve třídě GraphScreens.java. Každý layout má pak nastaven specifické parametry:

LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, 1);

Kde MATCH_PARENT znamená, že view bude stejně velké jako jeho rodič. V tomto případě je bigLay rodič. Poslední parametr „1“ znamená, že view bude mít pro zobrazení váhu jedna.

36

Tedy pokud 2 view se stejným rodičem používají váhový parametr „1“, tak se oba roztáhnou na polovinu jeho výšky. Layout bude vypadat potom jako na obr. 5.1-3.

Obr. 5.1-3: Obrazovka s grafy

Kód pro vytvoření požadovaného view pak vypadá takto:

LinearLayout bigLay = new LinearLayout(this);

LinearLayout fazeGraf = new LinearLayout(this);

LinearLayout logGraf = new LinearLayout(this);

LinearLayout buttons = new LinearLayout(this);

LinearLayout.LayoutParams lpGraphs = new

LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, 1);

LinearLayout.LayoutParams lpBut = new

LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);

LinearLayout.LayoutParams lp = new

LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);

logGraf.setLayoutParams(lpGraphs);

fazeGraf.setLayoutParams(lpGraphs);

37

buttons.setLayoutParams(lpBut);

buttons.setOrientation(LinearLayout.HORIZONTAL);

fazeGraf.setOrientation(LinearLayout.VERTICAL);

logGraf.setOrientation(LinearLayout.VERTICAL);

bigLay.setOrientation(LinearLayout.VERTICAL);

Button startNyq = new Button(this);

Button startAgain = new Button(this);

startNyq.setText("Nyq");

startNyq.setOnClickListener(NyqStart);

startAgain.setText("Zpět");

startAgain.setOnClickListener(goBack);

buttons.addView(startAgain, lpBut);

buttons.addView(startNyq, lpBut);

Layout tedy byl vytvořen. Dále bylo nutné přidat obsah, který se má zobrazit.

fazeGraf.setOnClickListener(fazeStart);

logGraf.setOnClickListener(LogStart);

bigLay.addView(buttons, lpBut);

bigLay.addView(logGraf, lpGraphs);

bigLay.addView(fazeGraf, lpGraphs);

setContentView(bigLay);

Metoda LinearLayout.addView() přidá view do layoutu s parametry, které již byly definovány. Metoda setContentView() zabezpečí už samotné zobrazení celé obrazovky.

Dále bylo potřeba zajistit ovládací prvky, které umožní uživateli přesun do jiné nabídky. Na to se použila metoda setOnClickListener().

startNyq.setOnClickListener(NyqStart);

startAgain.setOnClickListener(goBack);

fazeGraf.setOnClickListener(fazeStart);

logGraf.setOnClickListener(LogStart);

Zbývající obrazovky pro samotné zobrazení charakteristik vypadají téměř stejně, liší se jen v použití pouze jednoho zobrazení grafů a jiných tlačítek. Na této ukázce se demonstrovalo použití podle klasického rozvržení layoutu dle parametrů definovaných XML, tak i pomocí dynamického rozvržení přímo v kódu. Pro větší projekty je vhodnější použití XML parametrů, které pomůžou zlepšit orientaci v kódu.

5.2 Používané třídy a popis hlavních tříd

Pro zabezpečení funkčnosti aplikace se muselo navrhnout, jaké třídy a metody bude aplikace používat. Jako nejvhodnější se ukázalo použití více různých tříd, které budou zprostředkovávat

38

výpočty, zobrazování nebo ukládání výsledků do paměti. Více tříd také zabezpečí přehlednost celého projektu a možnost snadného rozšíření aplikace. V této kapitole jsou blíže popsány hlavní třídy důležité pro funkčnost aplikace. Třídám zajišťujícím vykreslování grafů a třídám pro různé pomocné výpočty nebo operace jsou věnovány samostatné kapitoly.

Z důvodu konvence byly třídy pojmenovány v anglickém jazyce a začínají velkým písmenem.

1. About – třída zobrazující obrazovku s informacemi o aplikaci

2. ComplexNumbers – třída pro uchovávání a práci s komplexními čísly 3. GraphScreens – třída vykreslující grafy a výpočty

4. Help – třída pro zobrazení nápovědy 5. MainActivity – hlavní třída pro vstup dat

6. PlotLog – třída pro výpočet a vykreslování amplitudové charakteristiky

7. PlotNyq – třída pro výpočet a vykreslování amplitudově-fázové charakteristiky 8. PlotPhase – třída pro výpočet a vykreslování fázové charakteristiky

9. ScreenUtils – třída pro práci s daty 10. Solver – třída pro výpočty

11. ZerosPoles – třída pro uchovávání a práci pólů a nul

a. Omega – podtřída pro práci se zlomovými frekvencemi b. OmegaPair – podtřída pro práci se zlomovými frekvencemi Komentáře v kódu byly psány ve většině případů také v anglickém jazyce.

MainActivity.java

Tato třída je volána ihned po spuštění aplikace. MainActivity.java dědí metody a proměnné z nativní třídy Activity. Třída ošetří nesprávně vložená data a vytvoří intent, který data pošle jako parametry do jiné activity. Také bylo potřeba zajistit funkčnost rozbalovacího menu. To se provedlo metodou onCreateOptionsMenu().

public class MainActivity extends Activity { /**

* Called when the activity is first created.

*/

private Spinner spinnerHz;

int selectionCurrent;

public TextView textLabelUnits;

@Override

public void onCreate(Bundle savedInstanceState) {

39

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

Toast.makeText(this, R.string.wellcome_toast, Toast.LENGTH_LONG).show();

} @Override

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the action bar if it is present.

getMenuInflater().inflate(R.menu.menu_main, menu);

return true;

} }

V metodě onCreate() se inicializuje vzhled této aplikace, a informační dialog, který se objeví při spuštění aplikace.

Rovněž byla potřeba vytvořit funkci, která při kliknutí na tlačítko „Menu“ (ovládací prvek Androidu) vytvoří jednotlivé položky a umožní jejich zobrazení. Zároveň se při této akci vytváří již zmíněný intent, který je předán do metody startActivity(), která už jen zavolá položce příslušnou activity:

public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) {

case R.id.about:

Intent intent = new Intent(this, About.class);

startActivity(intent);

return true;

case R.id.help:

Intent intent1 = new Intent(this, Help.class);

startActivity(intent1);

return true;

case R.id.export:

Toast.makeText(this, R.string.export, Toast.LENGTH_LONG).show();

return true;

case R.id.dataShow:

Toast.makeText(this, R.string.datashow, Toast.LENGTH_LONG).show();

return true;

default:

return super.onOptionsItemSelected(item);

} }

Pro ošetření vstupů z EditText view se použil regulární výraz. Vše se zabalilo do metody, která při nesprávném zadání vrátí null, jinak vrátí předaný řetězec. Pro ukázku je zobrazena metoda getNumerator():

40

protected String getNumerator() {

EditText numeratorInput = ((EditText) findViewById(R.id.editNumerator));

String numeratorStr = numeratorInput.getText().toString();

Boolean validateResult = numeratorStr.matches(regExpres);

if (!validateResult) { numeratorStr = null;

}

return numeratorStr;

}

Jako nejvhodnější způsob zadávání vstupů se jevilo oddělení jednotlivých koeficientů středníkem. Regulární výraz pro ošetření vstupů se definoval takto [6]:

String regExpres =

"((\\x2d)?[0-9]*\\.?[0-9]+;)*((\\x2d)?[0-9]*\\.?[0-9])+";

Pokud je vstup zadán nesprávně, nastaví metoda informAboutInvalidInput() defaultní hodnoty:

protected void informAboutInvalidInput(int message) { switch (message) {

case 1:

//wrong input

Toast.makeText(this, R.string.invalid_input_1, Toast.LENGTH_SHORT).show();

break;

case 2:

//nums > dens

Toast.makeText(this, R.string.invalid_input_2, Toast.LENGTH_SHORT).show();

break;

default:

break;

}

EditText numeratorInput = ((EditText) findViewById(R.id.editNumerator));

numeratorInput.setText("2");

EditText denumeratorInput = ((EditText) findViewById(R.id.editDenumerator));

denumeratorInput.setText("2;1");

numeratorInput.requestFocus();

}

Všechny tyto metody používá metoda buttonClickedAll(), která je nastavena jako akce po kliknutí na tlačítko „ZOBRAZ“. Nastavení buttonClickedAll(), aby fungovala jako onClickListener bylo provedeno přímo v activity_main.xml:

android:onClick="buttonClickedAll"

Samotná metoda buttonClickedAll() pak vypadá takto:

41

public void buttonClickedAll(View buttonAll) { String numerator = getNumerator();

String denumerator = getDenumerator();

int spinnerRadHzID = getSpinnerRadHz();

if (numerator == null || denumerator == null) { informAboutInvalidInput(1);

} else {

String[] citatel = numerator.split(";");

String[] jmenovatel = denumerator.split(";");

double[] nums = ScreenUtils.parseNums(citatel);

double[] dens = ScreenUtils.parseDens(jmenovatel);

if (nums.length > dens.length) { informAboutInvalidInput(2);

} else {

startGraphScreens(numerator, denumerator, spinnerRadHzID);

} } }

Metoda zpracuje data, ověří vstupy a předá je jiné metodě startGraphScreens(). Ta už vytváří samotný intent, který je postoupen GraphScreens.java:

protected void startGraphScreens(String numerator, String denumerator, int spinnerRadHz) {

Intent intent = new Intent(this, GraphScreens.class);

intent.putExtra(GraphScreens.NUMERATOR, numerator);

intent.putExtra(GraphScreens.DENUMERATOR, denumerator);

intent.putExtra(GraphScreens.SPINNERRAD, spinnerRadHz);

startActivity(intent);

}

Další vytvořené metody:

protected int getSpinnerRadHz()

- Vrátí vybrané jednotky jako číslo

protected String getDenumerator()

- Vrátí jmenovatel jako řetězec

GraphScreens.java

Tato třída zajišťuje vzhled aplikace, ovládání a pohyb v aplikaci. Přijímá data z intentu vytvořeném v MainActivity.java:

Intent i = getIntent();

cit = i.getStringExtra(NUMERATOR);

jmen = i.getStringExtra(DENUMERATOR);

spinnerUnits = i.getIntExtra(SPINNERRAD, 0);

Po přijmutí dat zpracuje čitatele a jmenovatele:

42

double[] nums = ScreenUtils.parseNums(numerator);

double[] dens = ScreenUtils.parseDens(denumerator);

Následně zavolá metody pro výpočet kořenů a uloží je do pole, které poté uspořádáno podle velikosti:

zerosPolesList.addAll(Solver.solveZeros(nums, spinnerUnits));

zerosPolesList.addAll(Solver.solvePoles(dens, spinnerUnits));

Collections.sort(zerosPolesList, ZerosPoles.ABS_VALUE_COMPARATOR);

Z vypočtených kořenů již lze snadno zjistit počáteční frekvenci, od které se budou generovat další hodnoty frekvencí, a také počet dekád, který se zobrazí při prvním spuštění. Dekády se vypočítají pomocí odečtení exponentů:

startFreq = Math.pow(10, ScreenUtils.getClosestMinimum(zerosPolesList)-1);

power = ScreenUtils.getClosestMinimum(zerosPolesList)-1;

powerStart = ScreenUtils.getClosestMinimum(zerosPolesList)-1;

powerEnd = ScreenUtils.getClosestMaximum(zerosPolesList)+1;

decades = (powerEnd - powerStart);

Metody getClosestMinimum() a getClosestMaximum(), zjistí z prvních, respektive posledních, nenulových kořenů odpovídající počáteční a koncovou frekvenci.

Po získání všech nutných údajů pro další výpočty, bylo nutné uložit počáteční zesílení a fázi:

Display display = getWindowManager().getDefaultDisplay();

computeResult(decades, spinnerUnits, display);

double theMag = theResult[0].mod();

thePhase = theResult[0].arg()* 180. / Math.PI;

phaseSwitcher = Solver.solvePhaseDegrees(theResult, display.getHeight());

firstModul = 20 * Math.log10(theMag);

Následně se zavolá metoda displayAll(), předá se jí počet dekád a vybrané jednotky, ve kterých bude prováděn výpočet.

V metodě displayAll() bylo implementováno dynamické vytváření layoutu pro zobrazení dvou grafů, popsaných v kapitole 5.1. Dochází zde k použití metody computeResult(), která volá DbCounter() pro vygenerování frekvencí. Počet frekvencí je dán velikostí displeje.