Byg din egen funktionsgenerator med arduino og ad9833 dds funktionsgenerator modul

Hvis du er en elektronisk entusiast som mig, der ønsker at finjustere med forskellige elektroniske kredsløb, bliver det undertiden obligatorisk at have en anstændig funktionsgenerator. Men at eje en er et problem, fordi sådan grundlæggende udstyr kan koste en formue. At bygge dit eget testudstyr er ikke kun billigere, men også en fantastisk måde at forbedre din viden på.

Så i denne artikel skal vi bygge en simpel signalgenerator med Arduino og AD9833 DDS-funktionsgeneratormodul, som kan producere sinus-, firkant- og trekantbølger med en maksimal frekvens på 12 MHz ved udgangen. Og endelig skal vi teste outputfrekvensen ved hjælp af vores oscilloskop.

Vi har tidligere bygget en Simple Sine Wave Generator, en Square Wave Generator og en Triangle Wave Generator ved hjælp af basale analoge kredsløb. Du kan tjekke dem ud, hvis du leder efter nogle grundlæggende Waveform Generator Circuits. Hvis du også vil bygge en billigere Arduino-funktionsgenerator uden at bruge AD9833-modulet, kan du tjekke DIY Arduino Waveform Generator Project.

Hvad er en DDS-funktionsgenerator?

Som navnet antyder, er en funktionsgenerator en enhed, der kan udsende en bestemt bølgeform med en bestemt frekvens ved indstilling. Overvej for eksempel, at du har et LC-filter, som du vil teste dit outputfrekvensrespons for, det kan du nemt gøre ved hjælp af en funktionsgenerator. Alt hvad du skal gøre er at indstille den ønskede udgangsfrekvens og bølgeform, så kan du skrue den ned eller op for at teste svaret. Dette var kun et eksempel, du kan gøre flere ting med det, når listen fortsætter.

DDS står for Direct Digital Synthesis. Det er en type bølgeformgenerator, der bruger digitale til analoge konvertere (DAC) til at opbygge et signal fra bunden. Denne metode bruges specifikt til at generere en sinusbølge. Men den IC, vi bruger, kan producere firkantede eller trekantede bølgesignaler. Funktionerne, der skete inde i en DDS-chip, er digitale, så den kan skifte frekvens meget hurtigt, eller den kan skifte fra et signal til et andet meget hurtigt. Denne enhed har en fin frekvensopløsning med et bredt frekvensspektrum.

Forstå arbejdet med AD9833 funktionsgenerator IC

Kernen i vores projekt er AD9833 Programmable Waveform Generator IC, som er designet og udviklet af analoge enheder. Det er en laveffekt, programmerbar bølgeformgenerator stand til at producere sinus, trekantet, og firkantet bølge med en frekvens på 12 MHz maksimum. Det er en meget unik IC, der er i stand til at ændre outputfrekvensen og fasen med blot et softwareprogram. Det har en 3-leder SPI-grænseflade, hvorfor kommunikation med denne IC bliver meget enkel og let. Det funktionelle blokdiagram for denne IC er vist nedenfor.

Arbejdet med denne IC er meget enkel. Hvis vi ser på det funktionelle blokdiagram ovenfor, vil vi observere, at vi har en faseakkumulator, hvis opgave er at gemme alle mulige digitale værdier for en sinusbølge startende fra 0 til 2π. Dernæst har vi SIN ROM, hvis opgave er at konvertere faseinformationen, som senere kan kortlægges direkte til amplitude. SIN ROM bruger den digitale faseinformation som en adresse til en opslagstabel og konverterer faseinformationen til amplitude. Og endelig har vi en 10-bit digital til analog konverter, hvis opgave er at modtage de digitale data fra SIN ROM og konvertere dem til de tilsvarende analoge spændinger, det er hvad vi får fra udgangen. Ved udgangen har vi også en switch, som vi kan tænde eller slukke med bare en lille softwarekode. Vi vil tale om det senere i artiklen.De detaljer, du ser ovenfor, er en meget afskåret version af, hvad der sker inde i IC, og de fleste af de detaljer, du ser ovenfor, er hentet fra AD9833-databladet, du kan også tjekke det ud for yderligere information.

Komponenter, der kræves for at opbygge den AD9833-baserede funktionsgenerator

Komponenterne, der kræves for at opbygge den AD9833-baserede funktionsgenerator, er anført nedenfor, vi designet dette kredsløb med meget generiske komponenter, hvilket gør replikeringsprocessen meget let.

Arduino Nano - 1
AD9833 DDS-funktionsgenerator - 1
128 X 64 OLED-skærm - 1
Generisk Rotary Encoder - 1
DC Barrel Jack - 1
LM7809 Spændingsregulator - 1
470uF kondensator - 1
220uF kondensator - 1
104pF kondensator - 1
10K modstand - 6
Taktile afbrydere - 4
Skrueterminal 5.04mm - 1
Hoved til kvinder - 1
12V strømkilde - 1

AD9833-baseret funktionsgenerator - skematisk diagram

Det komplette kredsløbsdiagram for AD9833 og Arduino-baseret funktionsgenerator er vist nedenfor.

Vi skal bruge AD9833 med Arduino til at generere vores ønskede frekvens. Og i dette afsnit forklarer vi alle detaljer ved hjælp af skemaet; lad mig give dig en kort oversigt over, hvad der sker med kredsløbet. Lad os starte med AD9833-modulet. AD9833-modulet er funktionsgeneratmodulet, og det er forbundet med Arduino i henhold til skematisk. For at drive kredsløbet bruger vi en LM7809 spændingsregulator IC med en anstændig afkoblingskondensator, dette er nødvendigt, fordi forsyningsstøj kan interferere med udgangssignalet, hvilket resulterer i uønsket output. Som altid fungerer Arduino som hjernen til dette projekt. For at vise den indstillede frekvens og anden værdifuld information har vi tilsluttet et 128 X 64 OLED-skærmmodul. For at ændre frekvensområdet bruger vi tre kontakter. Den første indstiller frekvensen til Hz, den anden indstiller udgangsfrekvensen til KHz, og den tredje indstiller frekvensen til MHz, vi har også en anden knap, der kan bruges til at aktivere eller deaktivere output. Endelig har vi drejekoderen,og vi er nødt til at vedhæfte en pull-up-modstand med det, ellers fungerer disse switches ikke, fordi vi kontrollerer knappen tryk på begivenheden på pooling-metoden. Drejekoderen bruges til at ændre frekvensen, og den taktile afbryder inde i drejekoderen bruges til at vælge den indstillede bølgeform.

AD9833-baseret funktionsgenerator - Arduino-kode

Den komplette kode, der bruges i dette projekt, kan findes nederst på denne side. Når du har tilføjet de nødvendige headerfiler og kildefiler, skal du kunne kompilere Arduino-filen direkte. Du kan downloade ad9833 Arduino-biblioteket og andre biblioteker fra nedenstående link, ellers kan du bruge metoden Board Manager til at installere biblioteket.

Download AD9833-biblioteket af Bill Williams
Download SSD1306 OLED-bibliotek af Adafruit
Download Adafruit GFX-bibliotek

Forklaringen på koden i ino. filen er som følger. Først starter vi med at inkludere alle de krævede biblioteker. Biblioteket til AD9833 DDS-modulet efterfølges først af biblioteket til OLED, og matematikbiblioteket kræves til nogle af vores beregninger.

#include // LIbrary for AD9833 Module #include // Wire Library for OLED #include // Support Library for OLED #include // OLED library #include // Matematikbibliotek

Dernæst definerer vi alle de nødvendige input- og outputstifter til knapper, switch, roterende encoder og OLED'er.

#define SCREEN_WIDATA_PINH 128 // OLED-skærm Bredde i pixels #definer SCREEN_HEIGHT 64 // OLED displayhøjde, i pixels #definer SET_FREQUENCY_HZ A2 // Trykknap For at indstille frekvens i Hz #definer SET_FREQUENCY_KHZ A3 // Trykknap for at indstille frekvens i Khz_DK A6 // Pushbutton For at indstille frekvens i Mhz #define ENABLE_DISABLE_OUTPUT_PIN A7 // Pushbutton To Enable / Disable the Output #define FNC_PIN 4 // Fsync Required by the AD9833 Module #define CLK_PIN 8 // Clock Pin of the Encoder #define DATA_P / Datapind på koderen #definer BTN_PIN 9 // Intern trykknap på koderen

Derefter definerer vi alle de nødvendige variabler, der kræves i denne kode. Først skal vi definere en heltalsvariabel tæller, som vil gemme den roterende enkoder værdi. De næste to variabler clockPin og clockPinState gemmer den pin-statue, der kræves for at forstå kodningsretningen. Vi har en tid variabel, der holder de aktuelle timer-counter værdier, denne variabel bruges til knap debouncing. Dernæst har vi et usigneret langt variabelt modulFrekvens, der indeholder den beregnede frekvens, der skal anvendes. Dernæst har vi forsinkelsen. Denne forsinkelse kan justeres efter behov. Dernæst har vi tre boolske variabler set_frequency_hz,set_frequency_Khz og set_frequency_Mhz disse tre variabler bruges til at bestemme den aktuelle indstilling af modulet. Vi vil tale om det mere detaljeret senere i artiklen. Dernæst har vi variablen, der gemmer status for outputbølgeformen, standardudgangsbølgeformen er en sinusbølge. Og til sidst har vi encoder_btn_count- variablen, der indeholder encoder- knaptællingen, der bruges til at indstille outputbølgeformen.

int tæller = 1; // Denne tællerværdi vil stige eller falde, hvis når drejekoderen drejes int clockPin; // Pladsholder til pin-status, der bruges af den roterende encoder int clockPinState; // Pladsholder til pin-status brugt af den roterende encoder usigneret lang tid = 0; // Bruges til afvisning af usigneret langt modulFrequency; // bruges til at indstille udgangsfrekvens lang debounce = 220; // Afvis forsinkelse bool btn_state; // bruges til at aktivere deaktivering af output af AD98333-modul bool set_frequency_hz = 1; // Defultfrekvens for AD9833-modulet bool set_frequency_khz; bool sæt_frekvens_mhz; String waveSelect = "SIN"; // Startbølgeform af modulet int encoder_btn_count = 0; // bruges til at kontrollere koderknappen tryk på Næste, vi har vores to objekter, det ene er til OLED-skærmen, og et andet er til AD9833-modulet.Adafruit_SSD1306 skærm (SCREEN_WIDATA_PINH, SCREEN_HEIGHT, & Wire, -1); AD9833 gen (FNC_PIN);

Dernæst har vi vores opsætningsfunktion (), i den opsætningsfunktion starter vi med at aktivere Serial til fejlfinding. Vi initialiserer AD9833-modulet ved hjælp af start () -metoden. Dernæst indstiller vi alle de tildelte roterende kodestifter som input. Og vi gemmer værdien af urstiften i variablen clockPinState, dette er et nødvendigt trin for den roterende indkoder.

Dernæst indstiller vi alle knappestifter som input og aktiverer OLED-skærmen ved hjælp af display.begin () -metoden, og vi kontrollerer også for eventuelle fejl med en if-sætning . Når det er gjort, rydder vi skærmen og udskriver en opstartsskærm, vi tilføjer en forsinkelse på 2 sekunder, hvilket også er forsinkelsen for stænkskærmen, og til sidst kalder vi opdateringsdisplay () -funktionen, der rydder skærmen og opdaterer vises igen. Detaljerne i metoden update_display () diskuteres senere i artiklen.

ugyldig opsætning () {Serial.begin (9600); // Aktivér Serial @ 9600 baud gen.Begin (); // Dette SKAL være den første kommando efter at have erklæret AD9833-objektet pinMode (CLK_PIN, INPUT); // Indstilling af pins som input pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Indstilling af pins som input pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); hvis (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adresse 0x3D til 128x64 Serial.println (F ("SSD1306 allokering mislykkedes")); til (;;); } display.clearDisplay (); // Ryd skærmvisning.setTextSize (2); // Indstil tekststørrelse display.setTextColor (WHITE); // indstil LCD-farvedisplay. setCursor (30, 0); // Indstil markørposition display.println ("AD9833"); // Udskriv denne tekstvisning.setCursor (17, 20); // Indstil markørposition display.println ("Funktion"); // Udskriv denne tekstvisning.setCursor (13, 40); // Indstil markørposition display.println ("Generator"); // Udskriv denne tekstvisning. Display (); // Opdater skærmforsinkelsen (2000); // Forsinkelse af 2 SEC update_display (); // Opkald opdateringsdisplayfunktion}

Dernæst har vi vores loop () -funktion, alle de vigtigste funktionaliteter er skrevet i loop-sektionen.

Først læser vi uret på Rotary encoder og gemmer det i clockPin-variablen, som vi tidligere har erklæret. Dernæst kontrollerer vi i if- sætningen, om den forrige værdi af stiften og den aktuelle værdi af stiften er ens eller ikke, og vi kontrollerer også den aktuelle værdi af stiften. Hvis det hele er sandt, kontrollerer vi for datapinnen, hvis det er sandt, betyder det, at koderen roterer mod uret, og vi reducerer tællerværdien ved hjælp af modkommando. Ellers øger vi tællerværdien med kommandoen tæller ++. Endelig sætter vi en anden if- sætning for at indstille minimumsværdien til 1. Derefter opdaterer vi clockPinState med det aktuelle clockPinværdi til fremtidig brug.

ugyldig sløjfe () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {tæller -; } ellers {tæller ++; // Encoder roterer CW så stigning} hvis (tæller <1) tæller = 1; Serial.println (tæller); update_display (); }

Dernæst har vi vores kode til at registrere et tryk på en knap. I dette afsnit har vi registreret knappen inde i koderen ved hjælp af nogle indlejrede hvis udsagn, hvis (digitalRead (BTN_PIN) == LOW && millis () - tid> opsige), i denne erklæring, kontrollerer vi først, om knappen pin er lav eller ej, hvis den er lav, trykkes den. Derefter kontrollerer vi timerværdien med afvisningsforsinkelsen. Hvis begge udsagn er sande, erklærer vi det som en vellykket knaptryk, hvis vi øger værdien encoder_btn_count. Dernæst erklærer vi et andet hvis udsagn for at indstille den maksimale tællerværdi til 2, har vi brug for det, fordi vi bruger det til at indstille outputbølgeformen.De på hinanden følgende tre, hvis udsagn gør det, hvis værdien er nul, vælges sinusbølgeform, hvis den er en, er den en firkantbølge, og hvis værdien er 2, er den en trekantet bølge. I alle tre af disse if-udsagn opdaterer vi skærmen med funktionen update_display () . Og endelig opdaterer vi tidsvariablen med den aktuelle timertællerværdi.

// Hvis vi registrerer et LAV signal, trykkes på knappen, hvis (digitalRead (BTN_PIN) == LOW && millis () - tid> afvisning) {encoder_btn_count ++; // Forøg værdierne, hvis (encoder_btn_count> 2) // hvis værdien er større end 2 nulstilles den til 0 {encoder_btn_count = 0; } hvis (encoder_btn_count == 0) {// hvis værdien er 0, er sinusbølge valgt waveSelect = "SIN"; // opdater strengvariablen med sin værdi update_display (); // opdater displayet} hvis (encoder_btn_count == 1) {// hvis værdien er 1 firkantet bølge er valgt waveSelect = "SQR"; // opdater strengvariablen med SQR-værdi update_display (); // opdater displayet} hvis (encoder_btn_count == 2) {// hvis værdien er 1 Triangulær bølge er valgt waveSelect = "TRI"; // opdater strengvariablen med TRI-værdi update_display ();// opdater displayet} tid = millis (); // opdater tidsvariablen}

Dernæst definerer vi al nødvendig kode, der er nødvendig for at opsætte alle knapper med en forsinkelse. Da knapperne er forbundet til de analoge ben på Arduino, bruger vi den analoge læsekommando til at identificere et knaptryk, hvis den analoge læseværdi når under 30, så registrerer vi, at det er et vellykket knaptryk, og vi venter på 200 ms til Kontroller, om det kun er et tryk på en knap eller en støj. Hvis denne sætning er sand, tildeler vi de boolske variabler med værdier, der bruges til at indstille Hz-, Khz- og Mhz-værdierne for funktionsgeneratoren. Dernæst opdaterer vi skærmen og opdaterer tidsvariablen. Vi gør det for alle de fire knapper, der er forbundet med Arduino.

hvis (analogRead (SET_FREQUENCY_HZ) <30 && millis () - tid> afvisning) {set_frequency_hz = 1; // opdater boolske værdier set_frequency_khz = 0; sæt_frekvens_mhz = 0; update_display (); // opdater displaytiden = millis (); // opdater tidsvariablen} hvis (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // opdater boolske værdier set_frequency_khz = 1; sæt_frekvens_mhz = 0; moduleFrequency = tæller * 1000; update_display (); // opdater displaytiden = millis (); // opdater tidsvariablen} hvis (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - tid> afvisning) {// kontroller analog pin med afvisningsforsinkelse set_frequency_hz = 0; // opdater boolske værdier set_frequency_khz = 0; sæt_frekvens_mhz = 1; moduleFrequency = tæller * 1000000; update_display ();// opdater visningstiden = millis (); // opdater tidsvariablen} hvis (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - tid> afvis) {// tjek analog pin med afvisningsforsinkelse btn_state =! btn_state; // Inverter knappen knap tilstand gen.EnableOutput (btn_state); // Aktivér / deaktiver output fra funktionsgeneratoren afhængigt af knaptilstand update_display (); // opdater visningstid = millis (); // opdater tidsvariabel}}// opdater tidsvariablen}}// opdater tidsvariablen}}

Endelig har vi vores update_display () funktion. I denne funktion gjorde vi meget mere end bare at opdatere denne skærm, fordi en bestemt del af skærmen ikke kan opdateres i en OLED. For at opdatere det skal du male det igen med nye værdier. Dette gør kodningsprocessen meget vanskeligere.

Inde i denne funktion starter vi med at rydde displayet. Dernæst indstiller vi vores krævede tekststørrelse. Derefter indstiller vi vores markør og udskrevne funktionsgenerator med displayet. Println ("Funktionsfunktion"); kommando. Vi sætter igen tekststørrelsen til 2 og markøren til (0,20) ved hjælp af display.setCursor (0, 20) -funktionen.

Det er her, vi udskriver oplysningerne for, hvilken bølge det er.

display.clearDisplay (); // Først ryd displayet. SetTextSize (1); // sæt tekst Størrelse display.setCursor (10, 0); // Indstil markørposition display.println ("Funktionsgenerator"); // udskriv tekstdisplayet.setTextSize (2); // indstil tekststørrelse display.setCursor (0, 20); // Indstil markørposition

Dernæst kontrollerer vi de boolske variabler for frekvensoplysninger og opdaterer værdien i moduleFrequency- variablen. Vi gør dette for Hz-, kHz- og MHz-værdier. Dernæst kontrollerer vi waveSelect- variablen og identificerer, hvilken bølge der er valgt. Nu har vi værdierne til at indstille bølgetype og frekvens.

hvis (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// kontroller, om der trykkes på knappen til indstilling af frekvensen i Hz moduleFrequency = counter; // opdater modulFrequency-variablen med den aktuelle tællerværdi} hvis (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// kontroller, om der trykkes på knappen til indstilling af frekvensen i KHz moduleFrequency = tæller * 1000; // opdater modulFrequency-variablen med den aktuelle tællerværdi, men vi multiplicerer 1000 for at indstille den på KHZ} hvis (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// kontroller, om der trykkes på knappen til indstilling af frekvensen i MHz modulFrequency = tæller * 1000000; hvis (moduleFrequency> 12000000) {moduleFrequency = 12000000;// lad ikke frekvensen være rivejern, at 12Mhz tæller = 12; }} hvis (waveSelect == "SIN") {// Sine wave er valgt display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "SQR") {// Sqr-bølge er valgt display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "TRI") {// Tri-bølge er valgt display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // opdater AD9833-modulet. Serial.println (moduleFrequency); }} hvis (waveSelect == "SQR") {// Sqr-bølge er valgt display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "TRI") {// Tri-bølge er valgt display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // opdater AD9833-modulet. Serial.println (moduleFrequency); }} hvis (waveSelect == "SQR") {// Sqr-bølge er valgt display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "TRI") {// Tri-bølge er valgt display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // opdater AD9833-modulet. Serial.println (moduleFrequency); }

Vi indstiller markøren igen og opdaterer tællerværdierne. Igen kontrollerer vi den boolske for at opdatere frekvensområdet på skærmen, vi skal gøre dette, fordi OLED's funktionsprincip er meget underligt.

display.setCursor (45, 20); display.println (tæller); // udskrive tælleroplysningerne på displayet. hvis (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // udskriv Hz på displayet. display (); // når alle indstillinger opdaterer displayet} hvis (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // når alle indstillinger opdaterer displayet} hvis (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // når alle indstillinger opdaterer skærmen}

Dernæst kontrollerer vi knapets trykvariabel for at udskrive output til / output fra til OLED. Igen skal dette gøres på grund af OLED-modulet.

hvis (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Output ON"); // udskrivning på displayet. display (); display.setTextSize (2); } andet {display.setTextSize (1); display.setCursor (65, 45); display.print ("Output OFF"); // udskrivning fra displayet. display (); display.setTextSize (2); }

Dette markerer afslutningen på vores kodningsproces. Hvis du er forvirret på dette tidspunkt, kan du tjekke kommentarerne i koden for yderligere forståelse.

Test af den AD9833-baserede funktionsgenerator

For at teste kredsløbet anvendes ovenstående opsætning. Som du kan se, har vi tilsluttet en 12V jævnstrømsadapter til jævnstrømsstikket, og vi har tilsluttet Hantek Oscilloskop til udgangen af kredsløbet. Vi har også tilsluttet oscilloskopet til den bærbare computer for at visualisere og måle outputfrekvensen.

Når dette var gjort, indstillede vi udgangsfrekvensen til 5 KHz ved hjælp af den roterende indkoder, og vi tester udgangssinusbølgen og helt sikkert, det er en 5 KHz sinusbølge ved udgangen.

Dernæst har vi ændret outputbølgeformen til en trekantet bølge, men frekvensen forblev den samme, outputbølgeformen er vist nedenfor.

Derefter ændrede vi output til en firkantbølge og observerede output, og det var en perfekt firkantbølge.

Vi ændrede også frekvensområderne og testede output, og det fungerede godt.

Yderligere forbedringer

Dette kredsløb er kun et bevis på konceptet og har brug for yderligere forbedringer. For det første har vi brug for et printkort af god kvalitet og et BNC-stik af god kvalitet til output, ellers kan vi ikke opnå en højere frekvens. Modulets amplitude er meget lav, så for at forbedre det har vi brug for nogle op-amp kredsløb til at forstærke udgangsspændingen. Et potentiometer kan tilsluttes for at variere outputamplituden. En kontakt til modregning af signalet kan tilsluttes; dette er også en must-have-funktion. Og yderligere har koden brug for meget forbedring, da den er lidt buggy. Endelig skal OLED-skærme ændres, ellers er det umuligt at skrive let forståelig kode.

Dette markerer slutningen af denne vejledning, jeg håber, du kunne lide artiklen og lærte noget nyt. Hvis du har spørgsmål vedrørende artiklen, kan du lade dem være i kommentarfeltet nedenfor, eller du kan bruge vores elektronikforum.