- Hva er en DDS-funksjonsgenerator?
- Forstå funksjonen til AD9833 funksjonsgenerator IC
- Komponenter som kreves for å bygge den AD9833-baserte funksjonsgeneratoren
- AD9833-basert funksjonsgenerator - skjematisk diagram
- AD9833-basert funksjonsgenerator - Arduino-kode
- Testing av den AD9833-baserte funksjonsgeneratoren
- Ytterligere forbedringer
Hvis du er en elektronisk entusiast som meg som vil finpusse med forskjellige elektroniske kretser, blir det noen ganger obligatorisk å ha en anstendig funksjonsgenerator. Men å eie en er et problem fordi slikt grunnleggende utstyr kan koste en formue. Å bygge ditt eget testutstyr er ikke bare billigere, men også en fin måte å forbedre din kunnskap på.
Så i denne artikkelen skal vi bygge en enkel signalgenerator med Arduino og AD9833 DDS funksjonsgeneratormodul som kan produsere sinus-, firkant- og trekantbølger med en maksimal frekvens på 12 MHz ved utgangen. Og til slutt skal vi teste utgangsfrekvensen ved hjelp av oscilloskopet vårt.
Vi har tidligere bygget en Simple Sine Wave Generator, en Square Wave Generator og en Triangle Wave Generator ved hjelp av grunnleggende analoge kretser. Du kan sjekke ut disse hvis du leter etter noen grunnleggende Waveform Generator Circuits. Hvis du vil bygge en billigere Arduino-funksjonsgenerator uten å bruke AD9833-modulen, kan du også sjekke ut DIY Arduino Waveform Generator Project.
Hva er en DDS-funksjonsgenerator?
Som navnet antyder, er en funksjonsgenerator en enhet som kan sende en bestemt bølgeform med en bestemt frekvens ved innstilling. Tenk for eksempel at du har et LC-filter du vil teste utgangsfrekvensresponsen din for, det kan du enkelt gjøre ved hjelp av en funksjonsgenerator. Alt du trenger å gjøre er å angi ønsket utgangsfrekvens og bølgeform, så kan du skru den ned eller opp for å teste responsen. Dette var bare ett eksempel, du kan gjøre flere ting med det når listen fortsetter.
DDS står for Direct Digital Synthesis. Det er en type bølgeformgenerator som bruker digitale til analoge omformere (DAC) for å bygge et signal fra grunnen av. Denne metoden brukes spesielt til å generere en sinusbølge. Men ICen vi bruker kan produsere firkantede eller trekantede bølgesignaler. Operasjonene som skjedde inne i en DDS-brikke er digitale, slik at den kan bytte frekvens veldig raskt, eller den kan bytte fra ett signal til et annet veldig raskt. Denne enheten har en fin frekvensoppløsning med et bredt frekvensspektrum.
Forstå funksjonen til AD9833 funksjonsgenerator IC
Kjernen i prosjektet vårt er AD9833 Programmable Waveform Generator IC som er designet og utviklet av analoge enheter. Det er en laveffekts, programmerbar bølgeformgeneratoren stand til å frembringe sinus, trekant, og firkantet bølge med en maksimal frekvens på 12 MHz. Det er en veldig unik IC som er i stand til å endre utgangsfrekvensen og fasen med bare et program. Den har et 3-leders SPI-grensesnitt, og derfor blir kommunikasjonen med denne IC veldig enkel og enkel. Det funksjonelle blokkdiagrammet til denne IC er vist nedenfor.
Arbeidet med denne IC er veldig enkelt. Hvis vi tar en titt på det funksjonelle blokkdiagrammet ovenfor, vil vi observere at vi har en faseakkumulator som har til oppgave å lagre alle mulige digitale verdier av en sinusbølge, fra 0 til 2π. Deretter har vi SIN ROM som har til oppgave å konvertere faseinformasjonen som senere kan kartlegges direkte til amplitude. SIN ROM bruker digital faseinformasjon som en adresse til en oppslagstabell og konverterer faseinformasjonen til amplitude. Og til slutt har vi en 10-bit digital til analog omformer hvis jobb er å motta digitale data fra SIN ROM og konvertere den til tilsvarende analoge spenninger, det er det vi får fra utgangen. Ved utgangen har vi også en bryter som vi kan slå på eller av med bare en liten programvarekode. Vi vil snakke om det senere i artikkelen.Detaljene du ser ovenfor er en veldig nedkladd versjon av hva som skjer inne i IC, og de fleste detaljene du ser ovenfor er hentet fra databladet AD9833, du kan også sjekke det ut for mer informasjon.
Komponenter som kreves for å bygge den AD9833-baserte funksjonsgeneratoren
Komponentene som kreves for å bygge den AD9833-baserte funksjonsgeneratoren er listet opp nedenfor, vi designet denne kretsen med veldig generiske komponenter, noe som gjør replikasjonsprosessen veldig enkel.
- Arduino Nano - 1
- AD9833 DDS-funksjonsgenerator - 1
- 128 X 64 OLED-skjerm - 1
- Generisk Rotary Encoder - 1
- DC fat jack - 1
- LM7809 Spenningsregulator - 1
- 470uF kondensator - 1
- 220uF kondensator - 1
- 104pF kondensator - 1
- 10K motstand - 6
- Taktile brytere - 4
- Skruterminal 5.04mm - 1
- Kvinnelig topptekst - 1
- 12V strømkilde - 1
AD9833-basert funksjonsgenerator - skjematisk diagram
Det komplette kretsskjemaet for AD9833 og Arduino-basert funksjonsgenerator er vist nedenfor.
Vi skal bruke AD9833 med Arduino for å generere ønsket frekvens. Og i denne delen vil vi forklare alle detaljene ved hjelp av skjematisk; la meg gi deg en kort oversikt over hva som skjer med kretsen. La oss starte med AD9833-modulen. AD9833-modulen er funksjonsgeneratormodulen og den er koblet til Arduino i henhold til skjematisk. For å drive kretsen bruker vi en LM7809 spenningsregulator IC, med en anstendig frakoblingskondensator, dette er nødvendig fordi forsyningsstøyen kan forstyrre utgangssignalet og resultere i uønsket utgang. Som alltid jobber Arduino som hjernen for dette prosjektet. For å vise den innstilte frekvensen og annen verdifull informasjon, har vi koblet til en 128 X 64 OLED-skjermmodul. For å endre frekvensområdet bruker vi tre brytere. Den første setter frekvensen til Hz, den andre setter utgangsfrekvensen til KHz, og den tredje setter frekvensen til MHz, vi har også en annen knapp som kan brukes til å aktivere eller deaktivere utgangen. Til slutt har vi den roterende koderen,og vi må feste noen opptrekksmotstand med den ellers vil ikke disse bryterne fungere fordi vi sjekker knappetrykkhendelsen på pooling-metoden. Rotasjonskoderen brukes til å endre frekvens, og den taktile bryteren inne i rotasjonskoderen brukes til å velge den innstilte bølgeformen.
AD9833-basert funksjonsgenerator - Arduino-kode
Den komplette koden som brukes i dette prosjektet, finner du nederst på denne siden. Etter å ha lagt til de nødvendige headerfilene og kildefilene, bør du kunne kompilere Arduino-filen direkte. Du kan laste ned ad9833 Arduino-biblioteket og andre biblioteker fra lenken nedenfor, ellers kan du bruke metoden for styringsadministrator for å installere biblioteket.
- Last ned AD9833-biblioteket av Bill Williams
- Last ned SSD1306 OLED Library av Adafruit
- Last ned Adafruit GFX bibliotek
Forklaringen på koden i ino. filen er som følger. Først begynner vi med å inkludere alle nødvendige biblioteker. Biblioteket for AD9833 DDS-modulen blir først fulgt av biblioteket for OLED, og mattebiblioteket er påkrevd for noen av våre beregninger.
#include // LIbrary for AD9833 Module #include
Deretter definerer vi alle nødvendige inngangs- og utgangspinner for knappene, bryteren, roterende koderen og OLED-ene.
#define SCREEN_WIDATA_PINH 128 // OLED-skjerm Bredde i piksler #definer SCREEN_HEIGHT 64 // OLED-skjermhøyde, i piksler #definer SET_FREQUENCY_HZ A2 // Trykknapp for å angi frekvens i Hz # definer SET_FREQUENCY_KHZ A3 // Trykknapp for å stille frekvens i Khz A6 // Trykknapp for å stille frekvens i MHz #definer ENABLE_DISABLE_OUTPUT_PIN A7 // Trykknapp for å aktivere / deaktivere utdata #definer FNC_PIN 4 // Fsync kreves av AD9833-modulen #definer CLK_PIN 8 // Clock Pin of the Encoder #define DATA_P / Data Pin of Encoder #define BTN_PIN 9 // Intern trykknapp på koderen
Deretter definerer vi alle nødvendige variabler som kreves i denne koden. Først definerer vi en heltalsvariabel teller som vil lagre den roterende koderverdien. De neste to variablene ClockPin og ClockPinState lagrer pin-statuen som kreves for å forstå koderen. Vi har en tid variabel som holder dagens tids-tellerverdier, denne variabelen brukes for knapp debouncing. Deretter har vi en usignert lang variabel modulFrekvens som inneholder den beregnede frekvensen som skal brukes. Deretter har vi forsinkelsen. Denne forsinkelsen kan justeres etter behov. Deretter har vi tre boolske variabler set_frequency_hz,set_frequency_Khz og set_frequency_Mhz disse tre variablene brukes til å bestemme den gjeldende innstillingen til modulen. Vi vil snakke om det mer detaljert senere i artikkelen. Deretter har vi variabelen som lagrer statusen til utgangsbølgeformen, standard utgangsbølgeform er en sinusbølge. Og til slutt har vi encoder_btn_count- variabelen som inneholder antall koderknapper som brukes til å stille utgangsbølgeformen.
int teller = 1; // Denne tellerverdien vil øke eller reduseres hvis når rotasjonsgiveren vris int clockPin; // Plassholder for pin-status brukt av den roterende koderen int clockPinState; // Plassholder for pinnestatus brukt av rotasjonskoderen usignert lang tid = 0; // Brukes for å avvise usignert lang modulFrequency; // brukes til å stille utgangsfrekvens lang avslag = 220; // Avvisningsforsinkelse bool btn_state; // brukes til å aktivere deaktivering av utdata fra AD98333-modul bool set_frequency_hz = 1; // Defultfrekvens for AD9833 Module bool set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // Oppstartsbølgeform av modulen int encoder_btn_count = 0; // brukes til å sjekke koderknappen trykk Neste, vi har våre to objekter en er for OLED-skjermen og en annen er for AD9833-modulen.Adafruit_SSD1306-skjerm (SCREEN_WIDATA_PINH, SCREEN_HEIGHT, & Wire, -1); AD9833 gen (FNC_PIN);
Deretter har vi vår oppsett () -funksjon, i den oppsettfunksjonen begynner vi med å aktivere Serial for feilsøking. Vi initialiserer AD9833-modulen ved hjelp av begin () -metoden. Deretter setter vi alle de tildelte roterende kodepinnene som inngang. Og vi lagrer verdien av klokkestiften i clockPinState- variabelen, dette er et nødvendig trinn for den roterende koderen.
Deretter setter vi alle knappepinnene som inngang og aktiverer OLED-skjermen ved hjelp av display.begin () -metoden, og vi ser også etter eventuelle feil med en if-setning . Når det er gjort, tømmer vi skjermen og skriver ut en oppstartssprutskjerm, vi legger til en forsinkelse på 2 sekunder som også er forsinkelsen for sprutskjermen, og til slutt kaller vi funksjonen update_display () som tømmer skjermen og oppdaterer vises igjen. Detaljer om metoden update_display () vil bli diskutert senere i artikkelen.
ugyldig oppsett () {Serial.begin (9600); // Aktiver Serial @ 9600 baud gener.Begin (); // Dette MÅ være den første kommandoen etter å ha erklært AD9833-objektet pinMode (CLK_PIN, INPUT); // Angi pins som inngang pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Angi pins som inngang pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); hvis (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adresse 0x3D for 128x64 Serial.println (F ("SSD1306-tildeling mislyktes")); for (;;); } display.clearDisplay (); // Fjern skjermvisning.setTextSize (2); // Set text Size display.setTextColor (WHITE); // sett LCD-fargeskjerm. setCursor (30, 0); // Sett markørposisjon display.println ("AD9833"); // Skriv ut denne tekstvisningen.setCursor (17, 20); // Sett markørposisjon display.println ("Funksjon"); // Skriv ut denne tekstvisningen. SetCursor (13, 40); // Sett markørposisjon display.println ("Generator"); // Skriv ut denne tekstvisningen. Display (); // Oppdater skjermforsinkelsen (2000); // Forsinkelse på 2 SEC update_display (); // Call update_display Function}
Deretter har vi loop () -funksjonen, alle hovedfunksjonalitetene er skrevet i loop-delen.
Først leser vi Clock pin på Rotary encoder og lagrer den i clockPin-variabelen som vi har erklært tidligere. Deretter, i if- setningen, sjekker vi om den forrige verdien av pinnen og den nåværende verdien av pinnen er lik eller ikke, og vi sjekker også den nåværende verdien av pinnen. Hvis alt er sant, ser vi etter datapinnen, hvis det er sant betyr det at koderen roterer mot klokken og vi reduserer tellerverdien ved hjelp av motkommando. Ellers øker vi tellerverdien med kommandoen teller ++. Til slutt setter vi en annen if- setning for å sette minimumsverdien til 1. Deretter oppdaterer vi clockPinState med gjeldende clockPinverdi for fremtidig bruk.
ugyldig sløyfe () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {counter -; } annet {counter ++; // Encoder roterer CW så inkrement} hvis (counter <1) counter = 1; Serial.println (teller); update_display (); }
Deretter har vi koden vår for å oppdage et trykk på knappen. I denne delen har vi oppdaget knappen inne i koderen ved hjelp av noen nestede hvis utsagn, hvis (digitalRead (BTN_PIN) == LOW && millis () - time> fordømme), i denne uttalelsen, sjekker vi først om knappen pin er lav eller ikke, hvis den er lav, trykkes den. Så igjen sjekker vi tidsverdien med utsettelsesforsinkelsen. Hvis begge utsagnene er sanne, erklærer vi det som en vellykket knappetrykkhandling, hvis vi øker verdien encoder_btn_count. Deretter erklærer vi en annen hvis setning for å sette maksimal tellerverdi til 2, trenger vi den fordi vi bruker den til å stille utgangsbølgeformen.De påfølgende tre hvis setninger gjør det, hvis verdien er null, er sinusbølgeform valgt, hvis den er en, er den en firkantbølge, og hvis verdien er 2, er det en trekantet bølge. I alle tre av disse if-setningene oppdaterer vi skjermen med funksjonen update_display () . Og til slutt oppdaterer vi tidsvariabelen med den nåværende timertellerverdien.
// Hvis vi oppdager et LAV signal, trykkes på knappen hvis (digitalRead (BTN_PIN) == LOW && millis () - tid> avvisning) {encoder_btn_count ++; // Øk verdiene hvis (encoder_btn_count> 2) // hvis verdien er større enn 2, tilbakestill den til 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// hvis verdien er 0 sinusbølge er valgt waveSelect = "SIN"; // oppdater strengvariabelen med sin verdi update_display (); // oppdater skjermen} hvis (encoder_btn_count == 1) {// hvis verdien er 1 firkantbølge er valgt waveSelect = "SQR"; // oppdater strengvariabelen med SQR-verdien update_display (); // oppdater skjermen} hvis (encoder_btn_count == 2) {// hvis verdien er 1 Triangulær bølge er valgt waveSelect = "TRI"; // oppdater strengvariabelen med TRI-verdi update_display ();// oppdater skjermen} tid = millis (); // oppdater tidsvariabelen}
Deretter definerer vi all nødvendig kode som kreves for å sette opp alle knappene med en forsinkelse. Ettersom knappene er koblet til de analoge pinnene til Arduino, bruker vi den analoge lesekommandoen for å identifisere et knappetrykk hvis den analoge leseverdien når under 30, så oppdager vi at det er et vellykket knappetrykk, og vi venter på 200 ms å sjekk om det bare er et knappetrykk eller en lyd. Hvis denne påstanden stemmer, tildeler vi de boolske variablene verdier som brukes til å sette Hz-, Khz- og Mhz-verdiene til funksjonsgeneratoren. Deretter oppdaterer vi skjermen og oppdaterer tidsvariabelen. Vi gjør det for alle de fire knappene som er koblet til Arduino.
hvis (analogRead (SET_FREQUENCY_HZ) <30 && millis () - time> debounce) {set_frequency_hz = 1; // oppdater boolske verdier set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // oppdater visningstiden = millis (); // oppdater tidsvariabelen} hvis (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // oppdater boolske verdier set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = teller * 1000; update_display (); // oppdater visningstiden = millis (); // oppdater tidsvariabelen} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - time> debounce) {// sjekk analog pin med utsettingsforsinkelse set_frequency_hz = 0; // oppdater boolske verdier set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = teller * 1000000; update_display ();// oppdater visningstiden = millis (); // oppdater tidsvariabelen} hvis (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - tid> avvis) {// sjekk analog pin med avvisningsforsinkelse btn_state =! btn_state; // Inverter knappestatus gener.EnableOutput (btn_state); // Aktiver / deaktiver utgang fra funksjonsgeneratoren avhengig av knappestatus update_display (); // oppdater visningstiden = millis (); // oppdater tidsvariabelen}}// oppdater tidsvariabelen}}// oppdater tidsvariabelen}}
Til slutt har vi vår update_display () -funksjon. I denne funksjonen gjorde vi mye mer enn bare å oppdatere denne skjermen fordi en viss del av skjermen ikke kan oppdateres i en OLED. For å oppdatere den, må du male den på nytt med nye verdier. Dette gjør kodingsprosessen mye vanskeligere.
Inne i denne funksjonen starter vi med å rydde skjermen. Deretter setter vi ønsket tekststørrelse. Deretter setter vi markøren og den trykte funksjonsgeneratoren med display.println ("Funksjonsfunksjon"); kommando. Vi setter igjen tekststørrelsen til 2, og markøren til (0,20) ved hjelp av display.setCursor (0, 20) -funksjonen.
Det er her vi skriver ut informasjonen for hvilken bølge det er.
display.clearDisplay (); // Tøm først skjermdisplayet.setTextSize (1); // set text Size display.setCursor (10, 0); // Still markørposisjonsvisning.println ("Funksjonsgenerator"); // skriv ut tekstdisplayet.setTextSize (2); // sett tekststørrelse display.setCursor (0, 20); // Still markørposisjon
Deretter sjekker vi de boolske variablene for frekvensdetaljer og oppdaterer verdien i variabelen moduleFrequency. Vi gjør dette for Hz-, kHz- og MHz-verdier. Deretter sjekker vi waveSelect- variabelen og identifiserer hvilken bølge som er valgt. Nå har vi verdiene for å stille inn bølgetype og frekvens.
hvis (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// sjekk om knappen for innstilling av frekvensen i Hz trykkes på moduleFrequency = counter; // oppdater moduleFrequency-variabelen med gjeldende tellerverdi} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// sjekk om knappen for innstilling av frekvensen i KHz trykkes på moduleFrequency = teller * 1000; // oppdater moduleFrequency-variabelen med gjeldende tellerverdi, men vi multipliserer 1000 for å sette den på KHZ} hvis (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// sjekk om knappen for innstilling av frekvensen i MHz trykkes på moduleFrequency = teller * 1000000; hvis (moduleFrequency> 12000000) {moduleFrequency = 12000000;// ikke la frekvensen være rivjern som 12Mhz teller = 12; }} hvis (waveSelect == "SIN") {// Sine wave er valgt display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "SQR") {// Sqr wave er valgt display.println ("SQR"); gener.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "TRI") {// Tri-bølge er valgt display.println ("TRI"); gener.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // oppdater AD9833-modulen. Serial.println (moduleFrequency); }} hvis (waveSelect == "SQR") {// Sqr wave er valgt display.println ("SQR"); gener.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "TRI") {// Tri-bølge er valgt display.println ("TRI"); gener.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // oppdater AD9833-modulen. Serial.println (moduleFrequency); }} hvis (waveSelect == "SQR") {// Sqr wave er valgt display.println ("SQR"); gener.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } hvis (waveSelect == "TRI") {// Tri-bølge er valgt display.println ("TRI"); gener.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // oppdater AD9833-modulen. Serial.println (moduleFrequency); }
Vi setter markøren på nytt og oppdaterer tellerverdiene. Igjen sjekker vi boolesk for å oppdatere frekvensområdet på skjermen, vi må gjøre dette fordi arbeidsprinsippet til OLED er veldig rart.
display.setCursor (45, 20); display.println (teller); // skriv ut tellerinformasjonen på skjermen. hvis (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // skriv ut Hz på displayet. display (); // når alle sett oppdaterer skjermen} 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 sett oppdaterer skjermen} 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 sett oppdaterer skjermen}
Deretter sjekker vi knappetrykkvariabelen for å skrive ut / på utdata til OLED. Igjen må dette gjøres på grunn av OLED-modulen.
hvis (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Output ON"); // skriv ut på displayet. display (); display.setTextSize (2); } annet {display.setTextSize (1); display.setCursor (65, 45); display.print ("Output OFF"); // utskriftsutdata av til skjermdisplayet. display (); display.setTextSize (2); }
Dette markerer slutten på kodingsprosessen. Hvis du er forvirret på dette punktet, kan du sjekke kommentarene i koden for nærmere forståelse.
Testing av den AD9833-baserte funksjonsgeneratoren
For å teste kretsen brukes oppsettet ovenfor. Som du kan se, har vi koblet en 12V DC strømadapter til DC fat-kontakten, og vi har koblet Hantek Oscilloscope til utgangen av kretsen. Vi har også koblet oscilloskopet til den bærbare datamaskinen for å visualisere og måle utgangsfrekvensen.
Når dette var gjort, satte vi utgangsfrekvensen til 5 KHz ved hjelp av den roterende koderen, og vi tester utgangssinusbølgen og sikkert, det er en 5 KHz sinusbølge ved utgangen.
Deretter har vi endret utgangsbølgeformen til en trekantet bølge, men frekvensen forble den samme, utgangsbølgeformen er vist nedenfor.
Så endret vi utgangen til en firkantbølge og observerte utgangen, og det var en perfekt firkantbølge.
Vi endret også frekvensområdene og testet utdataene, og det fungerte bra.
Ytterligere forbedringer
Denne kretsen er bare et bevis på konseptet og trenger ytterligere forbedringer. For det første trenger vi en PCB av god kvalitet og en BNC-kontakt av god kvalitet for utgangen ellers kan vi ikke oppnå en høyere frekvens. Amplituden til modulen er veldig lav, så for å forbedre det trenger vi noen op-amp kretser for å forsterke utgangsspenningen. Et potensiometer kan kobles til for å variere utgangsamplituden. En bryter for forskyvning av signalet kan kobles til; dette er også en må-ha-funksjon. Og videre trenger koden mye forbedring da den er litt buggy. Til slutt må OLED-skjermer endres, ellers er det umulig å skrive lett forståelig kode.
Dette markerer slutten på denne veiledningen, jeg håper du likte artikkelen og lærte noe nytt. Hvis du har spørsmål angående artikkelen, kan du legge dem igjen i kommentarfeltet nedenfor, eller du kan bruke vårt elektronikkforum.