Operácie

MEMS meranie s A/D prevodníkom: Rozdiel medzi revíziami

Zo stránky SensorWiki

Balogh (diskusia | príspevky)
dBez shrnutí editace
Balogh (diskusia | príspevky)
 
(18 medziľahlých úprav od rovnakého používateľa nie je zobrazených.)
Riadok 1: Riadok 1:
Note: v.2025
== Potenciometrické snímače ==
== Potenciometrické snímače ==


# Poskladajte si odporový senzor polohy so stupnicou (ak nemáte, použite senzor v TinkerCADe).
# Senzor z predošlého cvičenia pripojte k A/D prevodníku mikropočítača a pomocou programu nižšie zmerajte prevodovú charakteristiku celého meracieho člena.  
# Zmerajte prevodovú charakteristiku odporového senzora polohy pomocou ohmmetra (cvičenie 1).
# Namerané hodnoty pri oboch polohách prepínača (B aj A) vyhodnoťte podľa STN EN 60 770.
# Senzor pripojte k A/D prevodníku mikropočítača a pomocou programu nižšie zmerajte prevodovú charakteristiku celého meracieho člena.  
# Aktuálnu zmeranú hodnotu zobrazte na miestnom LED displeji.
# Prevodovú charakteristiku zlinearizujte a doložte úspešnosť porovnaním metrologických parametrov.  




[[Súbor:MEMS02-SchemaZapojenia21.png|300px|thumb|center|Schéma zapojenia]]
<!-- [[Súbor:MEMS02-SchemaZapojenia21.png|300px|thumb|center|Schéma zapojenia]] -->


[[Súbor:MEMS02-SchemaZapojenia.png|300px|thumb|center|Schéma zapojenia]]
[[Súbor:MEMS02-SchemaZapojenia.png|300px|thumb|center|Schéma zapojenia]]


* Príklad na pripojenie analógového senzora: http://senzor.robotika.sk/sensorwiki/index.php/Acrob007
[[Súbor:MEMS02-BlokyPrevodu.png|800px|thumb|center|Postupnosť prevodov]]
* Arduino homepage https://www.arduino.cc/
 
 




Riadok 19: Riadok 21:
Azda najjednoduchší program na meranie je tento
Azda najjednoduchší program na meranie je tento


<source lang="cpp">
<syntaxhighlight lang="arduino" line>
#define mySensor 0            // 0: potenciometer
#define mySensor 4                  // 4: potenciometer
                              // 3: senzor sily
                              // 5: senzor ohybu


int adcValue;
  int adcValue;
float outputValue;
float outputValue;


void setup()
void setup()
{                              // monitor sa otvara dole vpravo
{                               
  Serial.begin(9600);           // typicke rychlosti su 9600 alebo 115200
  Serial.begin(57600);               // typicke rychlosti su 9600 alebo 57600
}
}
   
   
void loop()
void loop()
{
{
   adcValue = analogRead(mySensor); // read ADC value
   adcValue = analogRead(mySensor); // read ADC value
    
    
   outputValue = adcValue;
   outputValue = adcValue;           // information processing (if necessary)
    
    
   Serial.println(outputValue);       // prints value over serial
   Serial.println(outputValue);     // prints result over serial
 
delay(100);                      // delay in milliseconds


delay(500);                        // delay in milliseconds
}
}
</source>
</syntaxhighlight>


Funkcia analogRead zavolá A/D prevodník integrovaný na čipe, ktorý prevedie vstupné napätie v rozsahu 0 - 5 V na celé číslo v rozsahu 0 - 1023 (zodpovedajúce 10-bitovému prevodníku).
Funkcia <tt>analogRead()</tt> zavolá A/D prevodník integrovaný na čipe, ktorý prevedie vstupné napätie v rozsahu 0 - 5 V na celé číslo v rozsahu 0 - 1023 (zodpovedajúce 10-bitovému prevodníku).
Ak chceme zobraziť hodnotu napätia a nie číslo z prevodníka, zmeníme kód na riadku ?? napr. nasledovne:
Ak chceme zobraziť hodnotu napätia a nie číslo z prevodníka, zmeníme kód na riadku 15 napr. nasledovne:


   outputValue = adcValue * 5 / 1023;
   outputValue = adcValue * 5 / 1023;


Funkcia Serial.println potom vyšle výsledné číslo po sériovej linke do PC, kde si ich odchytíme v terminálovom okne. Pozor, prenosová rýchlosť v termináli musí byť zhodná s tou, ktorú
Funkcia <tt>Serial.println()</tt> potom vyšle výsledné číslo po sériovej linke do PC, kde si ich odchytíme v terminálovom okne. Pozor, prenosová rýchlosť v termináli musí byť zhodná s tou, ktorú
sme nastavili funkciou Serial.begin, t.j. ???? Baud.
sme nastavili funkciou Serial.begin, t.j. 57 600 Baud.


Uvedený kód môžeme ďalej vylepšovať - napríklad odstránime časť šumu na vstupe tak, že meranie spravíme viackrát a spriemerujeme. Napríklad takto:
<syntaxhighlight lang="arduino">
/* odmeraj N (64) hodnot a vypocitaj priemer */
  outputValue = 0;
    for ( int i=1; i<=64; i++)
      outputValue += analogRead(mySensor);
  outputValue = outputValue / 64;
</syntaxhighlight>


Lepší kód na poloautomatické meranie
Hint: viete, prečo je lepšie počítať priemer zo 16, 32 alebo 64 hodnôt a nie z 10 alebo 100?


<source lang="cpp">
Ďalšie zlepšenie by mohlo byť pridanie indikácie pripravenosti na meranie LED diódou a spustenie samotného merania tlačidlom (je pripojené na A5, resp. D19)


// Meranie na potenciometrickej doske v.2024
<syntaxhighlight lang="arduino">
// Tlacitko je na A5 a zapiseme nim meranie
/* Zadefinovanie tlacitka */
// Potenciometer je na A4 a da sa citat 0/1023
#define PUSHBUTTON 19
//  pricom ak zmenim prepinacom charakteristiku, tak
//  tym ze je to napatovy delic, funguje stale rovnako


unsigned long int sensorValue;
unsigned      int counter;


void setup()  
/* Do casti setup() treba pridat konfiguraciu a uvodny vypis */
{
  Serial.begin(115200);
    
    
   pinMode(LED_BUILTIN, OUTPUT);
   pinMode(LED_BUILTIN, OUTPUT);
   pinMode(18, INPUT);
   pinMode(PUSHBUTTON, INPUT_PULLUP);
  pinMode(19, INPUT);


   Serial.println("*** MISA measurement (press Red PB to start): ***\n\n");
   Serial.println("*** MISA measurement (press Red PB to start): ***\n\n");
  counter = 1;
}


void loop()
{
  digitalWrite(13,HIGH);  // Led ON = Ready
  while ( digitalRead(19)== 1)
    {/* wait here */}
 
  digitalWrite(13,LOW);  // Led OFF = Measuring...


  /* odmeraj N hodnot a vypocitaj priemer */
/* Do casti loop(), ktora sa opakuje pridame indikaciu LED a cakanie na tlacitko */
   sensorValue = 0;
 
    for ( int i=1; i<=64; i++)
   digitalWrite(LED_BUILTIN,HIGH);           // Led ON = Ready
      sensorValue += analogRead(A4);
  sensorValue = sensorValue / 64;


   Serial.print(counter++);
   while ( digitalRead(PUSHBUTTON)== 1)       // Wait for press
  Serial.print(",");
        {    /* just wait here */   }
  Serial.println(sensorValue);
 
  delay(500);        // delay in between reads for stability
    
    
}
  digitalWrite(LED_BUILTIN,LOW);            // Led OFF = Measuring...


  /* a tu uz nasleduje meranie a odoslanie hodnoty */


</source>
</syntaxhighlight>


== Linearizácia prevodovej charakteristiky ==
== Zobrazenie hodnoty na LED displeji ==


Postupujte podľa návodu [[MEMS displej LED]] a zobrazte na displeji hodnotu meranej veličiny. Pre prepínač v polohe B by to mohla byť viac-menej priamo hodnota na stupnici potenciometra.


<center>
[[Súbor:displayTM1637.jpg]]<BR>
<I>Rozličné informácie zobrazené na displeji.</I>
</center>


=== 1. Look-up table ===
<BR>


== Grafické priebehy na PC (Serial Plotter) ==


<source lang="cpp">
[[Súbor:IconSerialPlotter.png|left]] Serial Plotter je trocha sofistikovanejší program ako Terminal, jeho úlohou je zakresliť graficky všetky prijaté informácie. Každý prijatý riadok predstavuje jeden bod na diagrame. Správne časovanie musíte zabezpečiť sami, program nepridáva časové značky k prijatým dátam. Neposielajte hodnoty príliš často, aby sa nepreplnil vstupný buffer.
#include <avr/pgmspace.h>
* [https://hackaday.io/project/5334-serialplot-realtime-plotting-software Domovská stránka programu]
* [http://senzor.robotika.sk/zp/serialplot.zip Lokálna kópia]


const PROGMEM int table[] = {11,12,15,...};
return( table[adcValue] );
</source>


Viac info tu: https://www.arduino.cc/en/Reference/PROGMEM


=== 2. Po častiach lineárna náhrada ===


<source lang="cpp">
<span class="mw-customtoggle-2016" style="background:#e0e8ff">Nepovinná časť (kliknutím rozbaliť / zbaliť)</span>
  /* segment 1 */
if (adcValue > x0) && (adcValue <= x1)
  y = k1 * adcValue + q1;


  /* segment 2 */
<div  id="mw-customcollapsible-2016" class="mw-collapsible mw-collapsed">
if (adcValue > x1) && (adcValue <= x2)
  y = k2 * adcValue + q2;


return(y)
Ak chcete zakresliť časový priebeh signálu zo snímača, najjednoduchšie je posielať priamo čísla v ASCII formáte, pričom ich môže byť aj viac, oddelených čiarkami - každé sa zobrazí inou farbou. Každá jedna takáto n-tica hodnôt musí končíť znakom pre nový riadok (CR+LF). Ak budete používať Arduino, tak príkazmi Serial.Write posielajte čísla a čiarky, ak chcete riadok ukončiť, použijete Serial.prinln(), napríklad takto:
</source>
<syntaxhighlight lang="arduino">
 
  Serial.print(counter++);
Dá sa použiť aj funkcia map v Arduine -  https://www.arduino.cc/reference/en/language/functions/math/map/
  Serial.print(",");
 
  Serial.println(sensorValue);
=== 3. Aproximácia funkcie ===
</syntaxhighlight>
alebo aj takto:
<syntaxhighlight lang="arduino">
  char buffer[20];                    // Used for sprintf
  sprintf(buffer, "%d,%d,%d",adcValue1, adcValue2, adcValue3); 
  Serial.println(buffer);              // Send the value using serial to PC
</syntaxhighlight>


<source lang="cpp">
Pre micro:bit v knižnici <tt>Serial</tt> použite bloky Serial Write Number pre čísla, Serial Write String pre čiarky a Serial Write Line pre ukončenie riadka.<BR><BR>
  y = a2 * adcValue^2 + a1 * adcValue + a0;
  return(y);
</source>
 
 
* http://terpconnect.umd.edu/~toh/spectrum/CurveFitting.html
 
* https://www.gnu.org/software/octave/doc/interpreter/Polynomial-Interpolation.html
* http://octave.sourceforge.net/optim/function/leasqr.html
* http://octave.sourceforge.net/optim/function/expfit.html
* https://www.gnu.org/software/gsl/manual/html_node/Example-programs-for-Nonlinear-Least_002dSquares-Fitting.html
* https://www.gnu.org/software/octave/doc/interpreter/One_002ddimensional-Interpolation.html#One_002ddimensional-Interpolation




[[Súbor:SerialPlotter01.png]]


<BR>
<BR>


</DIV> <!-- rozbalovacia / zbalovacia cast -->


== Úlohy ==
== Úlohy ==
Riadok 161: Riadok 144:
'''Úlohy, ktoré treba odovzdať:'''  
'''Úlohy, ktoré treba odovzdať:'''  


* Graf 1: prevodové charakteristiky
* Graf 1: prevodové charakteristiky B aj A
* Chyby podľa EN 60 770
* Chyby podľa EN 60 770
** Nepresnosť
** Nepresnosť
Riadok 168: Riadok 151:
** Hysteréza
** Hysteréza
** Neopakovateľnosť
** Neopakovateľnosť
* Graf 2: chybové krivky (viď obr.)
* Graf 2: chybové krivky  
* Program pre mikroprocesor na linearizáciu
* Porovnať namerané výsledky s predošlými


[[Súbor:Example2-1.png|500px]]
[[Súbor:Example2-1.png|500px]]


Hodnotenie: 5 bodov
Deadline: <FONT COlor="red">'''8. 3. 2022 '''</font>




* Tools: https://inkscape.org/sk/~sincoon/%E2%98%85knob-scale-generator


[[MEMS inteligentné senzory a aktuátory#Cvi.C4.8Denia|Návrat na zoznam cvičení...]]
[[MEMS inteligentné senzory a aktuátory#Cvi.C4.8Denia|Návrat na zoznam cvičení...]]


[[Category:MEMS]]
[[Category:MEMS]]

Aktuálna revízia z 16:34, 23. február 2025

Note: v.2025

Potenciometrické snímače

  1. Senzor z predošlého cvičenia pripojte k A/D prevodníku mikropočítača a pomocou programu nižšie zmerajte prevodovú charakteristiku celého meracieho člena.
  2. Namerané hodnoty pri oboch polohách prepínača (B aj A) vyhodnoťte podľa STN EN 60 770.
  3. Aktuálnu zmeranú hodnotu zobrazte na miestnom LED displeji.


Schéma zapojenia
Postupnosť prevodov



Meranie charakteristiky senzora mikroprocesorom s A/D prevodníkom

Azda najjednoduchší program na meranie je tento

#define mySensor 4                  // 4: potenciometer

  int adcValue;
float outputValue;

void setup()
{                              
 Serial.begin(57600);               // typicke rychlosti su  9600 alebo 57600
}
 
void loop()
{
  adcValue = analogRead(mySensor);  // read ADC value
  
  outputValue = adcValue;           // information processing (if necessary)
  
  Serial.println(outputValue);      // prints result over serial

 delay(500);                        // delay in milliseconds
}

Funkcia analogRead() zavolá A/D prevodník integrovaný na čipe, ktorý prevedie vstupné napätie v rozsahu 0 - 5 V na celé číslo v rozsahu 0 - 1023 (zodpovedajúce 10-bitovému prevodníku). Ak chceme zobraziť hodnotu napätia a nie číslo z prevodníka, zmeníme kód na riadku 15 napr. nasledovne:

 outputValue = adcValue * 5 / 1023;

Funkcia Serial.println() potom vyšle výsledné číslo po sériovej linke do PC, kde si ich odchytíme v terminálovom okne. Pozor, prenosová rýchlosť v termináli musí byť zhodná s tou, ktorú sme nastavili funkciou Serial.begin, t.j. 57 600 Baud.

Uvedený kód môžeme ďalej vylepšovať - napríklad odstránime časť šumu na vstupe tak, že meranie spravíme viackrát a spriemerujeme. Napríklad takto:


 /* odmeraj N (64) hodnot a vypocitaj priemer */
  outputValue = 0;
    for ( int i=1; i<=64; i++) 
      outputValue += analogRead(mySensor);
  outputValue = outputValue / 64;

Hint: viete, prečo je lepšie počítať priemer zo 16, 32 alebo 64 hodnôt a nie z 10 alebo 100?

Ďalšie zlepšenie by mohlo byť pridanie indikácie pripravenosti na meranie LED diódou a spustenie samotného merania tlačidlom (je pripojené na A5, resp. D19)

/* Zadefinovanie tlacitka */
#define PUSHBUTTON 19


/* Do casti setup() treba pridat konfiguraciu a uvodny vypis */
  
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(PUSHBUTTON, INPUT_PULLUP);

  Serial.println("*** MISA measurement (press Red PB to start): ***\n\n");


/* Do casti loop(), ktora sa opakuje pridame indikaciu LED a cakanie na tlacitko */

  digitalWrite(LED_BUILTIN,HIGH);            // Led ON = Ready

  while ( digitalRead(PUSHBUTTON)== 1)       // Wait for press
        {    /* just wait here */    }
  
  digitalWrite(LED_BUILTIN,LOW);             // Led OFF = Measuring...

  /* a tu uz nasleduje meranie a odoslanie hodnoty */

Zobrazenie hodnoty na LED displeji

Postupujte podľa návodu MEMS displej LED a zobrazte na displeji hodnotu meranej veličiny. Pre prepínač v polohe B by to mohla byť viac-menej priamo hodnota na stupnici potenciometra.


Rozličné informácie zobrazené na displeji.


Grafické priebehy na PC (Serial Plotter)

Serial Plotter je trocha sofistikovanejší program ako Terminal, jeho úlohou je zakresliť graficky všetky prijaté informácie. Každý prijatý riadok predstavuje jeden bod na diagrame. Správne časovanie musíte zabezpečiť sami, program nepridáva časové značky k prijatým dátam. Neposielajte hodnoty príliš často, aby sa nepreplnil vstupný buffer.



Nepovinná časť (kliknutím rozbaliť / zbaliť)

Ak chcete zakresliť časový priebeh signálu zo snímača, najjednoduchšie je posielať priamo čísla v ASCII formáte, pričom ich môže byť aj viac, oddelených čiarkami - každé sa zobrazí inou farbou. Každá jedna takáto n-tica hodnôt musí končíť znakom pre nový riadok (CR+LF). Ak budete používať Arduino, tak príkazmi Serial.Write posielajte čísla a čiarky, ak chcete riadok ukončiť, použijete Serial.prinln(), napríklad takto:

  Serial.print(counter++);
  Serial.print(",");
  Serial.println(sensorValue);

alebo aj takto:

  char buffer[20];                     // Used for sprintf
  sprintf(buffer, "%d,%d,%d",adcValue1, adcValue2, adcValue3);  
  Serial.println(buffer);              // Send the value using serial to PC

Pre micro:bit v knižnici Serial použite bloky Serial Write Number pre čísla, Serial Write String pre čiarky a Serial Write Line pre ukončenie riadka.




Úlohy

Úlohy, ktoré treba odovzdať:

  • Graf 1: prevodové charakteristiky B aj A
  • Chyby podľa EN 60 770
    • Nepresnosť
    • Meraná chyba
    • Nelinearita
    • Hysteréza
    • Neopakovateľnosť
  • Graf 2: chybové krivky



Návrat na zoznam cvičení...