Arduino gebaseerd echt

De oscilloscoop is een van de belangrijkste gereedschappen die u op de werkbank van elke elektronica-ingenieur of -fabrikant vindt. Het wordt voornamelijk gebruikt voor het bekijken van golfvormen en het bepalen van spanningsniveaus, frequentie, ruis en andere parameters van signalen die aan de ingang worden toegepast en die in de loop van de tijd kunnen veranderen. Het wordt ook gebruikt door ontwikkelaars van embedded software voor het debuggen van codes en technici voor het oplossen van problemen met elektronische apparaten tijdens reparatie. Deze redenen maken de oscilloscoop tot een onmisbaar stuk gereedschap voor elke ingenieur. Het enige probleem is dat ze erg duur kunnen zijn. Oscilloscopen die de meest elementaire functies met de minste nauwkeurigheid uitvoeren, kunnen wel $ 45 tot $ 100 kosten, terwijl de meer geavanceerde en efficiënte oscilloscopen meer dan $ 150 hebben gekost. Vandaag zal ik demonstreren hoe je de Arduino gebruikten een software, die zal worden ontwikkeld met mijn favoriete programmeertaal Python, om een goedkope 4-kanaals Arduino-oscilloscoop te bouwen die de taken kan uitvoeren waarvoor sommige van de goedkope oscilloscopen worden ingezet, zoals het weergeven van golfvormen en het bepalen van spanningsniveaus voor signalen.

Hoe het werkt

Dit project bestaat uit twee delen;

De dataconverter
De plotter

Oscilloscopen omvatten over het algemeen de visuele weergave van een analoog signaal dat op het ingangskanaal wordt toegepast. Om dit te bereiken, moeten we eerst het signaal van analoog naar digitaal converteren en vervolgens de gegevens plotten. Voor de conversie maken we gebruik van de ADC (analoog naar digitaal converter) op de atmega328p-microcontroller die door de Arduino wordt gebruikt om de analoge gegevens aan de signaalingang om te zetten in een digitaal signaal. Na de conversie wordt de waarde per tijd via UART van de Arduino naar de pc gestuurd waar de plotter-software die met python zal worden ontwikkeld, de inkomende gegevensstroom omzet in een golfvorm door elke gegevens tegen de tijd uit te zetten.

Vereiste componenten

De volgende componenten zijn vereist om dit project te bouwen;

Arduino Uno (elk van de andere borden kan worden gebruikt)
Breadboard
10k weerstand (1)
LDR (1)
Doorverbindingsdraden

Vereiste software

Arduino IDE
Python
Python-bibliotheken: Pyserial, Matplotlib, Drawnow

Schema's

Het schema voor de Arduino-oscilloscoop is eenvoudig. Het enige wat we hoeven te doen is het te onderzoeken signaal verbinden met de gespecificeerde analoge pin van de Arduino. Echter, gebruiken we de LDR in een eenvoudige spanningsdeler setup het genereren te onderzoeken, zodat de opgewekte golfvorm het spanningsniveau beschrijven op basis van de intensiteit van licht rond de LDR.

Sluit de componenten aan zoals weergegeven in het onderstaande schema;

Na verbinding zou de installatie de onderstaande afbeelding moeten zien.

Nu alle verbindingen zijn voltooid, kunnen we doorgaan met het schrijven van de code.

Arduino Osclloscope-code

We zullen codes schrijven voor elk van de twee secties. Voor de Plotter zoals eerder vermeld, zullen we een python-script schrijven dat de gegevens van de Arduino accepteert via UART en Plots, terwijl we voor de converter een Arduino-sketch schrijven die de gegevens van de ADC opneemt en converteert naar spanningsniveaus die naar de plotter worden gestuurd.

Python (plotter) script

Omdat de python-code complexer is, zullen we ermee beginnen.

We zullen een aantal bibliotheken gebruiken, waaronder; drawnow, Matplotlib en Pyserial met het python-script zoals eerder vermeld. Met Pyserial kunnen we een python-script maken dat via de seriële poort kan communiceren, Matplotlib geeft ons de mogelijkheid om plots te genereren op basis van de gegevens die via de seriële poort worden ontvangen, en drawnow biedt ons een middel om de plot in realtime bij te werken.

Er zijn verschillende manieren om deze pakketten op uw pc te installeren, de gemakkelijkste is via pip . Pip kan worden geïnstalleerd via de opdrachtregel op een Windows- of Linux-machine. PIP is verpakt met python3, dus ik zal je adviseren python3 te installeren en het vakje aan te vinken over het toevoegen van python aan pad. Als je problemen ondervindt bij het installeren van pip, bekijk dan de officiële Python-website voor tips.

Met pip geïnstalleerd, kunnen we nu de andere bibliotheken installeren die we nodig hebben.

Open de opdrachtprompt voor Windows-gebruikers, terminal voor linux-gebruikers en voer het volgende in;

pip pyserial installeren

Nu dit is gebeurd, installeert u matplotlib met;

pip installeer matplotlib

Drawnow wordt soms naast matplotlib geïnstalleerd, maar voor de zekerheid, run;

pip install drawnow

Nu de installatie is voltooid, zijn we nu klaar om het python-script te schrijven.

Het python-script voor dit project is vergelijkbaar met het script dat ik schreef voor de Raspberry Pi-gebaseerde oscilloscoop.

We beginnen met het importeren van alle bibliotheken die nodig zijn voor de code;

importeer tijd import matplotlib.pyplot als plt uit drawnow import * import pyserial

Vervolgens maken en initialiseren we de variabelen die tijdens de code zullen worden gebruikt. De array val wordt gebruikt om de gegevens op te slaan die zijn ontvangen van de seriële poort en cnt wordt gebruikt om te tellen. Gegevens op locatie 0 worden verwijderd na elke 50 datatellingen. Dit wordt gedaan om ervoor te zorgen dat de gegevens die op de oscilloscoop worden weergegeven, behouden blijven.

val = cnt = 0

Vervolgens maken we het seriële poortobject waarmee de Arduino zal communiceren met ons python-script. Zorg ervoor dat de hieronder gespecificeerde com-poort dezelfde com-poort is waarmee uw Arduino-bord communiceert met de IDE. De hierboven gebruikte baudrate van 115200 werd gebruikt om een snelle communicatie met de Arduino te garanderen. Om fouten te voorkomen, moet de seriële poort van de Arduino ook zijn ingeschakeld om met deze baudrate te communiceren.

port = serial.Serial ('COM4', 115200, time-out = 0,5)

Vervolgens maken we de plot interactief met;

plt.ion ()

we moeten een functie maken om de plot te genereren op basis van de ontvangen gegevens, waarbij we de verwachte boven- en minimumlimiet creëren, in dit geval 1023 op basis van de resolutie van de ADC van de Arduino. We stellen ook de titel in, labelen elke as en voegen een legenda toe om de plot gemakkelijk te identificeren.

#create the figure function def makeFig (): plt.ylim (-1023,1023) plt.title ('Osciloscope') plt.grid (True) plt.ylabel ('ADC outputs') plt.plot (val, 'ro - ', label =' Kanaal 0 ') plt.legend (loc =' rechtsonder ')

Nu dit klaar is, zijn we nu klaar om de hoofdlus te schrijven die de gegevens van de seriële poort, indien beschikbaar, haalt en deze plot. Om te synchroniseren met de Arduino, worden handshake-gegevens door het python-script naar de Arduino gestuurd om aan te geven dat het klaar is om gegevens te lezen. Wanneer de Arduino de handshake-gegevens ontvangt, antwoordt deze met gegevens van de ADC. Zonder deze handdruk kunnen we de gegevens niet in realtime plotten.

while (True): port.write (b's ') #handshake met Arduino if (port.inWaiting ()): # if de arduino antwoordt value = port.readline () # lees het antwoord print (waarde) #print zodat we kunnen monitor it number = int (waarde) # converteer ontvangen data naar integer print ('Channel 0: {0}'. format (number)) # Slaap voor een halve seconde. time.sleep (0.01) val.append (int (nummer)) drawnow (makeFig) #update plot om nieuwe gegevensinvoer weer te geven plt.pause (.000001) cnt = cnt + 1 if (cnt> 50): val.pop (0) #houd de plot vers door de gegevens op positie 0 te verwijderen

De volledige python-code voor de arduino-oscilloscoop wordt aan het einde van dit artikel hieronder weergegeven.

Arduino-code

De tweede code is de Arduino-schets om de gegevens te verkrijgen die het signaal van de ADC vertegenwoordigen, en wacht vervolgens op het ontvangen van het handshakesignaal van de plotter-software. Zodra het het handshake-signaal ontvangt, stuurt het de verkregen gegevens via UART naar de plotter-software.

We beginnen met het declareren van de pin van de analoge pin van de Arduino waarop het signaal zal worden toegepast.

int sensorpin = A0;

Vervolgens initialiseren en starten we seriële communicatie met een baudrate van 115200

void setup () { // initialiseer seriële communicatie met 115200 bits per seconde om overeen te komen met die van het python-script: Serial.begin (115200); }

Ten slotte de functie voidloop () die het lezen van de gegevens afhandelt en de gegevens serieel naar de plotter verzendt.

void loop () { // lees de invoer op analoge pin 0: float sensorValue = analogRead (sensorpin); bytegegevens = Serial.read (); if (data == 's') { Serial.println (sensorValue); vertraging (10); // vertraging tussen leesbewerkingen voor stabiliteit } }

De volledige Arduino-oscilloscoopcode wordt hieronder gegeven, evenals aan het einde van dit artikel hieronder.

int sensorpin = A0; void setup () { // initialiseer seriële communicatie met 115200 bits per seconde om overeen te komen met die van het python-script: Serial.begin (115200); } void loop () { // lees de invoer op analoge pin 0: ################################## ##################### float sensorValue = analogRead (sensorpin); bytegegevens = Serial.read (); if (data == 's') { Serial.println (sensorValue); vertraging (10); // vertraging tussen leesbewerkingen voor stabiliteit } }

Arduino-oscilloscoop in actie

Upload de code naar de Arduino-setup en voer het python-script uit. Je zou de gegevens moeten zien binnenkomen via de python-opdrachtregel en de plot varieert met de lichtintensiteit zoals weergegeven in de onderstaande afbeelding.

Dus dit is hoe Arduino kan worden gebruikt als oscilloscoop, het kan ook worden gemaakt met Raspberry Pi, bekijk hier de volledige tutorial over op Raspberry Pi gebaseerde oscilloscoop.