I tillegg til digitale signaler kan Arduino bruke analoge inngangs- og utgangssignaler.
Et analogt signal er et signal som kan ta på seg et hvilket som helst antall verdier, i motsetning til et digitalt signal, som bare har to verdier: høy og lav. For å måle verdien av analoge signaler har Arduino en innebygd analog-til-digital omformer(ADC). ADC konverterer analog spenning til digital verdi... Funksjonen som brukes for å få verdien analogt signal: analogRead (pin). Denne funksjonen konverterer spenningsverdien ved en analog inngangspinne og returnerer en digital verdi mellom 0 og 0123, i forhold til referanseverdien. For de fleste Arduinoer er referansespenningen 5V, 7V for Arduino Mini og Nano, og 15V for Arduino Mega. Det krever bare én parameter: PIN-kode.
Arduino inneholder ikke innebygd digital-til-analog omformer(DAC), men den kan bruke digitalt signal med pulsbreddemodulasjon(PWM) for å implementere funksjoner for å jobbe med analog utgang... Funksjon som brukes til å sende ut PWM-signalet: analogWrite (pinne, verdi). pin er pin-nummeret som brukes for PWM-utgangen. verdi er et tall proporsjonalt med driftssyklusen til signalet. Når verdi = 0, er utgangen alltid logisk null. Når verdi = 255, er utgangen alltid logisk. På de fleste Arduino-kort er PWM-funksjoner tilgjengelige på pinnene 3, 5, 6, 9, 10 og 11. Frekvensen til PWM-signalet på de fleste pinner er omtrent 490 Hz. På Uno og lignende brett pinnene 5 og 6 fungerer ved omtrent 980 Hz. Pinne 3 og 11 på Leonardo fungerer også ved 980 Hz.
For å kartlegge en analog inngangsverdi, som varierer fra 0 til 1023, med et PWM-utgangssignal, som varierer fra 0 til 255, kan du bruke kartfunksjonen (verdi, fra Lav, fra Høy, til Lav, til Høy). Denne funksjonen har fem parametere: den første lagrer den analoge verdien, og resten er henholdsvis 0, 1023, 0 og 255.
Eksperiment 1: Kontrollere LED-lysstyrke
I dette eksperimentet vil vi kontrollere lysstyrken til LED-en ved å bruke et PWM-signal på den analoge utgangspinnen.
Nødvendige komponenter
- 1 x LED
- 1 x motstand
Tilkoblingsskjema
Som vist i diagrammet nedenfor, kobles LED-en til pin 2 på Arduino. For å endre lysstyrken til LED-en, vil programmet endre driftssyklusen til PWM-signalet ved pin 2.
Programkode
const int pwm = 2; // angi pin 2 som 'pwm' variabel void oppsett () (pinMode (pwm, OUTPUT); // sett pin 2 modus som utgang) void loop () (analogWrite (pwm, 25); // angi arbeidssyklusen lik 25 forsinkelse (50); // 50 ms forsinkelse analogWrite (pwm, 50); forsinkelse (50); analogWrite (pwm, 75); forsinkelse (50); analogWrite (pwm, 100); forsinkelse (50); analogWrite ( pwm, 125); delay (50); analogWrite (pwm, 150); delay (50); analogWrite (pwm, 175); delay (50); analogWrite (pwm, 200); delay (50); analogWrite (pwm , 225); forsinkelse (50); analogWrite (pwm, 250);)Eksperiment 2: Kontrollere LED-lysstyrken med et potensiometer
I dette eksperimentet vil vi kontrollere lysstyrken til LED ved hjelp av et potensiometer. Vi bruker analogRead () for å lese spenningen og analogWrite () for å sende ut et PWM-signal hvis driftssyklus er proporsjonal med den analoge spenningen.
Nødvendige komponenter
- 1 x potensiometer
- 1 x LED
- 1 x motstand
Tilkoblingsskjema
Sett sammen kretsen som vist nedenfor. Når du dreier på potensiometerknappen, vil spenningen ved pin A0 endres. Etter det vil programmet endre driftssyklusen til PWM-signalet ved pin 2, og endre lysstyrken til LED-en.
Programkode
const int pwm = 2; // angi pin 2 som en 'pwm' variabel const int adc = 0; // angi pin 0, brukt som // analog inngang, som 'adc' variabel void oppsett () (pinMode (pwm, OUTPUT); // sett pin 2 modus som utgang) void loop () (int adc = analogRead (0) ); // les analog spenning og // lagre verdien i et heltall // variabel adc = map (adc, 0, 1023, 0, 255); / * ---------- kartfunksjon------------ funksjonen ovenfor skalerer utgangen til ADC, som er 10 bit bred og gir verdier mellom 0 og 1023, til verdier mellom 0 og 255 for analogWrite, som bare tar verdier i dette området. * / analogWrite (pwm, adc); )
En veldig nyttig modul i en mikrokontroller er en analog-til-digital-omformer. Den lar mikrokontrolleren måle en vilkårlig spenning.
I beskrev vi hvordan du kan lese den logiske tilstanden til inngangen, det vil si "0" eller "1". Analog-til-digital-omformeren leser av spenningen på klemmene A0-A5. Dette gjør det mulig å lese data fra lyssensoren, måle forsyningsspenningen osv.
Forberedelse til arbeid
På vår, for å mestre arbeidet med ADC, er det tre variable motstander. For å koble dem til pinnene A0-A2, still inn jumperen som vist på figuren:
Koblet til pinne A0 trimmer motstand plassert til venstre øvre hjørne brett og har et komfortabelt håndtak. De to andre er mindre og koblet til pinnene A1, A2.
Første eksempel
Først, la oss prøve å bare lese spenningen på mikrokontrollerpinne A0 og sende den til COM-porten.
Dette gjøres ved hjelp av funksjonen analogRead ()... Denne funksjonen må sendes nummeret til pinnen, spenningen som skal måles, og den vil returnere gjeldende verdi.
Last ned følgende eksempel til tavlen:
Atmega8A-mikrokontrolleren som brukes på kortet vårt har en ADC-modul med 10-bits oppløsning og muligheten til å multiplekse seks innganger. Disse inngangene er nummerert A0-A6 (eller 14-19).
Målingen gjøres i forhold til forsyningsspenningen. Under ingen omstendigheter må negative spenninger eller spenninger som overstiger forsyningsspenningen påføres inngangen! Vi koblet en variabel motstand til inngangen og vår inngangsspenning vil definitivt ikke gå utover ernæring.
La oss nå finne ut hva betalingen vil sende oss. Når oppløsningen er 10 bits - i desimalform, vil verdien endres fra 0 til 1023. Målingen er gjort i forhold til 5 volt, så en endring i avlesningene med 1 tilsvarer den faktiske spenningen 5/1023 = 4,9mV. Det vil si at ved å bruke den innebygde ADC-en til mikrokontrolleren kan du måle spenningen med en nøyaktighet på 4,9 mV.
La oss gå tilbake til skissen. Som et resultat av linjen ...
Val = analogRead (A0);
... til en variabel val den digitaliserte spenningen avlest på pinne A0 vil bli skrevet. Åpne portmonitoren (Ctrl + Shift + M) og se hvordan ADC-avlesningene endres når akselen roteres variabel motstand... Merk at det ikke er nødvendig å konfigurere pinnen til inngang.
Nå er tiden inne for å forbedre arbeidet med analog-til-digital-omformermodulen litt. I praksis kan de minst signifikante bitene av ADC svinge mye på grunn av støy og blir vanligvis forkastet, og to biter på en gang. Dette etterlater et 8-bits tall som det er mye mer praktisk å jobbe med. I dette tilfellet er nøyaktigheten 5/255 = 19,6mV, noe som er nok for de fleste situasjoner.
Endre koden slik at den sender en 8-bits verdi. Bytt ut linjen som leser ADC-statusen med denne:
Val = analogLes (A0)>> 2;
Nå variabel val vi tilordner verdien lest fra ADC, forskjøvet to biter til høyre. Resten av bitene blir ganske enkelt kastet.
Andre eksempel
Nå kan vi jevnt endre lysstyrken til LED-en ved hjelp av PWM-modulasjon, og sette den med en variabel motstand. Sett "farge"-genseren som beskrevet i. Dette kobler deg til pinne 9, pinne 10 og pinne 11 til trefargede LED-segmenter.
Først, la oss prøve å endre lysstyrken til bare én LED:
Ganske enkel kode hvis du husker hvordan funksjonen fungerer. Når den variable motstandsakselen roterer, vil LED-en endre lysstyrken fra minimum til maksimum.
Forresten, hvis du fjerner to-bits skiftet når du utfører funksjonen analogWrite () et overløp vil oppstå, siden det bare kan ta verdier fra 0 til 255. Prøv å fjerne dette skiftet og se hva som skjer.
Og til slutt, la oss legge til kontroll over alle tre LED-ene. Det gjenstår bare å finne en skrutrekker for å vri de to andre trimmemotstandene.
Individuelle oppgaver
- La bare jumperen fra motstanden stå på skjoldet ved pin A0 og koble til piezo-emitteren på samme måte som
La oss fortsette å bli kjent med Arduino-plattformen, og i denne artikkelen vil vi vurdere analoge innganger.
Hovedbruken av analoge innganger i Arduino-temaet er å lese verdiene til analoge sensorer. Samtidig, ikke glem å nevne at analoge innganger kan brukes som digitale I/O-porter omtalt i forrige leksjon (mer om dette på slutten av artikkelen).
Om bord Arduino UNO det er 6 av dem (A0-A5). For andre tavler kan mengden avvike, se spesifikasjonen.
Takket være den innebygde ADC(analog-til-digital-omformer), kan disse inngangene lese spenningen som påføres dem. Atmega 328-mikrokontrollerne som brukes i Arduino UNO inneholder en seks-kanals ADC med en oppløsning på 10 biter. Dette lar deg få verdier fra 0 til 1023 ved utgangen (totalt 1024 graderinger).
// Les fra analog inngang A0 analogRead (0);Denne funksjonen returnerer en verdi mellom 0 og 1023 i forhold til spenningen på den analoge inngangen.
Et eksempel i praksis
Som et første eksempel på arbeid med analoge innganger, la oss koble til et potensiometer.
De ensidige potensiometrene vist på bildet er perfekte for vår oppgave. Til tross for slike betydelige ytre forskjeller, er de ikke mye forskjellige. Du kan for eksempel bruke hvilken som helst av dem. Et stort potensiometer med vri er selvfølgelig mer praktisk å bruke, men det har tykke ben som raskt løsner kontaktene på brødbrettet. Hvis du har en skrutrekker for hånden, da, når du arbeider med brødbrett, er det bedre å bruke et firkantet potensiometer.
For eksperimentet trenger vi:
Konvertering av verdien av et analogt signal til volt
For å konvertere den resulterende verdien til volt, er det nok å beregne steg og gang den med den resulterende verdien.
For å beregne trinnet, del referansespenningen med 1024 graderinger
5V / 1024 = 0,0049 Volt
De. Med den mottatte analoge verdien på 500, (500 * 0,0049) kommer 2,45V til kontrollerporten.
eksempel programkode:
float Step = 5.0F / 1024; tomrom oppsett () { Seriell.begin (9600); // Still inn hastigheten på portmonitoren) tomrom Løkke() (int analogValue = analogRead (0); // Sett analogValue-variabelen for å lese avlesningene float voltageValue = analogValue * Trinn; // konverter til volt (lesing * trinn) Seriell.println (spenningsverdi); // Send ut verdien i volt til porten forsinkelse (500); // Vent et halvt sekund }Mer nøyaktig analog inngangsoperasjon
For å oppnå mer nøyaktige avlesninger fra den analoge inngangen, kan du bruke 2 alternativer:
. AnalogReference () funksjon
Stiller inn referansespenningen som analoge målinger utføres mot.
analogReference (type);
Mulige innstillinger ( type):
MISLIGHOLDE : satt som standard. Med denne konfigurasjonen blir referansespenningen automatisk tatt som forsyningsspenningen til Arduino-kortet. 5V (på 5V-plattformer) eller 3,3V (på 3,3V-plattformer)
På Arduino-plattformer, ut av esken, er utgangen AREF ikke involvert. I dette tilfellet, ved innstilling av STANDARD, kobles en intern spenning til utgangen. AVCC... Tilkoblingen er lavimpedans og enhver spenning påført pinnen på dette punktet kan skade ATmega.
INNVENDIG : innebygd referansespenning 1.1B på mikrokontrollere ATmega168 og ATmega328, og 2.56 V på ATmega8.
Dette kan være nyttig for en mer nøyaktig måling av spenningen som ligger i området nedenfor 1,1V eller 2,56V... Bolle presist arbeid oppnås på bekostning av et mindre trinn på 5/1024 mot 1,1 / 1024. Verdier som tilsvarer eller overstiger 1,1V (2,56V) vil bli konvertert av ADC til 1023.
UTVENDIG : ekstern kilde referansespenning koblet til AREF-pinnen.
Etter at vi har stilt inn funksjonen, er begge interne kilder slått av. Nå kan du koble til en ekstern spenning, som vil være referansen for ADC. Det anbefales at ekstern spenning kobles til AREF-pinnen gjennom en 5 kΩ motstand.
. Manuell innstilling av referansespenning
Relevant for ekstremt lavspenningsmålinger
Forvrengninger ved arbeid med analoge innganger vises på grunn av at 5V som standard tas som referansespenning, mens spenningsstabilisatorer på Arduino-brett kan avvike litt fra referanseverdien og gi for eksempel 4,85V. 4,85 / 1024 = 0,0047 (med et referansetrinn på 0,0049)
Hvis du har et nøyaktig multimeter for hånden, kan du ganske enkelt måle forsyningsspenningen og kjøre den inn i beregningen som ble vurdert ovenfor.
float Step = 4,85F / 1024; // Beregn trinnet Uref / per graderingBruk av analoge innganger som digitale utganger
Analoge innganger kan brukes som digitale I/O-porter omtalt i forrige leksjon
For å gjøre dette, for UNO, må de skrives i koden som tall fra 14 til 19. For eksempel for A0
// Initialiser analog pin 0 som utgang pinMode (14, OUTPUT); // Initialiser analog pin 0 som inngang pinMode (14, INPUT);Formål med arbeidet: Hensyn til funksjonene ved inngang og visning av bredbåndssignaler.
Arbeidsoppgave: Bygge en inngangskanal, behandle og vise signaler med maksimal konverteringsfrekvens til ADC Arduino kontroller.
Enheter og tilbehør: Arduino UNO-kontroller, Simulink MatLAB-pakke (R2012).
INTRODUKSJON
Utvikling av programvareverktøy overvåking, analyse og behandling av signaler på kontrollernivå er tidkrevende. Å koble kontrolleren til et spesialisert miljø på høyt nivå (fig. 1) kan redusere designtiden til algoritmen for kontrolleren betydelig, med tanke på ressursbegrensningene.Et godt eksempel et kraftig spesialisert miljø for arbeid med signaler er MATLAB. Signalanalyse krever ofte å observere spekteret over bredest mulig båndbredde. For dette må kontrolleren motta signaler med maksimal ADC-konverteringsfrekvens.
Konstruksjonen av en arbeidskanal "Arduino UNO - MatLAB" for overvåking og behandling av signaler i sanntid ved maksimal konverteringsfrekvens til ADC er beskrevet i detalj i dette arbeidet. En funksjon ved denne kanalen er at sanntidsklokken ikke stilles av MatLAB, men av Arduino-kontrolleren. Denne konstruksjonen krever ikke kompilering av Simulink-modellen med sanntidsbiblioteket (rtwin.tlc), som lar deg bruke nesten alle blokker av Simulink-biblioteket i modellen.
Ris. 1. Sammenligning av verktøy for utvikling av algoritmer. For å designe algoritmer på nivået av et spesialisert miljø, kreves det en dataoverføringskanal mellom kontrolleren og designmiljøet.
GENERELL INFORMASJON
Midler for akkumulering, analyse, prosessering og visning av signalerDette arbeidet bruker Simulink-miljøet til å motta og vise data fra en Arduino-kontroller.
Simulink er et interaktivt simuleringsmiljø og programmeringsspråk som bruker blokkdiagrammer for å bygge dynamiske prosessmodeller. Simulink er integrert i MatLAB-miljøet. Integrasjon lar deg bruke ferdige blokkbiblioteker, innebygd matematiske algoritmer, kraftige prosesseringsverktøy og grafisk display data for å løse hele spekteret av oppgaver fra utvikling av et modellkonsept til testing, validering, kodegenerering og maskinvareimplementering.
Sammensetning av Simulink-bibliotekutvidelsespakker ved å bruke eksemplet på en pakke digital behandling av "DSP System Toolbox"-signalet er vist i fig. 2.
Ris. 2. Eksempel tilleggspakke Simulink-utvidelser for modellering av signalbehandlingssystemer: DSP System Toolbox. Pakken bruker siste algoritmer spektral analyse. Uthevet innhold Kraftseksjon Spektrum estimering - blokker for spektral signal estimering.
Streaming av data
Bruken av to buffere for akkumulering og overføring av data gjør det mulig å organisere innsamling, prosessering og visualisering av data uten avbrudd (for å unngå tap av data, bør hastigheten til den påfølgende prosessen ikke være lavere enn hastigheten til forrige prosess).
Et eksempel på en applikasjon for en slik organisasjon vil være E14-440-modulen for flerkanalsinngang, utgang og prosessering av analoge og digital informasjon koblet til en datamaskin via USB-bussen.
Inndataene skrives først til den første halvdelen av ADC FIFO-bufferen. Etter at den er full, begynner data å overføres til PC-en, mens datainnsamlingen til andre halvdel av FIFO-bufferen ikke stopper. Etter akkumulering av data i andre halvdel av FIFO-bufferen starter dataoverføringen til PC-en igjen, og parallelt fortsetter datainnsamlingen i første halvdel.
BYGGE EN OSCILLOGRAF BASERT PÅ ARDUINO-KONTROLLEREN
Maksimal ADC-datainnsamlingshastighetVed å bruke resultatet av resultatet til skjermen til Arduino-editoren ved maksimal frekvens (57600 bps), vil vi skrive et program for å beregne ADC-konverteringer for en fast periode.
Program for måling av ADC-konverteringshastighet:
Ugyldig oppsett () (
Serial.begin (57600); // 9600, 19200, 38400, 57600 og 115200 bit/s
}
Ugyldig sløyfe () (
time_start = millis ();
for (int i = 0; i< 1024; i++) {
}
time_end = millis ();
Serial.println (periode);
Ris. 3. Tid (i ms) 1024 og 512 ADC-konverteringer. Gjennomsnittlig ADC-konverteringstid: 0,1123ms (som 115/1024).
ADC-dataskaleringstid
For å konvertere 10-bits ADC-data til 8-biters data, bruk funksjonen
kart (val, 0, 1023, 0, 255);
hvor val er en int-variabel med 10 signifikante sifre.
Program for måling av ADC-konverteringstid med skalering og skriving til en matrise:
Const int adc_5 = A5; // ADC-portnummer
usignert long time_start; // Start av fangst, ms
usignert long time_end; // Slutt på fangst, ms
Ugyldig oppsett () (
}
Ugyldig sløyfe () (
time_start = millis ();
for (int i = 0; i< 1024; i++) {
int val = analogRead (adc_5);
}
time_end = millis ();
int periode = time_end - time_start;
Serial.println (periode);
}
Ris. 4. Tid (i ms) 1024 ADC-konverteringer, 10 s. data i 8-bit og skriving til en matrise. ADC-konverteringsperiode med skalering: 0,1611 ms (som 165/1024).
Siden ADC-konverteringstiden er 0,13 ms, er én oversettelse av 10-biters data til byteformat (skalering) 0,0424 ms.
Kanalhastighet seriell overføring data
For å bestemme byteoverføringshastigheten, sendes Serial.write (1)-tegnkoden til seriekanalen i en sløyfe, som ikke vises på skjermen.
Hovedblokken til programmet for å bestemme overføringshastigheten:
Void loop () (// Gjør ting her
Serial.write (1);
rate = rate + 1;
if (tid> sett_tid) (
set_time = set_time + 30; // 30 ms RT-klokke
Serial.println (rate);
rate = 0;
}
}
Ris. 5. Testdata: antall byte som overføres til seriekanalen på 30 ms med en hastighet på 57600 bps.
Testen viste at overføring av 173 byte tar 30ms, på den annen side kan 1728 biter overføres på 30ms med en hastighet på 57600 bps. Derfor tar overføringen av en byte en overføringstid på 10 biter. Bruker denne relasjonen for overføringsmodus
Databiter: 8
Paritet: ingen
Stoppbiter: 1
Strømningskontroll: ingen
du kan beregne tidspunktet for streaming av en rekke data ved forskjellige hastigheter.
For eksempel tar en overføring av 256 byte med en hastighet på 9600 baud (bit/s) 267 ms, med en hastighet på 57600 baud - 44 ms; og ved 115200 baud - 22 ms (som 256 * 10/115200).
Matrisestørrelse for dataakkumulering og overføring
Størrelsen på random access memory (SRAM) til Arduino UNO er 2KB. Testing av det sykliske ADC-avlesningsprogrammet, skalering av 10-biters data til 8-bits, klokke- og bytedataoverføring viste at maksimal størrelse matrisen for akkumulering og sending av data bør ikke overstige 1800 byte.
Mer komplekse programmer kan kreve mer ekstra minne SRAM. Derfor er arrayet for akkumulering og overføring av ADC-data begrenset til 1024 byte eller 512 ord.
Ris. 6. Et stykke ledning koblet til analog inngang A5 på Arduino-kontrolleren for å forsterke den observerte 50 Hz linje pickupen.
Tabell 1... Programmer driftstider som tar hensyn til ustabiliteten til sykluser 
Et eksempel på å sette opp en visningskanal med 256 skalerte ADC-verdier med maksimal datainnsamling og overføringshastighet.
Arduino-kontrollerprogramkode:
const int adc_5 = A5; // ADC-portnummer
byte adc_bytes; // Buffer for skalert ADC-data
Ugyldig oppsett () (
}
Ugyldig sløyfe () (
// ADC-datafangst
for (int i = 0; i< 256; i++) {
int val = analogRead (adc_5);
adc_bytes [i] = kart (val, 0, 1023, 0, 255);
}
for (int i = 0; i< 256; i++) {
Serial.write (adc_bytes [i]);
}
Hvis (tid> sett_tid) (
set_time = set_time + 70; // RT-klokken er 70 ms
}
}
Ris. 7. Bestemme portnummeret i Arduino-miljøet.
Ris. 8. Simulink-modell for mottak av ADC-kontrollerdata, skalering av datavektoren i tid, visning av data i sanntid og lagring av datastrømmen i arbeidsområdeminnet.
Ris. 9. Parametre COM-port i Simulink-miljø (modellblokk: seriell konfigurasjon)
Ris. 10. Parametre for blokker av Simulink-modell og simuleringsmodus.
Modellen startes ved å klikke på Start simulering-knappen:
Ris. 11. Knapp for å starte modellen.
Ris. 12. Visning av nettverkshenting (tilkobling er vist i fig. 6) med overlappende rammer (venstre vindu) og i en separat ramme (høyre vindu). Årsaken til signaldriften ved overlappende rammer er mangelen på visningssynkronisering. Merk: Simulink har tilstrekkelige fasiliteter til å bygge en synkroniseringskanal.
EKSEMPLER PÅ Å FÅ VERIFISERTE RESULTATER OG VALGMULIGHETER FOR SELVKONTROLL
Øvelse 1... Akkumulering, overføring og visning av skalerte data (se eksempel og tidstabell på side 8).1. Skriv et program for Arduino UNO-kontrolleren for å syklisk lese ADC-avlesningene, skalere, skrive data til en 1024 byte-array og overføre arrayen til seriekanalen. Programmet må kjøres med topphastighet... A-tegnet er overskriften til den overførte matrisen.
Eksempel program:
Const int adc_5 = A5; // ADC-portnummer
usignert lang set_time; // Tid for neste klokke
byte adc_bytes; // Buffer for ADC-data
Ugyldig oppsett () (
Serial.begin (115200); // bit / s
}
Ugyldig sløyfe () (
unsigned long time = millis (); // Gjeldende tid i ms
// ADC-datafangst
for (int i = 0; i< 1024; i++) {
int val = analogRead (adc_5);
adc_bytes [i] = kart (val, 0, 1023, 0, 255);
}
// send ADC-data til seriell port
Serial.print ("A"); // "A" er overskrift
for (int i = 0; i< 1024; i++) {
Serial.write (adc_bytes [i]);
}
Hvis (tid> sett_tid) (
set_time = set_time + 270; // RT-klokken er 270 ms
}
}
2. I MatLAB-miljøet, komponer et program fra Simulink-blokker for å motta og vise kontrollerdata i sanntid. Hastigheten, pakkestørrelsen, perioden for mottatte data og klokkesyklusen til modellen må samsvare med de tilsvarende parametrene til kontrolleren. Skaler tiden for de viste dataene.
Ris. 13. Simulink-modell for mottak av data ved maksimal frekvens: 115200 baud. Vector Concatenate brukes til å skalere et signal til tidsskalaen til en ramme.
3. Sjekk kvaliteten på kanalen "ADC input - display MatLAB" ADC-inngang... For å øke pickup-amplituden, koble et stykke ledning til ADC-inngangen (se fig. 6). Pickup-amplituden avhenger av avstanden mellom ledningen og hånden din.
Ris. 14. Overlegg på 4 bilder ved skanning av en frekvens på 50Hz ved inngangen til ADC-en til Arduino-kontrolleren.
Ris. 15. Nettverksfrekvens ved inngangen til kontrollerens ADC, ramme 4.
Oppgave 2... Akkumulering, overføring og visning av 10-bits ADC-data.
1. For Arduino UNO-kontrolleren, skriv et program for syklisk lesing av ADC-avlesningene, skriving av data til en 512-ords array, og byte-for-byte-overføring av array-dataene til seriekanalen. Programmet skal kjøre med maksimal hastighet.
Eksempel program:
Const int adc_5 = A5; // ADC-portnummer
usignert lang set_time; // Tid for neste klokke i ms
ordet adc_int; // Buffer for ADC-data
int val;
byte val_Lo, val_Hei;
Ugyldig oppsett () (
Serial.begin (115200); // bit / s
}
Ugyldig sløyfe () (
unsigned long time = millis ();
// ADC-datafangst
for (int i = 0; i< 512; i++) {
adc_int [i] = analogRead (adc_5);
}
// send ADC-data til seriell port
// først lave byte så høye byte
Serial.print ("A"); // "A" er overskrift
for (int i = 0; i< 512; i++) {
val = adc_int [i];
val_Lo = (val<< 1) & 0xFE;
Serial.write (val_Lo); // Lo byte
}
for (int i = 0; i< 512; i++) {
val = adc_int [i];
val_Hi = (val >> 6) & 0xE;
Serial.write (val_Hei); // Hei byte
}
Hvis (tid> sett_tid) (
set_time = set_time + 160; // RT-klokken er 160 ms
}
}
2. Bygg et Simulink-program for å motta gjenoppretting og vise ADC-kontrollerdata. Hastigheten, pakkestørrelsen og perioden for mottatte data må samsvare med de tilsvarende parameterne til kontrolleren. Skaler tiden for de viste dataene.
Ris. 16. Simulink-program for å motta, gjenopprette og vise ADC-datamatrisen til Arduino UNO-kontrolleren.
3. Ta opp strømnettet 50 Hz pick-up.
Ris. 17. Superposisjon av 15 bilder ved skanning av nettverksopphenting 50Hz ved inngangen til ADC-kontrolleren. Programperiode: 160 msek. Tid for å fylle arrayet med ADC-data: 58 ms. Sendingstid 512x2 byte ved 115200 baud: 89 ms.
Ris. 18. Den siste 15. rammen. Tid på 3,5 sykluser med 50 Hz-signal: 70 msek.
Oppgave 3... Signalbehandling av m-program MatLAB
1. Lagre dataene som vises i sanntid i arbeidsområdet til MatLAB-minnet, for eksempel ved å bruke simout-blokken (se fig. 13).
2. Kopier de lagrede dataene til arbeidskatalogen, for eksempel:
lagre ("simout_50Hz", "simout");
3. Utvikle m-programmet MatLAB for å vise det arkiverte ADC-signalet til kontrolleren.
Eksempelkode:
Rydd alt
belastning ("simout_50Hz");
size_frame = størrelse (simout.Data, 1);
sampling = d_frame / (størrelse_ramme + 163 * 4); % dt
data_size = størrelse (simout.Data, 1) * størrelse (simout.Data, 2) * størrelse (simout.Data, 3);
% tid = (0: datastørrelse-1) * sampling;
tid =;
for i = 1: lengde (simout.Time)
tid =;
slutt
Adc = uint8 ();
for i = 1: størrelse (simout.Data, 3)
adc =;
slutt
% frame_num = lengde (simout.Time) % eller størrelse (adc, 3) % er 54 bilder
hvis 1 %
figur
plot (tid, adc, "b")
rutenett på
xlabel ("Tid, s");
slutt
Ris. 19. Bilde-for-bilde endring av 50 Hz pickup ved inngangen til ADC-en til Arduino UNO-kontrolleren: 24 bilder à 0,27 sek.
4. Utvikle et m-program for å beregne parameterne til signalet, for eksempel perioden i en gitt ramme.
Eksempelkode:
Rydd alt
belastning ("simout_50Hz");
D_frame = simout.Time (2) -simout.Time (1);
sampling = d_frame / ((256 + 176) * 4); % dt
data_size = størrelse (simout.Data, 1) * størrelse (simout.Data, 2) * størrelse (simout.Data, 3); %<256 x 1 x 54>
% FRAME nummer
i = 5;
tid = (0: 1023) * sampling + simout.Tid (i);
adc = simout.Data (:,:, i) ";
hvis 1 %
figur
plot (tid, adc, "b")
rutenett på
xlabel ("Tid, s");
ylabel ("ADC, bit");
tittel ("8 bit ADC-ramme mot tid");
slutt
% periode
comp_level = 60;
j = 1;
for i = 2: lengde (adc)
if (adc (i)> = comp_level) && (adc (i-1)< comp_level)
cellenummer (j) = i;
j = j + 1;
slutt
slutt
s_period = diff (tid (cellenummer));
Ris. 20. Kontinuerlig og punktvis endring av signalet i den valgte rammen. Tid på 5 bilder: 1,08 ... 1,24 sek. Vektorstørrelse: 1024 byte. Derfor er tiden for én avlesning og skalering av ADC-signalet 0,156 ms.
Ris. 21. Perioden for nettverkshentingen av den 5. rammen: 19,2… 19,4 msek.
Oppgave 4... Bygge et spektrum av et signal i sanntid.
1. For å observere frekvensspekteret til et signal, koble en Fast Fourier Transform (Spectrum Scope: FFT)-blokk fra Simulink> DSP System Toolbox> Sinks-delen av biblioteket til det viste modellsignalet.
Ris. 22. Modell med spektroskop.
Ris. 23. Spekteret til nettverkshentingen. Rammesignalet inkluderer 1024 amplituder og 163x4 null verdier.
2. Velg grunnharmonikken til signalet: 50 Hz. 
Ris. 24. Harmonisk signal ved en frekvens på 50 Hz.
3. Koble Spectrum Scope: FFT-blokken til et uskalert (i tid) signal. 
Ris. 25. Overføring av koblingspunktet til spektrografen. Inngangen er et uskalert signal med en mindre sone med nullverdier på slutten av matrisen (vektor).
4. Konfigurer blokken. Velg typen vist spektrum: Spektrumtype. 
Ris. 26. Parametre til spektrometeret til et uskalert signal på 1024 amplituder.
Oppgave 5... Bygge en kanal for høyhastighetsstrømming og prosessering av 8p-data i sanntid uten å hoppe over data.
1. Skriv et program for Arduino UNO-kontrolleren for å syklisk lese ADC-avlesningene, skalere og overføre 2048 byte med en overskrift til seriekanalen. Programmet skal lese ADC-avlesningene med en konstant frekvens uten avbrudd.
Eksempel program:
const int adc_5 = A5; // ADC-portnummer
Ugyldig oppsett () (
Serial.begin (115200); // bit / s
}
Ugyldig sløyfe () (
for (int i = 0; i< 2048; i++) {
if (i == 0) Serial.print ("A"); // “A” er overskrift
int val = analogRead (adc_5);
byte adc_byte = kart (val, 0, 1023, 0, 255);
Serial.write (adc_byte);
}
}
2. Konfigurer Simulink-modellen (MatLAB) for å motta kontrollerdata. 
Ris. 27. Et eksempel på en modell for å vise en kontinuerlig strøm av data. Rammen inneholder 2048 byte.
3. Still inn simuleringstiden for modellen (Meny> Simulering> Konfigurasjonsparametere> Løser> Fast-trinns størrelse) og syklusen til seriell mottak> blokkeksempeltidsblokk (se fig. 10) over 50 Hz nettverksperioden.
Estimert bildetid i henhold til tabell 1: 254 ms (for 1024 byte) => 508 ms for 2048 byte. I virkeligheten er rammetiden for programmet (der ADC leser og overføringer utføres vekselvis) 375 ms.
Ris. 28. Vector Scope plotterramme. Det er 18,75 perioder med 50 Hz-bølger i rammen. Derfor bør rammetiden være 375ms, og ADC-konverterings-, skalerings- og dataoverføringsperioden: 0,1831ms.
4. I MatLAB-kommandovinduet skriver du inn kommandoen for å danne det 5. rammesignalet.
sgnl =;
5. Plott de første 5 rammene av signalet. 
Ris. 29. Fem rammer med modellinndata.
6. Vurder kvaliteten på rammesømmene. 
Ris. 30. Skjøter av fem rammer. Det er merkbar forvrengning i den første byten i hver ramme. Ved å erstatte de første bytene med gjennomsnittsverdier mellom de nærmeste punktene, kan forvrengningen reduseres betydelig.
7. Koble en spektrumanalysator til inngangssignalet til modellen. Observer spekteret til signalet i sanntid. 
Ris. 31. Modell for visning av spekteret til inngangssignalet (ADC Arduino UNO) i sanntid.
Ris. 32. Spekteret til nettverkshenteren ved inngangen til ADC-en til Arduino-kontrolleren.
8. Koble Time Scope-oscilloskopet fra Simulink> DSP System Toolbox> Sinks-biblioteket til inngangssignalet til modellen. 
Ris. 33. Oscilloskop i modellen for visning av inngangssignalet til Arduino-kontrolleren.
9. Konfigurer oscilloskopet til å vise innholdet i gjeldende ramme og bølgeformfrekvensen. 
Ris. 34. Sette opp oscilloskopet Tidsomfang> Meny> Vis> Egenskaper.
10. Kjør modellen og observer stabiliteten til signalparametrene. 
Ris. 35. Visning av signalet og dets parametere i sanntid på oscilloskop Simulink-modellen.
Den siste versjonen av kanalen Arduino-kontrolleren - MatLAB, sammenlignet med de tidligere versjonene, har følgende fordeler.
kontrollerminne brukes ikke til å akkumulere ADC-data;
en liten ADC-konverteringsklokke med skalering er gitt, som er litt mer enn konverteringsklokken til en ADC med skalering i fravær av overføring;
ingen tidsskalering av signalet er nødvendig i Simulink-modellen;
modellen inneholder færre blokker;
vektorstørrelse og bildetid er praktisk talt ubegrenset.
Oppgave 6.Øk samplingsfrekvensen til ADC-signalet.
Samplingshastigheten til Arduino ADC kan økes til 15 kHz i 10-bit modus og opptil 77 kHz i 8-bit modus ved å erstatte bibliotekfunksjonene med flere raskt alternativ ved hjelp av registrene til mikrokontrolleren.
En brukerfunksjon kan opprettes i *.ino-programmet eller i systemfil kontrolleren
... \ arduino-1.0.6 \ hardware \ arduino \ cores \ arduino \ wiring_analog.c ved å registrere den i
... \ arduino-1.0.6 \ maskinvare \ arduino \ kjerner \ arduino \ Arduino.h
For å bygge en 8-bits høyhastighetskanal Arduino - MatLAB, må du gjøre følgende.
1. Skriv et program for å bestemme tidspunktet for å fylle ADC-matrisen med data og vise resultatet i "Serial Monitor"-vinduet. Størrelsen på matrisen må være stor nok, for eksempel halvparten SRAM-minne... For å øke nøyaktigheten, mål tiden det tar å fylle matrisen flere ganger.
Eksempel program:
ugyldig oppsett () (
Serial.begin (57600); // bit / s
ADCSRA = (1<< ADEN) // Включение АЦП
|(1 << ADPS2); // Установка предделителя преобразователя на 8
ADMUX = (1<< ADLAR) | (1 << REFS0) // Подключение внешнего ИОН
|(1 << MUX2) |(0 << MUX1) |(1 << MUX0); // подключение АЦП A5 == 101
}
Ugyldig sløyfe () (
unsigned long time_start = millis ();
for (int j = 0; j< 100; j++) {
for (int i = 0; i< 1024; i++) {
ADCSRA | = (1<< ADSC); // Запуск преобразования АЦП
mens ((ADCSRA & (1<< ADIF)) == 0);//Ожидание флага окончания преобразования
adc_bytes [i] = ADCH; // Les den mottatte verdien
}
}
unsigned long time_end = millis ();
usignert int dt = time_end - time_start;
Serial.println (dt);
}
Hundre fyllinger av en rekke på 1024 byte ble fullført i 1542 ms.
2. Suppler engangsoverfyllingen av arrayet med ADC-data ved å overføre hele arrayet til den serielle porten med maksimal hastighet.
Eksempel program:
Byte adc_bytes; // Reserver en matrise for ADC-data
Ugyldig oppsett () (
Serial.begin (115200); // bit / s
ADCSRA = (1<< ADEN) // Включение АЦП
|(1 << ADPS2); // Установка предделителя преобразователя на 8
ADMUX = (1<< ADLAR) | (1 << REFS0) // Подключение внешнего ИОН
|(1 << MUX2) |(0 << MUX1) |(1 << MUX0); // подключение АЦП A5 == 101
}
Ugyldig sløyfe () (
for (int i = 0; i< 1024; i++) {
ADCSRA | = (1<< ADSC); // Запуск преобразования АЦП
mens ((ADCSRA & (1<< ADIF)) == 0); //Ожидание флага окончания преобразования
adc_bytes [i] = ADCH; // Les den mottatte verdien
}
// send ADC-data til seriell port
Serial.print ("A"); // "A" er overskrift
for (int i = 0; i< 1024; i++) {
Serial.write (adc_bytes [i]);
}
}
3. I Simulink-modellen (fig. 36) i 0,01542-formatet, skriv den eksperimentelle verdien av skrivetiden til matrisen, nemlig i linjen "Blokkeksempeltid" i blokken "Serielt mottak" og i menylinjen > simulering > konfigurasjonsparametere > størrelse med fast trinn (grunnleggende prøvetid).
Ris. 36. Simulink-modell for mottak og visning av data fra COM-porten.
4. Koble testsignalet til ADC-inngangen. Start Arduino-programmet og deretter Simulink-modellen (MatLAB). Sammenlign de kjente signalparametrene med de observerte signalparametrene. Du kan sjekke driften av banen ved å vise de vekselvis tilkoblede utgangsspenningene til Arduino-kortet: 0V; 3,3V og 5V.
Ris. 37. Visning i sanntid nettverk 50 Hz pickup. Rammen inneholder 1024 punkter. Bildetid 15,42 msek. Samplingshastighet 66 kHz (som 1 / (0,01542_sek / 1024)). Det viste signalet har hull: opptaksprosessen avbrytes ved å overføre en ramme til seriekanalen.
Ris. 38. Sanntidsvisning av sagtannsignalet 0 ... 3,3 V, generert på Teensy 3.1-kontrolleren med en 12-bits DAC og koblet til den sjette ADC (A5) til Arduino-kontrolleren.
Ris. 39. 500 Hz-signal fra Teensy-kontrolleren 3.1. Syklusfeilen (15,42 ms) til Simulink-modellen uten ekstra korreksjon er mindre enn 1 % (som 100 % * (504,72 Hz - 500 Hz) / 500 Hz). Feilen kan reduseres ved å justere RT-syklusen, som vist i trinn 3 i denne oppgaven.
KONTROLLSPØRSMÅL
1. Sammenlign ADC-konverteringsperiodene for de første og siste jobbene.2. Hvorfor anbefales det å ta en prøve på et multiplum av to for å bygge signalspekteret?
3. Hva er ventetiden for streaming av 1024 byte ved 115200 bps med følgende overføringsparametere?
Databiter: 8
Paritet: ingen
Stoppbiter: 1
Strømningskontroll: ingen
Det er ingen hemmelighet at alle mengder i den fysiske verden er analoge. For å måle disse mengdene har folk kommet opp med mange forskjellige enheter. Så for eksempel lar et termometer deg finne ut temperaturen til et stoff, et barometer - gasstrykk, et hygrometer - luftfuktighet. Og ved hjelp av vekter kan du måle kroppsvekten din.
Alle disse enhetene har en skala som vi bruker til å registrere avlesningene deres. La oss vurdere et enkelt eksempel - å bestemme temperaturen ved hjelp av et konvensjonelt termometer. En person løser dette problemet veldig enkelt: vi ser på hvilken av divisjonene som er nærmest væskenivået i termometeret. Verdien som oppnås på denne måten vil være den målte temperaturen. Vi konverterer med andre ord en analog kontinuerlig verdi til en diskret verdi som kan skrives ned på papir ved hjelp av tall.
For å automatisere prosessen med å måle analoge verdier, og tilordne denne oppgaven til elektroniske enheter, har ingeniører laget en spesiell enhet kalt en analog-til-digital-omformer (ADC). Denne enheten lar deg konvertere et analogt signal til en digital kode som er egnet for bruk i en datamaskin.
I robotikk er ADC-er en viktig komponent i en maskins sensorsystem. Akselerometer, gyroskop (gyrotachometer), barometer, magnetometer og til og med et videokamera - alle disse enhetene er koblet til sentralprosessoren ved hjelp av en ADC.
Strukturelt kan ADC plasseres i samme pakke med en mikroprosessor eller mikrokontroller, som i tilfellet med Arduino Uno. Ellers, som alle moderne elektroniske enheter, kan ADC utformes som en separat mikrokrets, for eksempel MCP3008:
Det skal bemerkes at det også er en enhet med en invers funksjon kalt en digital-til-analog-omformer (DAC). Den lar deg konvertere et digitalt signal til analogt. For eksempel, mens du spiller en melodi på en mobiltelefon, konverteres den digitale koden fra en MP3-fil til lyden du hører i hodetelefonene.
For bedre å forstå driften av ADC, trenger vi et interessant problem. Som sådan vil vi prøve å lage en enhet for å måle gjenværende ladning av konvensjonelle AA-batterier - et ekte digitalt voltmeter.
1. Funksjoner for arbeid med ADC
I denne leksjonen vil vi studere driften av ADC ved å bruke Arduino-plattformen. I Arduino Uno-modellen vi bruker, sammen med de vanlige universalpinnene (som vi allerede har koblet til og) er det så mange som seks analoge innganger... I andre versjoner av Arduino kan det være flere slike innganger, for eksempel har Arduino Mega 16 av dem.
På Arduino Uno-kortet er analoge innganger alfanumerisk merket A0, A1,..., A5 (nederst til venstre).
Mens vi jobbet med de samme, ble vi kjent med funksjonen digitallest, som er i stand til å lese et digitalt signal fra en spesifikk kontrollerinngang. Denne funksjonen har en analog versjon analogLes som kan gjøre det samme, men bare for et analogt signal.
resultat = analogRead (pinnenummer);
etter å ha kalt denne funksjonen, vil mikrokontrolleren måle nivået på det analoge signalet ved den spesifiserte kontakten, og lagre resultatet av ADC-operasjonen i "resultat"-variabelen. I dette tilfellet, resultatet av funksjonen analogLes det vil være et tall fra 0 til 1023.
2. Bit ADC
Det skal bemerkes at tallet 1023 dukket opp her av en grunn. Faktum er at hver ADC-enhet har en så viktig parameter som bithet... Jo høyere verdien på denne parameteren er, desto mer nøyaktig fungerer enheten. Anta at vi har en ADC med en kapasitet på 1. Ved å påføre en hvilken som helst spenning fra 0 til 2,5 volt på inngangen vil vi få 0 på utgangen. Enhver spenning fra 2,5 til 5 volt vil gi oss en enhet. Det vil si at en 1-bits ADC bare vil kunne gjenkjenne to spenningsnivåer. Dette kan avbildes grafisk som følger:
En ADC med en bredde på 2 gjenkjenner allerede fire spenningsnivåer:
- 0 til 1,25 er 0;
- fra 1,25 til 2,5 er 1;
- fra 2,5 til 3,75 er 2;
- til slutt er 3,75 til 5 3.
De følgende to bildene viser driften av ADC med 2 og 3 biter:
Arduino Uno har en 10-bits ADC, som betyr at enhver analog inngangsspenning mellom 0 og 5 volt vil bli konvertert til et tall med 1/1024 volt presisjon. Det vil være vanskelig å skildre så mange trinn på grafen. Med denne presisjonen kan en 10-bits ADC registrere inngangsspenningsendringer på så lite som 5 millivolt.
3. Referansespenning
Det er en nyanse som kan forårsake målefeil ved bruk av ADC. Husker du det området fra 0 til 5 volt som enheten fungerer i? Generelt ser dette området annerledes ut:
0 til referansespenning
Denne endringen vil innebære en endring i formelen for beregning av nøyaktigheten til ADC:
nøyaktighet = referansespenning / 1024
Referansespenningen definerer grensen for området som ADC-en skal operere med.
I vårt eksempel vil referansespenningen være lik forsyningsspenningen til Arduino Uno, som ble gitt av USB-porten på datamaskinen. I mitt spesielle tilfelle var denne spenningen 5,02 volt, og jeg kan trygt si at jeg målte batteriladingen med høy nøyaktighet.
Hva om du driver mikrokontrolleren fra en annen kilde? La oss si at du har fire 1,2 Volt NiMh-batterier. Totalt vil de gi 4,8 Volt (selv om de er litt utladet, fordi de i virkeligheten lades opp til 1,4 Volt). Målenøyaktigheten vil være 4,8 / 1024. Dette bør tas med i programmet vårt.
Tenk til slutt på tilfellet når vi driver Arduino Uno med én spenning, og som referanse vil vi sette noe helt annet, for eksempel 3,3 volt. Hva å gjøre? For dette alternativet har Arduino Uno en spesiell Vref-pin. For å løse problemet må vi påføre en spenning på 3,3 volt til denne pinnen, og aktivere bruk av en ekstern referansespenning ved hjelp av funksjonen:
AnalogReference (EKSTERN);
som skal kalles inne i oppsettsfunksjonen til programmet vårt.
Det bør også huskes at resultatet av måling av spenningsverdien ikke kan overskride rekkeviddegrensene. Hvis vi velger 3,3 Volt som referansespenning, og det innkommende signalet vil være med høy spenning, vil vi få en feil spenningsverdi, siden ADC "ikke vet" om tilstedeværelsen av en høyere spenning.
4. Program
Vårt første program som bruker en ADC vil være ekstremt enkelt: hvert sekund vil vi måle den analoge verdien ved inngang A0, og overføre den til den serielle porten.
Int val = 0; void oppsett () (Serial.begin (9600); pinMode (A0, INPUT);) void loop () (val = analogRead (A0); Serial.println (val); forsinkelse (1000);)
Nå laster vi opp programmet til Arduino, og går videre til målingene.
5. Tilkobling
For å måle spenningen på et batteri, må vi koble det til Arduinoen vår med bare to pinner. La oss bruke et 1,5 volt alkalisk batteri som et eksempel.
La oss nå åpne COM-monitorvinduet i Arduino IDE, og se hvilke verdier ADC gir oss:
Hva betyr tallet 314? Husk at en 10-bits ADC deler 0 til 5 volt-området i 1024 deler. Dette betyr at nøyaktigheten til en 10-bits ADC er 5/1024. Når vi kjenner nøyaktigheten, kan vi skrive formelen for å konvertere ADC-avlesningene til volt:
V = (5/1024) * ADC
hvor V er den målte spenningen på batteriet;
ADC er resultatet av analogRead-funksjonen.
La oss erstatte denne formelen i programmet og prøve igjen å måle batteriladningen!
Int val = 0; void oppsett () (Serial.begin (9600); pinMode (A0, INPUT);) void loop () (val = analogRead (A0); Serial.println ((5 / 1024.0) * val); forsinkelse (1000); )
Måleresultat:
Det ser mer ut som sannheten.
6. Utfall
Så vi har behandlet et veldig komplekst og viktig tema i elektronikkens verden. ADC brukes overalt, og i robotikk er denne enheten absolutt uunnværlig. For å forstå verden rundt dem, må roboter på en eller annen måte oversette analoge sensasjoner til tall.
På portalen vår kan du finne flere leksjoner, hvor implementeringen avhenger av forståelsen av ADC-emnet: kapasitiv sensor, potensiometer og analog joystick. Og i forbindelse med et annet viktig emne - PWM, vil bruken av en ADC tillate deg å lage en dimmer for en LED-lampe og en motorkontroller. Lykke til!
