Teken iets op uw oscilloscoop

Over dit project

De R-2R DAC

Een van de eenvoudigste implementaties van een digitaal naar analoog omzetter kan worden bereikt door een R-2R ladder-DAC te ontwerpen. Dit type DAC heeft alleen weerstanden nodig om te werken, waardoor het een zeer beginnersvriendelijke DAC is.

Het basisprincipe van dit type DAC is dat je slechts twee waarden nodig hebt voor weerstanden. R en 2R. Vervolgens kunt u ze instellen zoals weergegeven in het onderstaande schema.

R kan van alles zijn, zolang elk voorkomen van R in het schema dezelfde waarde heeft.

Als we bijvoorbeeld R =1k kiezen, dan is 2R slechts twee keer het bedrag. In dit geval 2R =2k. U kunt dus slechts 1k- en 2k-weerstanden gebruiken.

Als je R=3,3K hebt gebruikt, dan is 2R =6,6k enzovoort. Als je voor alles dezelfde waarde van weerstanden wilt gebruiken, dan zou je om 2R te krijgen gewoon twee weerstanden in serie moeten zetten en dat zou je aantal componenten verhogen.

Het aantal bits wordt bepaald door het aantal takken van 2R dat je uitsteekt. In dit project zullen we een 8-bit R-2R en een 6-bit R-2R gebruiken voor de Arduino Uno of Nano. Als u een andere microcontroller gebruikt waarvan u weet dat deze een volledige poortmanipulatie van ten minste 8-bits ondersteunt, zoals de STM32 "blue pill" en "black pill", dan kunt u gewoon twee 8-bits DAC's gebruiken.

Nevenopmerking over DAC IC's:

Dit project is gericht op het gebruik van een R-2R DAC, maar je kunt gerust een DAC-IC gebruiken om iets soortgelijks te bereiken. Als je een DAC-IC gaat gebruiken, raad ik je aan er een te gebruiken die een snel communicatieprotocol zoals SPI ondersteunt, omdat I2C te traag zal zijn om een ​​gedetailleerd beeld te tekenen. Ik zal in dit bericht niet bespreken hoe je een DAC-IC gebruikt, maar misschien in een toekomstig bericht. De R-2R nog steeds mijn voorkeursmethode omdat het afbeeldingen met meer detail kan weergeven.

Poortmanipulatie

We zullen parallelle poortmanipulatie van onze microcontroller gebruiken. De reden hiervoor is omdat het een hogere uitvoersnelheid mogelijk maakt en de code ook eenvoudig houdt. U kunt meer details over de poortregisters voor Arduino lezen via deze link.

De Arduino Uno en Nano hebben de ATmega328p-microcontroller. Deze microcontroller deelt dezelfde pin-mapping met de Atmega168:

De poortpinnen en bits worden aangegeven met hun label PXN, waarbij X de poortletter is en N het bitnummer.

Voorbeeld:PB1 is voor POORT B ​​bit 1. Op dezelfde manier is PC5 voor PORT C bit 5.

Als we de pinnen inspecteren, zien we dat de microcontroller poorten B, C en D heeft. Door terug te gaan naar de Arduino-referentie kunnen we zien welke poorten kunnen worden geschreven of gelezen van of beide. In onze applicatie geven we alleen om schrijven.

In de documentatie staat dat PORTD lezen/schrijven is en is toegewezen aan digitale pinnen 0 tot 7. Dit geeft ons volledige 8-bits van de poorten om naar te schrijven.

Vervolgens hebben we PORTB die, zoals vermeld, is toegewezen aan digitale pinnen 8-13. Er wordt een aanvullende verklaring afgelegd waarin staat dat 6&7, die de volledige 8-bits zouden voltooien, niet toegankelijk zijn. Deze poort kan alleen worden gebruikt om 6-bits te schrijven.

Hetzelfde geldt voor PORTC. Het is toegewezen aan analoge pinnen 0-5, maar twee pinnen zijn ook gereserveerd, waardoor we slechts 6 bits hoeven te schrijven.

Vanwege deze beperkingen zullen we een combinatie moeten gebruiken van een 8-bits DAC voor PORTD en een 6-bits DAC voor PORTC of PORTB.

We zullen PORTD en PORTB gebruiken en nu kunnen we beginnen met het bedraden van de DAC's naar de pinnen.

Als je wat visuele hulp nodig hebt bij het monteren, dit is hoe ik beide R-2R's in het breadboard heb gemonteerd. Merk op dat ik twee R-2R's heb gebruikt sinds ik het aan het testen was op mijn STM32 "zwarte pil". Ik heb twee jumperdraden uitgestoken zodat ik mijn oscilloscoop-sondes erop kon aansluiten en ook een aardingsdraad aan de zijkant. Ik heb alle 10k-weerstanden gebruikt, dus voor mijn 2R heb ik twee 10k-weerstanden in serie gezet.

Hier is een schonere breadboard-configuratie met Tinkercad. Ik heb de uitgangen gemarkeerd met X en Y, omdat onze oscilloscoop-sondes daarop zijn aangesloten. Als je meer hulp nodig hebt bij de installatie, zal ik schema's geven van de R-2R-ladders die allemaal bestaan ​​uit dezelfde weerstandswaarden en een andere met twee waarden.

Zorg ervoor dat u uw terrein controleert! Elke keer dat ik deze opstelling assembleer, vergeet ik het vaak. Controleer ook of je geen gaten hebt achtergelaten zonder verbindingen.

ArduinoCode

Nu is het tijd voor de Arduino-schets.

Eerst moeten we onze poorten instellen als uitgangen. Van de Arduino-referentie over poortmanipulatie. We kunnen zien hoe we de poorten kunnen instellen:

In principe zal een waarde van 1 voor de bit het instellen als uitvoer en een waarde van 0 zal het instellen als invoer. Voor PORTD kunnen we direct schrijven omdat alle bits toegankelijk zijn. Houd er voor PORTB rekening mee dat bits 6 en 7 niet bruikbaar zijn, omdat ze naar het kristal verwijzen. Het is een goede gewoonte om bitsgewijze OR te gebruiken met een waarde van 0 om te voorkomen dat bits worden gewijzigd die niet worden ingesteld.

In onze setup-lus is dit de code:

De code wordt bijgevoegd om te downloaden, dus maak je geen zorgen over het met de hand typen.

De for-lus onder de configuraties wijst eenvoudigweg de waarden voor de 6-bits poort opnieuw toe. Deze waarden komen uit een lijst met waarden van 8-bits bereik. Om opnieuw toe te wijzen naar 6-bits, is onze maximale waarde 2 ^ 6-1, wat 63 is. We brengen een bereik van 0 tot 2 ^ 8-1 in kaart, wat 255 is. De reden dat we opnieuw toewijzen in de Arduino-code is omdat onze handplotter-tool zal de x- en y-punten uitvoeren in termen van 8-bits. We kunnen het in beide codes wijzigen, maar het is beter om het op de gebruikte microcontroller te wijzigen.

In principe hebben we wat vertraging nodig, afhankelijk van de oscilloscoop. Ik vond dat voor de mijne 1 prima is. Sterker nog, de vertraging helemaal weglaten is ook prima. Voor punten wordt het automatisch gegenereerd door onze handplotter, dus je kunt het nummer gewoon kopiëren en plakken, maar in feite is dit hoeveel punten er zijn om te plotten, zodat de itererende variabele er doorheen kan. Hoe dan ook, hier is de volledige code:

De arrays x_points en y_points zijn voor jou verschillend elke keer dat je iets tekent en worden automatisch gegenereerd met onze tool.

Nevenopmerking over snelle PWM:

Als u een gevorderde gebruiker van microcontrollers bent, realiseert u zich misschien dat als u zich zorgen maakt over snelheid, misschien kan hetzelfde worden bereikt door snelle PWM en het wijzigen van klokregisters. Voer vervolgens de PWM-uitgangen naar een laagdoorlaatfilter om een ​​analoge spanning te krijgen die het aantal pinnen zou verminderen. Ik heb beide methoden geprobeerd en dit resulteert nog steeds in een betere ondersteuning voor afbeeldingen met meer detail. In ieder geval in de Arduino Uno

Tekengereedschap

Ik heb deze tool in Python 3 gemaakt met tkinter. Als je tkinter niet hebt geïnstalleerd, installeer het dan met pip.

pip install tk 

De code wordt gewoon bijgevoegd, maar in feite registreert het de coördinaat op het venster waar uw cursor is geklikt. Probeer het formaat van het venster niet te wijzigen, omdat dit de resolutie zal veranderen. Als u nauwkeuriger wilt zijn, gebruikt u het vergrootglas in Windows. Het venster is gebaseerd op 255x255, aangezien dat de maximale waarden van onze bitbereiken zijn. Natuurlijk wordt een van de dimensies toegewezen aan 6-bits als je een Arduino UNO gebruikt.

Gebruik dit formaat om de tool aan te roepen

python drawlog.py> arduino_list.txt 

Hiermee wordt een.txt-bestand gemaakt met de naam arduino_list.txt met de Arduino-lijst voor x_points, y_points en NUM_POINTS voor u gegenereerd, klaar om te kopiëren en in uw code te plakken.

Zo ziet het.txt-bestand er bijvoorbeeld uit als u het opent. Je hoeft alleen die regels in de code te vervangen.

Hier is hoe het eruit ziet als het eenmaal is geopend. Van daaruit kun je alles tekenen.

Ik heb de volgende afbeelding gemaakt om het uit te testen. De code wordt gegenereerd bij het sluiten van het venster.

En na het uploaden van de code op de Arduino zag het er zo uit in de X-Y-modus.

BELANGRIJK:

Als je een compilatiefout tegenkomt die over geheugen praat, komt dit door het lage geheugen dat beschikbaar is in de Arduino UNO. Dat betekent dat u een minder gedetailleerde afbeelding moet tekenen. Ik denk dat het maximale aantal punten ongeveer 400 was, maar het kunnen meer zijn. Als u een STM32 "Blauwe pil" of "zwarte pil" gebruikt, is dit aantal meer dan 4.000.

Oscilloscoop X-Y-modus

De oscilloscoop moet in de x-y-modus staan. 8-bit R-2R DAC-uitgang (PORTD) wordt aangesloten op kanaal 1 en 6-bit R-2R DAC (PORTB) wordt aangesloten op kanaal 2. Van daaruit kunt u deze aanpassen met de knoppen totdat u een afbeelding ziet.

Dat is het! Als je vragen hebt, stel ze gerust. Als je het bovendien wilt uitproberen op een blauwe pil of zwarte pil, dan is hier de link naar mijn GitHub-pagina met wat voorbeeldcode

Hier zijn enkele afbeeldingen die ik heb geplot.

Voel je vrij om de jouwe te delen!!!

Bewerken:

Belangrijke details voor geheugenbeheer

Zoals Tim al zei in de reacties

• In je Arduino-code is je iterator over de punten, t, een "byte"-type, dus ondersteunt maximaal 255 punten. Waarom maak je er geen "int" van?
• Uw plottercode voert "const unsigned long" uit voor x_points en y_points - dat zal niet werken als u later y-points wijzigt. En waarom niet gewoon "byte" gebruiken om geheugen te besparen?

Houd rekening met de hardwarebeperkingen die u gebruikt. Voor de Arduino Uno is het beter om byte te gebruiken, maar als je een STM32 of zelfs ESP32 gebruikt, heb je meer punten om te plotten. Bedankt allemaal voor jullie feedback.

Timster :

Ik heb een manier gevonden om het aantal ondersteunde punten op een UNO enorm te vergroten - verplaats ze naar de opslagruimte voor programma's. U kunt dit doen met de PROGMEM modificator. Zo kun je zo'n 15.000 punten sparen!

Declareer de arrays dus als volgt:

const int NUM_POINTS =...
const byte x_points[NUM_POINTS] PROGMEM ={...
const byte y_points[NUM_POINTS] PROGMEM ={... 

Voer de wijziging van de y_points in de setup-functie niet uit (d.w.z. verwijder de for lus daar). Voer in plaats daarvan een beetje shift in loop-functie uit.

U hebt ook een speciaal commando nodig om gegevens uit het programmageheugen te lezen (pgm_read_byte_near). Dus de for-lus in de void loop() ziet eruit als:

for (int t=0; t  { 
 PORTD =pgm_read_byte_near(x_points + t);
 PORTB =pgm_read_byte_near( y_points + t)>> 2;
 delayMicroseconds(FIGURE_DELAY);
 } 

Dan is het mogelijk om één afbeelding met hoge resolutie of meerdere kleinere afbeeldingen op te slaan en ertussen te wisselen 😃

const byte FIGURE_DELAY =1; // traceer vertraging in de VS. pas indien nodigconst aan int NUM_POINTS =87;// aantal XY-punten in figuur// x- en y-coördinaten om byte x_points [NUM_POINTS] ={106,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91 te plotten , 90,90,89,88,87,87,87,86,86,86,86,87,89,90,91,93,95,97,99,101,102,102,104,104,105,105,106,106,106,106,106,106,108,109,110,112,113,115,117,119,121,122,123,123,124,124,124,124,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,110,109,109,109,108,107,107}; byte y_points [NUM_POINTS] ={78,80 , 81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,98,99,100,101,103,105,106,108,110,112,113,113,114,115,115,115,115,115,115,114,112,112,110,109,107,106,106,108,110,112,114,114,115,116,116,117,117,117,117,117,116,115,113,112,110,108,106,104,103,102,100,99,98,97,96,95,94,93 ,92,91,90,89,87,86,84,82,81,80,78};void setup(){ // initialiseer poort D en B voor het schrijven van DDRD =B11111111; DDRB =B00111111; byte t; for (t=0; t  
PlottoolPython 
 Tekentool om punten te exporteren naar plot
import tkinter as tkX =[]Y =[]lastx, lasty =0, 0# xy en addLine zijn alleen voor grafische doeleinden# on_move_press is degene die degene in de lijst logt en repareert Ydef xy(event):# logt coördinaten wanneer met muis wordt geklikt global lastx, lasty lastx, lasty =event.x, event.ydef addLine(event):# trekt lijn van oud punt naar nieuw punt global lastx, lasty canvas.create_line ((lastx, lasty, event.x, event.y)) # dit maakt het nieuwe startpunt van de tekening lastx, lasty =event.x, event.y# logs geklikt coördinaat op listdef on_move_press( event):curX, curY =(event.x, event.y) curY=255-curY # aangezien tkinter verschillende coördinaten gebruikt X.append(str(curX)) Y.append(str(curY))# instelling nodig voor windowroot =tk.Tk( )root.geometry("255x255")root.columnconfigure(0, weight=1)root.rowconfigure(0, weight=1)canvas =tk.Canvas(root)canvas.grid(column=0, row=0, sticky =(tk.N, tk.W, tk.E, tk.S))# bind de linkermuisknop en sleep naar functies en start loopcanvas.bind("", xy)canvas.bind("", addLine)root.bind("",on_move_press)root.mainloop()# verwijder elke 2e invoer om punten te verminderen en verhoog traceerverversing voor i in bereik(1,int(len(X)/2)):X.pop(i) Y.pop(i)print("const int NUM_POINTS =%s;" % str(len(X) ))print("const unsigned long x_points[NUM_POINTS] ={%s};" % ','.join(X))print("const unsigned long y_points[NUM_POINTS] ={%s};" % ',' .join(Y))#call python drawlog.py> arduino_list.txt
  
 
 Schema's