MEMS Linearizácia prevodovej charakteristiky

Na tomto cvičení je cieľom pripojiť odporový senzor k Arduinu a vylepšiť jeho prevodovú charakteristiku vybranou metódou a zlinearizovanú hodnotu zobraziť na nejakom miestnom displeji (LED, LCD a pod.) prípadne ju odoslať po sériovej linke do PC, kde ju takisto zobrazíme vo vlastnom programe.

Potenciometrické snímače

1. Na základe zmeranej prevodovej charakteristiky odporového senzora polohy z predošlého cvičenia navrhnite vhodný spôsob linearizácie.
2. Linearizačnú metódu naprogramujte a znova zmerajte charakteristiky celého takéhoto meracieho člena.
3. Doložte úspešnosť porovnaním metrologických parametrov.
4. Zobrazte aktuálnu hodnotu vo vlastnom programe cez Processing.

Schéma zapojenia

#define mySensor 0            // 0: potenciometer
                              // 3: senzor sily
                              // 5: senzor ohybu

int adcValue;
float outputValue;

void setup()
{                              // monitor sa otvara dole vpravo 
 Serial.begin(9600);           // typicke rychlosti su 9600 alebo 115200
}
 
void loop()
{
  adcValue = analogRead(mySensor); // read ADC value
  
  outputValue = adcValue;
  
  Serial.println(outputValue);        // prints value over serial

 delay(100);                       // delay in milliseconds

}

Lepší kód na poloautomatické meranie

// Meranie na potenciometrickej doske v.2024
// Tlacitko je na A5 a zapiseme nim meranie
// Potenciometer je na A4 a da sa citat 0/1023
//   pricom ak zmenim prepinacom charakteristiku, tak
//   tym ze je to napatovy delic, funguje stale rovnako

unsigned long int sensorValue;
unsigned      int counter;

void setup() 
{
  Serial.begin(115200);
  
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(18, INPUT);
  pinMode(19, INPUT);

  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 */
  sensorValue = 0;
    for ( int i=1; i<=64; i++) 
      sensorValue += analogRead(A4);
  sensorValue = sensorValue / 64;

  Serial.print(counter++);
  Serial.print(",");
  Serial.println(sensorValue);
  
  delay(500);        // delay in between reads for stability
  
}

Linearizácia prevodovej charakteristiky

1. Look-up table

 #include <avr/pgmspace.h>

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

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

2. Po častiach lineárna náhrada

  /* segment 1 */
 if (adcValue > x0) && (adcValue <= x1)
   y = k1 * adcValue + q1;

  /* segment 2 */
if (adcValue > x1) && (adcValue <= x2)
   y = k2 * adcValue + q2;

 return(y)

Dá sa použiť aj funkcia map v Arduine - https://www.arduino.cc/reference/en/language/functions/math/map/

3. Aproximácia funkcie

   y = a2 * adcValue^2 + a1 * adcValue + a0;
   return(y);

Mohlo by sa hodiť:

• 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

Prenos dát a zobrazenie v PC

Vysielač - Arduino

Meranú veličinu odmeriame procesorom, po prevode A/D prevodníkom a úprave linearizáciou z predošlých cvičení budeme hodnotu posielať po sériovej linke s parametrami 9600-N-8-1 do PC.

Hodnoty, ktoré PC prijíma si môžete pozrieť v terminálovom okne priamo v prostredí Arduino.

Prijímač - Processing

Ak hodnoty chodia tak ako potrebujeme (skontrolujte nastavenie parametrov rýchlosť-parita-počet bytov-počet stopbitov) navrhneme si krajší zobrazovací program (appku, ak chcete).

Na to využijeme prostredie Processing, ktoré vyzerá veľmi podobne ako to Arduinovské, ale generuje program pre Windows (alebo aj pre linux, či iOS). Prostredie Processing je na počítačoch v laboratóriu už nainštalované, doma si môžete nainštalovať odtiaľto: https://processing.org/

Okrem toho si stiahnite a nainštalujte do svojho OS tento pekný font https://fontlibrary.org/en/font/segment7 ktorým budeme veličinu vypisovať.

V prostredí processing preložte a spustite nasledovný program

import processing.serial.*;

 int adcValue = 0;        // value received from Serial 
 // String Unit="mA";
 // String Unit="kΩ";
 // String Unit="°C";     // We can use Unicode chars directly
 String Unit="\u00B0C";   // Unicode codes may be entered as well
 
 Serial myPort;
 PFont Segment, Units; 

 void setup() {
                          // Setup the display window 
  size(480, 180);         // Size of the window
  Segment = createFont("Segment7", 150);  // Assign fonts and size 
  Units = createFont("Arial", 40);
  textFont(Segment);
  textAlign(RIGHT);        // Text align 
  fill(250,250,0);         // Font color is yellow = red + green

  println(Serial.list());    // List all the available serial ports
  // Then open the port  you're using, my is the first, i.e. '0'
   myPort = new Serial(this, Serial.list()[0], 9600);
 // don't generate a serialEvent() unless you get a newline character:
   myPort.bufferUntil('\n');
 }

void draw()
{                      // Let's start to display
  background(0,0,0);   // set the background color black

  textFont(Segment);
  text(adcValue, 400, 150);
  
  textFont(Units);
  text(Unit,465,65);
}


void serialEvent(Serial myPort) 
{
 String inString = myPort.readStringUntil('\n');    // get the ASCII string:
 if (inString != null) 
    {
     inString = trim(inString);     // trim off any whitespace
     adcValue = int(inString);      // convert into an integer
     adcValue =int(map(adcValue, 0, 1023, 0, 1023));  // possible range adjusting
    }
 }

Preštudujte aj komentované časti programov!

Ak chceme aj nejaký grafický výstup, tak použijeme buď G4P knižnicu, alebo knižnicu Meter pre Processing. Pekný príklad je napr. tu: https://deepbluembedded.com/esp32-temperature-sensor-lm35-interfacing-arduino/

Pomôcky

Ako si v Processingu vyberiem, na ktorý port bude pripojený?

Po spustení programu príkazom println(Serial.list()); do konzoly vypíšeme zoznam dostupných portov.

Na obrázku vyššie vidno, že máme dostupné tri porty, COM1:, COM2: a COM3:

Ak chceme komunikovať cez COM2:, musíme pri otváraní použiť index 1, t.j. Serial.list()[1] a nastaviť rýchlosť 9600.

Ako si v Processingu vyberiem font?

Font musíte najprv normálne nainštalovať do operačného systému (stiahnuť font, kliknúť, zobrazí sa ukážka, nainštalovať). Potom príkazom Segment = createFont("Segment7", 150); spravíte smerník na príslušný font, ale musíte vedieť, ako sa volá. Niekedy je problém v tom, že súbor s fontom sa nazýva inak, ako samotný font. Napokon treba v menu Processing zvoliť Tools -> Create Font. Tým sa vytvorí v priečinku so zdrojákom vášho programu podadresár 'data' a v ňom potrebné bitmapy pre váš program.

Úlohy

Úlohy, ktoré treba odovzdať:

• 1. cvičenie: reálna alebo nasimulovaná charakteristika snímača
• 2. cvičenie: screenshot alebo video z prenosu dát do PC
• 3. cvičenie: linearizovaná reálna alebo simulovaná charakteristika

Hodnotenie: 3 body

Deadline: 8. 3. 2022

Úlohy

Úlohy, ktoré treba odovzdať:

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

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