Individální projekty MPOA

Tato stránka je pouze pro čtení. Můžete si pouze prohlédnout zdrojový kód, ale ne ho měnit. Zeptejte se správce, pokud si myslíte, že něco není v pořádku.
====== Řízení digitizeru ======
Vypracoval Jonáš Čech

===== Zadání =====
Vytvořte aplikaci na 32F746GDISCOVERY s dotykovým displejem, na kterém bude mít uživatel možnost zvolit nastavení AD převodníku (počet kanálů, rychlost vzorkování, …), dvou programovatelných zesilovačů (zisk, offset, …) a způsob spuštění vzorkování (externí signál nebo úrovní měřeného signálu). Získaná data z ADC během měření ukládejte do externí SDRAM paměti a po skončení měření je uložte na SD kartu.

===== Úvod =====
Na obrázku níže je blokové schéma měřícího systému pro měření s můstkovými tlakovými senzory. Tento projekt je vypracováván v rámci diplomové práce. Možnost změny parametrů měření a použitých obvodů slouží k vyhodnocení vlivu dvou zesilovačů s programovatelným ziskem na měřený signál a následný výběr jediného obvodu zesilovače.
{{ :2017:digitizer:blok_sch.png?600  |Obr 1.1: Blokové schéma }}

===== Hardware =====
Hardwarovou část projektu tvoří dvě vzájemně propojené DPS. První DPS tvoří analogově-digitální část, sloužící pro zpracování signálu z tenzometrického snímače tlaku. Druhá DPS tvoří čistě digitální část, zajišťující komunikaci s obsluhou, konfiguraci obvodů analogově-digitální části a záznam a uložení naměřených dat.


=== Analogově-digitální část ===
Tato část byla navržena v rámci semestrálního projektu. Její shcématické zapojení je na obrázku níže. Hlavními obvody (pro tento projekt) jsou dva přístrojové zesilovače s programovatelným ziskem, [[http://www.analog.com/en/products/amplifiers/instrumentation-amplifiers/ad8557.html|AD8557]] od Analog Devices a [[http://www.ti.com/product/PGA308|PGA308]] od Texas Instruments a také AD převodník [[http://www.analog.com/en/products/analog-to-digital-converters/ad7175-2.html|AD7175-2]] od Analog Devices. Zbylé obvody jsou na digitální části nezávislé, jako přístrojový zesilovač s OZ a napěťové stabilizátory.

{{ :2017:digitizer:fips_sch.png?600  |Obr 1.2: Celkové schéma analogově-digitální části }}

Zapojení je realizováno na 4vrstvé DPS, pro zajištění co nejlepšího rozvodu zemí (digitální a analogová), referenčního a napájecího napětí, čímž bylo také dosaženo získání většího prostoru k rozmístění obvodů tak, aby byly minimalizováno jejich vzájemné ovlivňování.

Výsledná sestava je napájena ze zdroje napětí v rozashu 7-12 V. Toto napětí je stabilizováno na 5 V, kterým je napájena analogová část zapojení a některé obvody digitální části, na jejíž desce je toto napětí stabilizováno na 3,3 V pro většinu obvodů a také pro napájení digitální části AD převodníku.

{{ :2017:digitizer:fips_top.jpg?200 |Obr 1.3: DPS analogově-digitální části}}
{{ :2017:digitizer:fips_bot.jpg?200 |Obr 1.4: DPS analogově-digitální části}}

=== Digitální část ===
Digitální část zapojení je realizována v rámci komerční vývojové desky [[http://www.st.com/en/evaluation-tools/32f746gdiscovery.html|STM32F746G-DISCO]] od STMicroelectronics. Tato deska poskytuje veškeré potřebné periferie pro záznam dat a komunikaci s uživatelem, jako je displej s dotykovou vrstvou, paměť typu SDRAM, připojený slot pro SD kartu a ethernetové rozhraní pro další rozšíření. SDRAM paměť má celkovou kapacitu 128 Mbit, ovšem z důvodu zapojení jen části datových a adresních pinů je k dispozici pouze polovina její velikosti, což ovšem dostačuje pro měření o maximální délce 8 vteřin.

{{  https://os.mbed.com/media/uploads/adustm/disco_f746ng_mbed_pinout_v5.png?600  }}

Spojení s digitální částí je zajištěno pomocí pinových lišt (Arduino kompatibilní).

^ Obvod - Pin    ^ Pin DISCO board                           ^
| AD8557 - 1W     | D2     |
| PGA308 - 1W     | D1     |
| AD7175-2 - CS   | D14    |
| AD7175-2 - SCK  | D13    |
| AD7175-2 - MISO | D12    |
| AD7175-2 - MOSI | D11    |

===== Firmware =====
Řídící firmware je psán ve vývojovém prostředí [[https://www.mbed.com/en/|Mbed]], jelikož je kompatibilní s použitou vývojovou deskou a poskytuje některé knihovny k jejím periferiím (LCD s dotykovou vrstvou apod.), což zjednodušuje tvorbu firmwaru pro tento prototyp. Tyto knihovny slouží většinou ve své podstatě jako "převdení" BSP knihoven (poskytovaných výrobcem pro své konkrétní vývojové desky) na C++ knihovny, jelikož Mbed pracuje s tímto programovacím jazykem. I přes tuto skutečnost byla snaha psát kód v jazyku C, z důvodu možného pozdějšího převzetí částí kódu do finální verze firmwaru (psané v C).

Exportovaný projekt z prostředí Mbed (pro SW4STM32) je k dispozici zde: {{ wiki:mpoa_fips_sw4stm32_disco_f746ng.zip}}

<code cpp>
void LCD_DISCO_F746NG::DrawPixel(uint16_t Xpos, uint16_t Ypos, uint32_t pixel)
{
  BSP_LCD_DrawPixel(Xpos, Ypos, pixel);
}
</code>
=== GUI ===
Komunikace s uživatelem je realizována pomocí GUI na LCD displeji s dotykovou vrstvou a v některých demonstračních případech výpisem do PC konzole. Prvky GUI jsou vykreslovány pomocí jednoduchých funkcí Mbed knihovny pro použitý LCD. Hlavním důvodem byla úspora paměti (oproti různým knihovnám sloužícícm pro tvorbu mnohem složitějších rozhraní, např. STemWin) a také fakt, že toto uživatelské rozhraní je vytvořeno pouze pro potřeby tohoto prototypu).

<code cpp>
// Vykresleni barevneho obdelniku pouzivaneho jako tlacitko
void Tlacitko(int x_poz, int y_poz, int sirka, int vyska, unsigned int barva, unsigned int barva_hrany)
{ 
   lcd.SetTextColor(barva);
   lcd.FillRect(x_poz, y_poz, sirka, vyska);
   lcd.SetTextColor(barva_hrany); 
   lcd.DrawRect(x_poz, y_poz, sirka, vyska);  
}
</code>

Vytvořené GUI (viz obrázek níže) je tvořeno jednoduchým menu po levém straně, ve kterém si uživatel stiskem zvolí, který obvod chce nakonfigurovat. V okně na pravé straně se mu zobrazí možné parametry, které lze měnit. Kliknutím na konkrétní parametr a poté na ovládací tlačítka níže ( <-, ->, Prog), může hodnotu měnit anebo obvod vybranými parametry nakonfigurovat.

{{ :2017:digitizer:gui.jpg?500  |Obr 2.1: GUI (ve skutečnosti to vypadá lépe než na fotce :) ) }}

Přehled konfigurovatelných parametrů z jednotlivých části menu je zobrazen v tabulce níže. Vysvětlení parametrů prvních dvou obvodů je vždy v patřičném datasheetu na stránkách výrobce. Obecně řečeno se ale nastavuje zesílení a offset. U AD převodníku se nastavují parametry použitých kanálů jako je jejich povolení, využití vstupního analogového bufferu, výstupní datová rychlost a mód měření AD převodníku (kontinuální, jednorázové měření). Jako parametry měření lze zvolit způsob spuštění samotného měření (externím spouštěcím signálem, úrovní měřeného signálu), dobu měření a úroveň spouštěcího signálu.
^ PGA308    ^ AD8557                           ^ AD7175-2               ^ Cas     |
| Front-End gain     | First Stage Gain     | Aktivní kanál (CH0, CH2, CH3)     | Způsob zpouštění     |
| GDAC Gain     | Second Stage Gain     | Vstupní buffer (CH0, CH2, CH3)     | Mód měření     |
| OutAmp Gain   | Offset    | Výstupní datová rychlost (CH0, CH2, CH3)     | Úroveň spouštění     |
| Coarse Offset  | -    | -     | Doba měření     |
| Fine Offset | -    | -     | -     |

Pro každé okno menu je deklarována struktura, která v sobě uchovává pole s možnými nastavitelnými hodnotami parametrů, jejich odpovídající kód pro konfiguraci patřičného obvodu a číslo údávající pořadí zvolené hodnoty v poli konkrétního parametru. Tyto struktury jsou vytvořeny a naplněny konkrétnimi daty na začátku funkce main.
<code c>
// Struktura pro konfigurovatelné parametry obvodu AD8557
typedef struct {float fStageGain[25]; int sStageGain[8]; int offset[27];
                int fStageGainCode[25]; int sStageGainCode[8]; int offsetCode[27];
                int fStageGain_X; int sStageGain_X; int offset_X;}INA_AD;
</code>

Snímání doteků uživatele na dotykové vsrtvě displeje je řešeno pomocí následující funkce, která při každém jejím zavolání  (umístěna v nekonečné smyčce) zkontroluje dotykovou vrstvu a při případném doteku (prvním doteku - vrstva umožňuje snímat až 5 doteků naráz) uloží jeho souřadnice.
<code cpp>
// Testování doteku a uložení jeho pozice pro další vyhodnocení
void testujDotek(dotekXY* dotek)
{ 
   ts.GetState(&TS_State);
   if (TS_State.touchDetected) 
   {
         dotek->X = TS_State.touchX[0];
         dotek->Y = TS_State.touchY[0];
   }
   dotek->pocetDoteku = TS_State.touchDetected;
}
</code>
Po této funkci jsou volány funkce zajišťující vyhodnocení pozice doteku, a to jak na úrovni menu, tak na úrovni jednotlivých jeho oken. Konkrétně se jedná o funkce klikmenu(), klikParametry() a klikZmenParametru(), které dle pozice doteku upraví hodnotu ve výčtových proměnných. \\ Tyto proměnné udávají informaci o:\\
  * zobrazení zvoleného okna menu (okno s parametry)
  * zvoleném parametru pro jeho změnu
  * stisknu jednoho ze tří ovládacích tlačítek

Níže je uvedena funkce klikMenu(), která vyhodnotí, zdali byl dotek proveden na některém z tlačítek menu a pokud ano, zapíše tuto informaci do již zmíněných výčtových proměnných. Ostatní funkce jsou napsány podobným způsobem.
<code c>
void klikMenu(dotekXY* dotek)
{
    //Detekovan dotek
    if (dotek->pocetDoteku > 0) { //kontrola doteku v nekonecne smycce //(*dotek).pocetDOteku > ......
        //Stisk PGA308
        if (dotek->X > 10 && dotek->X < 110 && dotek->Y > 30 && dotek->Y < 80) {
            tlacitko = PGA308; // Ulozeni informace o aktualnim stisku tlacitka menu
            zobrazNastaveni = PGA308n; // Informace o pozadavku vykresleni parametru obvodu PGA308
            paramIO = Nic_P; // Vynulovani informace o zvolenem parametru
            nastPar = Nic_NP;
        }
        //Stisk AD8557
        else if (dotek->X > 10 && dotek->X < 100 && dotek->Y > 90 && dotek->Y < 140) {
            tlacitko = AD8557;
            zobrazNastaveni = AD8557n;
            paramIO = Nic_P;
            nastPar = Nic_NP;
        }
        //Stisk AD7175
        else if (dotek->X > 10 && dotek->X < 100 && dotek->Y > 150 && dotek->Y < 200) {
            tlacitko = AD7175;
            zobrazNastaveni = AD7175n;
            paramIO = Nic_P;
            nastPar = Nic_NP;
        }
        //Stisk Cas
        else if (dotek->X > 10 && dotek->X < 100 && dotek->Y > 210 && dotek->Y < 260) {
            tlacitko = Cas;
            zobrazNastaveni = Casn;
            paramIO = Nic_P;
            nastPar = Nic_NP;
        }
    }
}
</code>
Po vytvoření požadavku na změnu parametru je v pořadí volána funkce zmenParametry(), která provede změnu požadového parametru požadovaným způsobem (pro každý parametr ověří požadavek vytvořený některým z tří ovládacích tlačítek), nebo zavolá konfigurační funkci, v případě stisku tlačítka "Prog". Podobným způsobem funguje funkce Parametry(), která zajistí vykreslení parametrů vybraného prvku menu. Obě funkce (stejně jako ty předcházející) přijímají ve svém agrumentu ukazetel na strukturu/y, se kterou/kterými pracují.
<code c>
void zmenParametry(dotekXY* dotek, INA_PGA* PGA308_val, INA_AD* AD8557_val, ADC_AD* AD7175_val, MERENI_CAS* cas_val)
{
    //Detekovan dotek
    if (dotek->pocetDoteku > 0 ) {
        switch (paramIO) {
            
// ******************** Menu PGA308 ********************
            
            // ******** Front End Gain **********
            case feGain_PGA308:
                if (nastPar != nastParPredchozi) {
                //Tlacitko <
                    if (nastPar == l) {
                        if (PGA308_val->feGain_X > 0) {
                            PGA308_val->feGain_X = PGA308_val->feGain_X - 1;
                        } 
                        param_PGA308(PGA308_val);
                    }
                //Tlacitko >
                    else if (nastPar == p) {
                        if (PGA308_val->feGain_X < (sizeof(PGA308_val->feGain) / sizeof(PGA308_val->feGain[0])-1)) {
                            PGA308_val->feGain_X = PGA308_val->feGain_X + 1;
                        }
                        param_PGA308(PGA308_val);
                    }
                //Tlacitko Prog
                    else if (nastPar == prog) {
                        KonfigPGA308(PGA308_val);
                    }
                }
                break;
                
                // ***************************************
                // vyhodnoceni vsech zbyvajicich parametru
                // ***************************************
                
                default:
                paramIO = Nic_P;  
                konfigurace = N;
        }
    }
}
</code>
=== Konfigurace obvodů ===
== AD7175-2 ==
Pro komunikaci s AD převodníkem [[http://www.analog.com/en/products/analog-to-digital-converters/ad7175-2.html|AD7175-2]] bylo využito knihovny [[https://wiki.analog.com/resources/tools-software/uc-drivers/ad717x|AD717X No-OS Software Drivers]] od Analog Devices, obsahující samotnou knihovnu pro AD převodník a dále také generickou komunikační knihovnu pro SPI komunikaci. V této knihovně byly napsány funkce pro inicializaci, čtení a zápis po SPI. S touto knihovnou pracuje hlavičkový soubor AD7175_2_regs.h (pro každý konkrétní obvod jiný) obsahující deklaraci struktury s adresami vnitřních registrů AD převodníku, jejich počáteční hodnotou a velikostí. Při zápisu do jakéhokoliv registru AD převodníku je třeba nejprve zapsat požadovanou hodnotu do této struktury a poté zavolat funkci pro zápis do AD převodníku. Obdobný princip funguje při čtení, kdy je hodnota registru uložena do této struktury a poté je třeba hodnoty vyčíst z ní.

{{  https://wiki.analog.com/_media/resources/tools-software/uc-drivers/spi_architecture.png?600  }}



<code c>
    // Zapis do registru ADCMODE
    //Registr ADCMODE - interni oscilator (bez vyvedeni na pin), standby mode, vypnuti interni reference
    AD717X_GetReg(ad7175_2_handler, AD717X_ADCMODE_REG)->value = AD717X_ADCMODE_REG_CLKSEL(0) | AD717X_ADCMODE_REG_MODE(2) | AD717X_ADCMODE_REG_DELAY(0);
    //Zapis do ADCMODE registru
    AD717X_WriteRegister(ad7175_2_handler, AD717X_ADCMODE_REG);
</code>

AD převodník může fungovat v režimu continual nebo single, což lze nastavit v GUI. Nastavení AD převodníku do režimu single způsobí převedení jediného vzorku a poté dojde k přechodu do režimu standby. Režim continual naopak zajišťuje neustálý převod, dokud není AD převodník nastaven jinak. Knihovna od výrobce obsahuje dvě funkce, sloužící pro správné vyčítání výsledků převodu, AD717X_WaitForReady a AD717X_ReadData. Funkce AD717X_WaitForReady čeká a kontroluje, zda již byl dokončen převod a je k dispozici jeho výsledek (lze nastavit počet těchto "kontrol"). Funkce AD717X_ReadData poté výsledek vyčte a uloží do uživatelem zvolené proměnné. 

Následující funkce zajištuje kontinuální měření po dobu k tomu určenou. V prvním případě je měření a ukládání vzorků spouštěno externím signálem, což je zde simulováno nastavením výčtové proměnné "mereni" pomocí tlačítka na vývojové desce. V druhém případě měření probíhá při zavolání této funkce neustále (a správném nastavení v GUI), je ovšem kontrolována hodnota vzorků a pokud překročí nebo je rovna nastavené úrovni, je spuštěno měření času a vzorky jsou ukládány do paměti SDRAM. Po ukončení měření je zavolána funkce ulozData, která data vyčte z paměti SDRAM a uloží je na SD kartu ve formě surových dat, bez souborového systému (který bude přidám v pozdější fázi práce), což je v této fázi dostačující.
<code c>
// Kontinualni mereni - spousteni ext. signalem / urovni mereneho signalu
void kontMer(uint32_t *pocetVzorku, struct ad717x_device *ad7175_2_handler, MERENI_CAS* cas, FMC_SDRAM_CommandTypeDef* SDRAMCommand) 
{
    uint8_t err = 0;
    
    if ((strcmp(cas->zpusSpout[cas->zpusSpout_X], "Ext. sig.") == 0) && (mereni == start)) { // Kontrola externiho signalu
        // Spusteni mereni
        if (dobaMer == ceka) {
            dobaMer = trva;
            t.attach(&kontrolaCasu, cas->dobaMereni[cas->dobaMereni_X]); // spust mereni casu urceneho pro mereni
        }
        
        else if (dobaMer == trva) {
        
            // Cekani na vysledek konverze
            ret = AD717X_WaitForReady(ad7175_2_handler, timeout);
            if (ret < 0) {
                // Chyba pri cekani na vysledek 
                printf("WaitForReady-Ext: %d\r\n", ret);
                //while(1);
            }

            // Vycteni vysledku konverze
            ret = AD717X_ReadData(ad7175_2_handler, &sample[0]);
            if (ret < 0) {
                // Chyba pri cteni dat
                printf("ReadData-Ext: %d\r\n", ret);
                //while(1);
            }
        
            //printf("cisloVzDoRAM: %d\r\n", *pocetVzorku);
            // Ulozeni vysledku do SDRAM
            err = sdram.WriteData(SDRAM_DEVICE_ADDR + WRITE_READ_ADDR + 4 * *pocetVzorku, (uint32_t*)&sample[0], 1);
            if (err) {
                printf("SDRAM Write err - S\r\n");
            }
        
            *pocetVzorku += 1;

        }
        // Ukonceni mereni po uplynuti doby k tomu urcene
        else if (dobaMer == uplynula) {
            t.detach();
            uint32_t pV = *pocetVzorku;
            ulozData(pV, SDRAMCommand); // Ulozeni dat na SD kartu
            // Nastaveni parametru urcujicich konec mereni
            *pocetVzorku = 0;
            mereni = stop;
            stav = nastaveniS;
            dobaMer = ceka;
        } 
    }
    
    // Spousteni mereni urovni signalu
    else if (strcmp(cas->zpusSpout[cas->zpusSpout_X], "Uroven") == 0) {
        
        while(urSpust != mer) {
            // Cekani na vysledek konverze
            ret = AD717X_WaitForReady(ad7175_2_handler, timeout);
            if (ret < 0) {
            // Chyba pri cekani na vysledek 
                printf("WaitForReady-urCek: %d\r\n", ret);
                //while(1);
            }
 
            // Vycteni vysledku konverze
            ret = AD717X_ReadData(ad7175_2_handler, &sample[0]);
            if (ret < 0) {
            // Chyba pri cteni dat 
                printf("ReadData-urCek: %d\r\n", ret);
                //while(1);
            }
            // Porovnani vysledku konverze se spousteci urovni
            if ((sample[0] >= cas->urovenSpoust[cas->urovenSpoust_X]) && dobaMer == ceka) {
                urSpust = mer; // spust ukladani dat
                dobaMer = trva;
                t.attach(&kontrolaCasu, cas->dobaMereni[cas->dobaMereni_X]); // spust mereni casu urceneho pro mereni
            }
        }
        
        if (urSpust == mer) { // mereni je spusteno
            
            // Cekani na vysledek konverze
            ret = AD717X_WaitForReady(ad7175_2_handler, timeout);
            if (ret < 0) {
                // Chyba pri cekani na vysledek
                printf("WaitForReady-uroven: %d\r\n", ret);
                //while(1);
            } 
 
            // Vycteni vysledku konverze
            ret = AD717X_ReadData(ad7175_2_handler, &sample[0]);
            if (ret < 0) {
                // Chyba pri cteni dat
                printf("ReadData-uroven: %d\r\n", ret);
                //while(1);
            }
            
            // Ulozeni vysledku do SDRAM
            err = sdram.WriteData(SDRAM_DEVICE_ADDR + WRITE_READ_ADDR + *pocetVzorku * 4, (uint32_t*)&sample[0], 1);
            if (err) {
                printf("SDRAM Write err - S\r\n");
            }
            
            *pocetVzorku += 1;
            // Ukonceni mereni po uplynuti doby k tomu urcene
            if (dobaMer == uplynula) {
                t.detach();
                uint32_t pV = *pocetVzorku;
                ulozData(pV, SDRAMCommand); // Ulozeni dat na SD kartu
                // Nastaveni parametru urcujicich konec mereni
                *pocetVzorku = 0;
                mereni = stop;
                stav = nastaveniS;
                dobaMer = ceka;
                urSpust = cekej;
            }
        }
    }
}
</code>

Funkce zajišťující zápis naměřených dat na SD kartu (v tomto výpisu jsou pro zkrácení smazány části, zajiˇštující pouhé vypsání hlásky o chybě, pokud nastane). Data z SDRAM a SD karty jsou postupně vypsána do konzole (v případě dat z SDkarty jsou vypisována po blocích) pro názornou ukázku jejich správnosti.
<code c>
void ulozData(uint32_t pocetVzorku)
{
    int32_t b = 0; // pomocna promenna pro vytvoreni bloku dat
    uint32_t indexBlok = 0;  
    uint8_t SD_state = MSD_OK;
    uint32_t vzorek[1];
    uint32_t poleSD[128];
    uint32_t NUM_OF_BLOCKS = (uint32_t)ceil((32.0*(float)pocetVzorku)/(4096.0)); // Pocet pametovych bloku v SD karte pro zapis vzorku
    printf("Num_of_blocks: %d\n", NUM_OF_BLOCKS);
    printf("Pocet vzorku: %d\n", pocetVzorku);
    
    // Vymazani casti pameti SD karty
    SD_state = sd.Erase(BLOCK_START_ADDR, (BLOCK_START_ADDR + NUM_OF_BLOCKS - 1));
    // Cekej dokud neni mazani dokonceno
    while(sd.GetCardState() != SD_TRANSFER_OK){
    }

    // Vycitani dat z SDRAM
    for (uint32_t a = 0; a < pocetVzorku; a++) {
        sdram.ReadData(SDRAM_DEVICE_ADDR + WRITE_READ_ADDR + 4 * a, (uint32_t*)&vzorek[0], 1);
        printf("DataSDRAM %d: %x\r\n", a, vzorek[0]); // Vypis vzorku v SDRAM pro kontrolu se vzorky v SDkarte
        // Naplneni pole odpovidajiciho bloku v SD karte
        if (b < 128) {
            poleSD[b] = vzorek[0];
            b++;
        }
        // Zapis a vycitani dat z SD karty (po blocich)
        if ((b >= 128) || (a >= (pocetVzorku-1))) {
            SD_state = sd.WriteBlocks(poleSD, BLOCK_START_ADDR + 512 * indexBlok, 1, 10000);
            // Cekej dokud neni zapis hotov
            while(sd.GetCardState() != SD_TRANSFER_OK){
            }
            
            uint32_t poleSD[128] = {NULL}; 
            
            // Cteni bloku dat z SD karty
            SD_state = sd.ReadBlocks(poleSD, BLOCK_START_ADDR + 512 * indexBlok, 1, 10000);
            // Cekej dokud neni cteni dokonceno
            while(sd.GetCardState() != SD_TRANSFER_OK){
            }
            
            b--; // dekrementace indexu pro vypsani vsech vzorku
            for (; b > -1; b--) {
                printf("SD data %d: %x\n", b, poleSD[b]); // vypsani vsech vzorku v bloku SD karty
            }
            
            indexBlok++;
            b = 0;
        }
        
    }
    
    pocetVzorku = 0;
    printf("Konec vypisu \r\n");
}
</code>
== AD8557 ==
Přístrojový zesilovač s programovatelným ziskem (v rozsahu 28 až 1300) [[http://www.analog.com/en/products/amplifiers/instrumentation-amplifiers/ad8557.html|AD8557]] je konfigurován přes rozhraní 1W. Vzhledem k napájení tohoto převodníku napětím 5 V, je pro zajištění úrovňové kompatibility použit převodník úrovní s tranzistorem BSS138. Parametry je možné naprogramovat a poté pomocí programovací sekvence napevno uložit v paměti nebo je možné tyto parametry tzv. simulovat, tedy naprogramovat jejich hodnotu dočasně. Je možné ji přepsat, případně dojde k resetu při odpojení napájení. Zisk je možné nastavovat pro vstupní a výstupní část přístrojového zesilovače. Dále je možné nastavovat výstupní offsetové napětí v rozsahu mezi oběma napájecími potenciály (s 8bitovým rozlišením).
Konfigurace probíhá pomocí vyslání 38bitového sériového slova na příslušný pin obvodu, viz [[http://www.analog.com/media/en/technical-documentation/data-sheets/AD8557.pdf|datasheet]]. Konfigurační slovo má následující strukturu: \\
  * Bit 0-11   : Startovací paket
  * Bit 12-13 : Volba funkce (v tomto případě se jedná o simulaci parametrů)
  * Bit 14-15 : Výběr parametru
  * Bit 16-17 : Dummy bit "10", zabraňuje předčasnému vzniku startovacího/ukončovacího paketu kombinací bitů
  * Bit 18-25 : Hodnota parametru
  * Bit 26-37 : Ukončovací paket
Vytvořená knihovna pro konfiguraci tohoto obvodu obsahuje deklaraci již zmíněné struktury, k uchování hodnot jednotlivých parametrů, funkci pro vysílání sériového slova a funkci pro jeho sestavování.

== PGA308 ==
Přístrojový zesilovač s programovatelným ziskem [[http://www.ti.com/product/PGA308|PGA308]] od Texas Instruments je přímo určen k použití při měření s můstkovými senzory. Tomu odpovídají jeho vnitřní funkce a možnosti jeho nastavení. Zesílení lze nastavovat v rozsahu od 2,66 až 9600. Nastavení zesílení probíhá pomocí více stupňů, je tedy možné dosáhnout jeho různých hodnot.Dále je také možné nastavit offset v rozsahu -2,5 V do 2,5 V při referenčním napětí 5 V.
Konfigurace tohoto bvodu probíhá přes rozhraní 1W, které je v tomto případě kompatibilní s UART rozhraním. Lze tedy využít výstupní pin UARTu na MCU. Rychlosti komunikace se mohou pohybovat v rozsahu 4,9 kbit/s až 114 kbit/s, přičemž pro každý jednotlivý přenos lze využít jinou rychlost. Při komunikaci je nejdříve vyslán inicializační byte (hodnota 0x55), pomocí kterého se nastaví datová rychlost na přijímači. Dále je odeslán řídící byte, nastavující čtení/zápis registru a jeho adresu. Následují dva datové byty v pořadí LSB, MSB.
Pro tento obvod byla také napsána knihovna obsahující strukturu (jako v případě AD8557) a dále funkci sestavující jednotlivé byty a jejich odesílání na UART. Funkce této knihovny nebyla zatím prakticky ověřena.

===== Závěr ===== 
Vytvořený firmware dokáže pomocí GUI uživatelsky volit různé parametry použitého AD převodníku a programovatelného zesilovače, kromě PGA308 u něhož nebyla zatím ověřena funkčnost konfigurační knihovny - bude provedeno později. Dále je schopen zajišťovat spouštění měření a to jak úrovní signálu (viz demonstrační video), tak externím signálem (který je v tomto případě simulován tlačítkem). Měření probíhá po zvolenou dobu, což lze také vyvodit z počtu vzorků a zvolené vzorkovací frekvence (v demonstračním videu: čas měření 100 ms, datová výstupní rychlost AD převodníku 100 kSa/s, počet vzorků 11). Ukládání dat na SDRAM a SD kartu probíhá v pořádku, viz obrázek níže. 
Bylo by vhodné doplnit firmware o část, zajišťující práci se souborovým systémem na SD kartě a ukládání dat do csv souboru. Dále by bylo uživatelsky přívětivější, kdyby zvolený parametr byl zvýraznět, ovšem není to nutné pro tyto potřeby.
V další fázi dojde k ověření funkčnosti konfigurační knihovny pro PGA308, porovnání obou programovatelných zesilovačů a implementaci ethernetového rozhraní. 

{{ :2017:digitizer:termite_vypis.png?500  |Obr 3.1: Výpis naměřených dat (z SDRAM a SD karty) do terminálu }}

Na videu je zachycen způsob spouštění měření pomocí úrovně signálu. Úroveň měřeného signálu je změněna zatlačením na membránu připojeného tlakového snímače.

{{ youtube>aAxsckU9gyo?medium }}
Individální projekty MPOA

Uživatelské nástroje

Nástroje pro tento web

Nástroje pro stránku
