- Wat is een DDS-functiegenerator?
- Begrijp de werking van de AD9833 Function Generator IC
- Componenten die nodig zijn om de op AD9833 gebaseerde functiegenerator te bouwen
- Op AD9833 gebaseerde functiegenerator - Schematisch diagram
- Op AD9833 gebaseerde functiegenerator - Arduino-code
- Testen van de op AD9833 gebaseerde functiegenerator
- Verdere verbeteringen
Als je een elektronische liefhebber bent zoals ik die wil afstemmen met verschillende elektronische circuits, wordt het hebben van een fatsoenlijke functiegenerator soms verplicht. Maar het bezit ervan is een probleem, omdat dergelijke basisuitrusting een fortuin kan kosten. Het bouwen van uw eigen testapparatuur is niet alleen goedkoper, maar ook een geweldige manier om uw kennis te verbeteren.
Dus in dit artikel gaan we een eenvoudige signaalgenerator bouwen met Arduino en AD9833 DDS-functiegeneratormodule die sinus-, vierkante en driehoeksgolven kan produceren met een maximale frequentie van 12 MHz aan de uitgang. En tot slot gaan we de uitgangsfrequentie testen met behulp van onze oscilloscoop.
We hebben eerder een Simple Sine Wave Generator, een Square Wave Generator en een Triangle Wave Generator gebouwd met behulp van eenvoudige analoge circuits. U kunt deze bekijken als u op zoek bent naar enkele basiscircuits voor golfvormgeneratoren. Als je een goedkopere Arduino-functiegenerator wilt bouwen zonder de AD9833-module te gebruiken, kun je het DIY Arduino Waveform Generator-project bekijken.
Wat is een DDS-functiegenerator?
Zoals de naam al aangeeft, is een functiegenerator een apparaat dat bij het instellen een specifieke golfvorm met een specifieke frequentie kan uitvoeren. Stel dat u bijvoorbeeld een LC-filter heeft waarvoor u uw uitgangsfrequentierespons wilt testen, dan kunt u dat eenvoudig doen met behulp van een functiegenerator. Het enige dat u hoeft te doen, is de gewenste uitgangsfrequentie en golfvorm instellen, waarna u deze kunt verlagen of verhogen om de respons te testen. Dit was slechts een voorbeeld, je kunt er meer dingen mee doen naarmate de lijst vordert.
DDS staat voor Direct Digital Synthesis. Het is een type golfvormgenerator die digitaal naar analoog converters (DAC) gebruikt om een signaal van de grond af op te bouwen. Deze methode wordt specifiek gebruikt om een sinusgolf te genereren. Maar de IC die we gebruiken, kan vierkante of driehoekige golfsignalen produceren. De bewerkingen die in een DDS-chip hebben plaatsgevonden, zijn digitaal, zodat deze de frequentie zeer snel kan omschakelen of zeer snel van het ene signaal naar het andere kan overschakelen. Dit apparaat heeft een fijne frequentieresolutie met een breed frequentiespectrum.
Begrijp de werking van de AD9833 Function Generator IC
De kern van ons project is de AD9833 Programmable Waveform Generator IC die is ontworpen en ontwikkeld door analoge apparaten. Het is een laag vermogen, programmeerbare golfvormgenerator staat is sine, driehoekige en vierkante golf met een frequentie van 12 MHz maximum. Het is een zeer unieke IC die in staat is om de uitgangsfrequentie en fase te veranderen met slechts een softwareprogramma. Het heeft een 3-draads SPI-interface en daarom wordt communiceren met dit IC heel eenvoudig en gemakkelijk. Het functionele blokschema van dit IC wordt hieronder weergegeven.
De werking van dit IC is heel eenvoudig. Als we het functionele blokschema hierboven bekijken, zullen we zien dat we een faseaccumulator hebben waarvan de taak het is om alle mogelijke digitale waarden van een sinusgolf op te slaan, beginnend bij 0 tot 2π. Vervolgens hebben we de SIN ROM wiens taak het is om de fase-informatie om te zetten die later direct kan worden toegewezen aan amplitude. De SIN ROM gebruikt de digitale fase-informatie als een adres voor een opzoektabel en zet de fase-informatie om in amplitude. En als laatste hebben we een 10-bit digitaal naar analoog converter wiens taak het is om de digitale data van SIN ROM te ontvangen en om te zetten in de overeenkomstige analoge spanningen, dat is wat we krijgen van de output. Aan de uitgang hebben we ook een schakelaar die we aan of uit kunnen zetten met een klein beetje softwarecode. Daar zullen we later in het artikel over praten.De details die u hierboven ziet, zijn een zeer uitgeklede versie van wat er in de IC gebeurt, en de meeste details die u hierboven ziet, zijn afkomstig uit het AD9833-gegevensblad, u kunt het ook bekijken voor meer informatie.
Componenten die nodig zijn om de op AD9833 gebaseerde functiegenerator te bouwen
De componenten die nodig zijn om de op AD9833 gebaseerde functiegenerator te bouwen, worden hieronder vermeld, we hebben dit circuit ontworpen met zeer generieke componenten, wat het replicatieproces erg eenvoudig maakt.
- Arduino Nano - 1
- AD9833 DDS-functiegenerator - 1
- 128 x 64 OLED-scherm - 1
- Generieke roterende encoder - 1
- DC-vataansluiting - 1
- LM7809 Spanningsregelaar - 1
- 470uF condensator - 1
- 220uF Condensator - 1
- 104pF condensator - 1
- 10K weerstand - 6
- Tactiele schakelaars - 4
- Schroefaansluiting 5,04 mm - 1
- Vrouwelijke koptekst - 1
- 12V voedingsbron - 1
Op AD9833 gebaseerde functiegenerator - Schematisch diagram
Het volledige schakelschema voor de AD9833 en de op Arduino gebaseerde functiegenerator wordt hieronder weergegeven.
We gaan de AD9833 gebruiken met Arduino om onze gewenste frequentie te genereren. En in deze sectie zullen we alle details uitleggen met behulp van het schema; laat me je een kort overzicht geven van wat er met het circuit gebeurt. Laten we beginnen met de AD9833-module. De AD9833-module is de functiegeneratormodule en is volgens het schema met de Arduino verbonden. Om het circuit van stroom te voorzien, gebruiken we een LM7809-spanningsregelaar-IC, met een degelijke ontkoppelingscondensator, dit is nodig omdat de voedingsruis het uitgangssignaal kan verstoren, wat resulteert in ongewenste uitvoer. Zoals altijd werkt de Arduino als het brein voor dit project. Om de ingestelde frequentie en andere waardevolle informatie weer te geven, hebben we een 128 X 64 OLED-displaymodule aangesloten. Om het frequentiebereik te wijzigen, gebruiken we drie schakelaars. De eerste stelt de frequentie in op Hz, de tweede stelt de uitgangsfrequentie in op KHz en de derde stelt de frequentie in op MHz, we hebben ook een andere knop die kan worden gebruikt om de uitvoer in of uit te schakelen. Eindelijk hebben we de roterende encoder,en we moeten er een pull-up-weerstand aan vastmaken, anders werken die schakelaars niet omdat we de knopdrukgebeurtenis op de pooling-methode controleren. De roterende encoder wordt gebruikt om de frequentie te wijzigen en de tactiele schakelaar in de roterende encoder wordt gebruikt om de ingestelde golfvorm te selecteren.
Op AD9833 gebaseerde functiegenerator - Arduino-code
De volledige code die in dit project is gebruikt, vindt u onderaan deze pagina. Na het toevoegen van de vereiste header-bestanden en source-bestanden, zou je het Arduino-bestand direct moeten kunnen compileren. U kunt de ad9833 Arduino-bibliotheek en andere bibliotheken downloaden via de onderstaande link of u kunt de boardmanager- methode gebruiken om de bibliotheek te installeren.
- Download AD9833 Library door Bill Williams
- Download SSD1306 OLED-bibliotheek van Adafruit
- Download de Adafruit GFX-bibliotheek
De uitleg van de code in de ino. bestand is als volgt. Eerst beginnen we met het opnemen van alle vereiste bibliotheken. De bibliotheek voor de AD9833 DDS-module wordt eerst gevolgd door de bibliotheek voor OLED en de wiskundebibliotheek is vereist voor sommige van onze berekeningen.
#include // LIbrary voor AD9833-module #include
Vervolgens definiëren we alle benodigde invoer- en uitvoerpinnen voor de knoppen, schakelaar, roterende encoder en OLED's.
#define SCREEN_WIDATA_PINH 128 // OLED-display Breedte in pixels #define SCREEN_HEIGHT 64 // OLED-display hoogte, in pixels #define SET_FREQUENCY_HZ A2 // Drukknop om frequentie in Hz in te stellen #define SET_FREQUENCY_KHZ A3 // Drukknop om SET_FREQUENCEN-frequentie in te stellen in Khz #QUZ A6 // Drukknop om de frequentie in Mhz in te stellen #define ENABLE_DISABLE_OUTPUT_PIN A7 // Drukknop om de uitvoer in / uit te schakelen #define FNC_PIN 4 // Fsync vereist door de AD9833-module #define CLK_PIN 8 // Klokpen van de encoder #define DATA_PIN 7 / / Datapin van de encoder #define BTN_PIN 9 // Interne drukknop op de encoder
Daarna definiëren we alle benodigde variabelen die in deze code vereist zijn. Eerst definiëren we een integer variabele teller die de roterende encoder waarde zal opslaan. De volgende twee variabelen clockPin en clockPinState slaan het pin-beeld op dat nodig is om de richting van de encoder te begrijpen. We hebben een tijd variabele die de huidige timer-counter waarden houdt, deze variabele wordt gebruikt voor de knop debouncing. Vervolgens hebben we een ongetekende lange variabele moduleFrequentie die de berekende frequentie bevat die zal worden toegepast. Vervolgens hebben we de debounce-vertraging. Deze vertraging kan naar wens worden aangepast. Vervolgens hebben we drie booleaanse variabelen set_frequency_hz,set_frequency_Khz, en set_frequency_Mhz deze drie variabelen worden gebruikt om de huidige instelling van de module te bepalen. We zullen er later in het artikel meer in detail over praten. Vervolgens hebben we de variabele die de status van de uitvoergolfvorm opslaat, de standaard uitvoergolfvorm is een sinusgolf. En tot slot hebben we de variabele encoder_btn_count die het aantal encoderknoppen bevat dat wordt gebruikt om de uitvoergolfvorm in te stellen.
int teller = 1; // Deze tellerwaarde zal toenemen of afnemen als de roterende encoder in de klokPin wordt gedraaid; // Tijdelijke aanduiding voor pin-status gebruikt door de roterende encoder int clockPinState; // Tijdelijke aanduiding voor pin-status gebruikt door de roterende encoder lange tijd niet ondertekend = 0; // Gebruikt voor het ontkrachten van niet-ondertekende lange moduleFrequency; // gebruikt om de uitgangsfrequentie lang debounce = 220 in te stellen; // Debounce delay bool btn_state; // gebruikt om de uitvoer van de AD98333-module uit te schakelen bool set_frequency_hz = 1; // Defult frequentie van de AD9833 Module bool set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // Opstartgolfvorm van de module int encoder_btn_count = 0; // gebruikt om de encoderknop te controleren druk op Volgende, we hebben onze twee objecten, een is voor het OLED-display en een ander is voor de AD9833-module.Adafruit_SSD1306-display (SCREEN_WIDATA_PINH, SCREEN_HEIGHT, & Wire, -1); AD9833 gen (FNC_PIN);
Vervolgens hebben we onze setup () -functie, in die setup-functie beginnen we met het inschakelen van de Serial voor foutopsporing. We initialiseren de AD9833-module met behulp van de begin () - methode. Vervolgens stellen we alle toegewezen roterende encoderpennen in als invoer. En we slaan de waarde van de klokpin op in de variabele clockPinState, dit is een noodzakelijke stap voor de roterende encoder.
Vervolgens stellen we alle knoppennen in als invoer en schakelen we het OLED-display in met behulp van de methode display.begin () , en we controleren ook op eventuele fouten met een if-statement . Wanneer dat is gebeurd, maken we het display leeg en drukken we een opstartscherm af, voegen we een vertraging van 2 seconden toe, wat ook de vertraging is voor het opstartscherm, en tot slot noemen we de functie update_display () die het scherm leegmaakt en de weer te geven. De details van de update_display () - methode zullen later in het artikel worden besproken.
ongeldige setup () {Serial.begin (9600); // Schakel Serial @ 9600 baud gen.Begin () in; // Dit MOET het eerste commando zijn na het declareren van het AD9833 object pinMode (CLK_PIN, INPUT); // Pinnen instellen als input pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Pinnen instellen als input pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adres 0x3D voor 128x64 Serial.println (F ("SSD1306-toewijzing mislukt")); voor (;;); } display.clearDisplay (); // Wis het scherm display.setTextSize (2); // Set tekstgrootte display.setTextColor (WIT); // set LCD-kleurendisplay. setCursor (30, 0); // Zet cursorpositie display.println ("AD9833"); // Druk het display van deze tekst af.setCursor (17, 20); // Stel cursorpositie in display.println ("Functie"); // Druk de this Text display.setCursor (13, 40); // Stel cursorpositie in display.println ("Generator"); // Druk deze tekst af display.display (); // Update de weergave-vertraging (2000); // Vertraging van 2 SEC update_display (); // Call update_display Function}
Vervolgens hebben we onze functie loop (), alle belangrijke functionaliteiten worden in de lussectie geschreven.
Eerst lezen we de Clock-pin van de Rotary encoder en slaan deze op in de variabele clockPin die we eerder hebben gedeclareerd. Vervolgens controleren we in de if- instructie of de vorige waarde van de pin en de huidige waarde van de pin vergelijkbaar zijn of niet, en we controleren ook de huidige waarde van de pin. Als het allemaal waar is, controleren we de datapin, als dat waar is, betekent dit dat de encoder tegen de klok in draait en verlagen we de tellerwaarde met behulp van een tegencommando. Anders verhogen we de tellerwaarde met het commando counter ++. Ten slotte plaatsen we nog een if- statement om de minimumwaarde in te stellen op 1. Vervolgens werken we de clockPinState bij met de huidige clockPinwaarde voor toekomstig gebruik.
void loop () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {counter -; } else {counter ++; // Encoder draait CW dus increment} if (counter <1) counter = 1; Serial.println (teller); update_display (); }
Vervolgens hebben we onze code om een druk op een knop te detecteren. In deze sectie hebben we de knop in de encoder gedetecteerd met behulp van enkele geneste if-statements, if (digitalRead (BTN_PIN) == LOW && millis () - time> denounce), in dit statement controleren we eerst of de knop pin is laag of niet, als het laag is, dan wordt het ingedrukt. Vervolgens controleren we opnieuw de timerwaarde met de debounce-vertraging, als beide uitspraken waar zijn, dan verklaren we dat het een geslaagde druk op de knop is als we de waarde encoder_btn_count verhogen. Vervolgens declareren we nog een if-statement om de maximale tellerwaarde in te stellen op 2, we hebben het nodig omdat we het gebruiken om de uitvoergolfvorm in te stellen .De opeenvolgende drie if-statements doen dat, als de waarde nul is, wordt de sinusgolfvorm geselecteerd, als het er één is, is het een blokgolf en als de waarde 2 is, is het een driehoekige golf. In alle drie deze if-instructies werken we de weergave bij met de functie update_display () . En tot slot werken we de tijdvariabele bij met de huidige timer-tellerwaarde.
// Als we een LOW-signaal detecteren, wordt de knop ingedrukt als (digitalRead (BTN_PIN) == LOW && millis () - tijd> debounce) {encoder_btn_count ++; // Verhoog de waarden if (encoder_btn_count> 2) // als de waarde groter is dan 2, zet deze dan terug op 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// als de waarde 0 is, is sinusgolf geselecteerd waveSelect = "SIN"; // update de stringvariabele met sin waarde update_display (); // update de weergave} if (encoder_btn_count == 1) {// als de waarde 1 blokgolf is is geselecteerd waveSelect = "SQR"; // update de stringvariabele met SQR-waarde update_display (); // update de weergave} if (encoder_btn_count == 2) {// als de waarde 1 is Driehoekige golf is geselecteerd waveSelect = "TRI"; // update de stringvariabele met TRI-waarde update_display ();// update de weergave} time = millis (); // update de tijdsvariabele}
Vervolgens definiëren we alle benodigde code die nodig is om alle knoppen in te stellen met een debounce-vertraging. Omdat de knoppen zijn verbonden met de analoge pinnen van de Arduino, gebruiken we het analoge leescommando om een druk op de knop te identificeren als de analoge leeswaarde onder de 30 komt, dan detecteren we dat de knop succesvol is ingedrukt en wachten we 200 ms om controleer of het een daadwerkelijke druk op de knop is of alleen een geluid. Als deze bewering waar is, kennen we de booleaanse variabelen waarden toe die worden gebruikt om de Hz-, Khz- en Mhz-waarden van de functiegenerator in te stellen. Vervolgens werken we de weergave bij en werken we de tijdsvariabele bij. Dat doen we voor alle vier de knoppen die met de Arduino zijn verbonden.
if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - tijd> debounce) {set_frequency_hz = 1; // update booleaanse waarden set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // update de weergavetijd = millis (); // update de tijdvariabele} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - tijd> debounce) {set_frequency_hz = 0; // update booleaanse waarden set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = teller * 1000; update_display (); // update de weergavetijd = millis (); // update de tijdvariabele} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - tijd> debounce) {// controleer analoge pin met dempingsvertraging set_frequency_hz = 0; // update booleaanse waarden set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = teller * 1000000; update_display ();// update de weergavetijd = millis (); // update de tijdvariabele} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - time> debounce) {// controleer analoge pin met debounce-vertraging btn_state =! btn_state; // Keer de knopstatus om gen.EnableOutput (btn_state); // Schakel de uitvoer van de functiegenerator in / uit, afhankelijk van de status van de knop update_display (); // update de weergavetijd = millis (); // update de tijdvariabele}}// update de tijdsvariabele}}// update de tijdsvariabele}}
Eindelijk hebben we onze update_display () functie. In deze functie hebben we veel meer gedaan dan alleen dit beeldscherm updaten, omdat een bepaald gedeelte van het beeldscherm niet kan worden bijgewerkt in een OLED. Om het bij te werken, moet u het opnieuw schilderen met nieuwe waarden. Dit maakt het coderingsproces een stuk moeilijker.
Binnen deze functie beginnen we met het leegmaken van het display. Vervolgens stellen we onze vereiste tekstgrootte in. Daarna zetten we onze cursor en afgedrukte Function Generator met de display.println ("Function Function"); opdracht. We stellen de tekstgrootte opnieuw in op 2 en de cursor op (0,20) met behulp van de functie display.setCursor (0, 20).
Dit is waar we de informatie afdrukken voor welke golf het is.
display.clearDisplay (); // Maak eerst het display leeg display.setTextSize (1); // set tekstgrootte display.setCursor (10, 0); // Zet cursorpositie display.println ("Function Generator"); // print de tekst display.setTextSize (2); // set text Size display.setCursor (0, 20); // Stel cursor positie in
Vervolgens controleren we de booleaanse variabelen op frequentiedetails en werken we de waarde in de variabele moduleFrequency bij. Dit doen we voor Hz, kHz en MHz waarden. Vervolgens controleren we de variabele waveSelect en bepalen welke golf is geselecteerd. Nu hebben we de waarden om het golftype en de frequentie in te stellen.
if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// controleer of de knop voor het instellen van de frequentie in Hz is ingedrukt moduleFrequency = counter; // update de moduleFrequency-variabele met de huidige tellerwaarde} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// controleer of de knop voor het instellen van de frequentie in KHz is ingedrukt moduleFrequency = counter * 1000; // update de moduleFrequency-variabele met de huidige tellerwaarde, maar we vermenigvuldigen 1000 om het op KHZ} te zetten als (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// controleer of de knop voor het instellen van de frequentie in MHz is ingedrukt moduleFrequency = teller * 1000000; if (moduleFrequency> 12000000) {moduleFrequency = 12000000;// laat de frequentie niet raspen dat 12Mhz-teller = 12; }} if (waveSelect == "SIN") {// Sinusgolf is geselecteerd display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// Sqr wave is geselecteerd display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave is geselecteerd display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // update de AD9833-module. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr wave is geselecteerd display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave is geselecteerd display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // update de AD9833-module. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr wave is geselecteerd display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave is geselecteerd display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // update de AD9833-module. Serial.println (moduleFrequency); }
We zetten de cursor opnieuw en werken de tellerwaarden bij. We controleren opnieuw de boolean om het frequentiebereik op het display bij te werken, we moeten dit doen omdat het werkingsprincipe van de OLED erg raar is.
display.setCursor (45, 20); display.println (teller); // print de tellerinformatie op het display. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // print Hz op het display display.display (); // wanneer alles is ingesteld, update het display} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // wanneer alles is ingesteld, update het display} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // wanneer alles is ingesteld, update het display}
Vervolgens controleren we de variabele voor het indrukken van de knop om de uitvoer aan / uit te printen naar de OLED. Nogmaals, dit moet worden gedaan vanwege de OLED-module.
if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Uitgang AAN"); // print output op het display display.display (); display.setTextSize (2); } anders {display.setTextSize (1); display.setCursor (65, 45); display.print ("Uitgang UIT"); // print output naar het display display.display (); display.setTextSize (2); }
Dit markeert het einde van ons coderingsproces. Als u op dit punt in de war bent, kunt u de opmerkingen in de code raadplegen voor meer informatie.
Testen van de op AD9833 gebaseerde functiegenerator
Om het circuit te testen, wordt de bovenstaande opstelling gebruikt. Zoals u kunt zien, hebben we een 12V DC-voedingsadapter aangesloten op de DC barrel-aansluiting en hebben we de Hantek-oscilloscoop aangesloten op de uitgang van het circuit. We hebben ook de oscilloscoop op de laptop aangesloten om de uitgangsfrequentie te visualiseren en te meten.
Zodra dit was gebeurd, stellen we de uitgangsfrequentie in op 5 Khz met behulp van de roterende encoder en testen we de uitgangssinusgolf en ja hoor, het is een 5 kHz sinusgolf aan de uitgang.
Vervolgens hebben we de uitvoergolfvorm gewijzigd in een driehoekige golf, maar de frequentie is hetzelfde gebleven, de uitvoergolfvorm wordt hieronder weergegeven.
Daarna veranderden we de output in een blokgolf en observeerden we de output, en het was een perfecte blokgolf.
We hebben ook het frequentiebereik gewijzigd en de output getest, en het werkte goed.
Verdere verbeteringen
Dit circuit is slechts een proof of concept en behoeft verdere verbeteringen. Ten eerste hebben we een PCB van goede kwaliteit nodig en een BNC-connector van goede kwaliteit voor de uitvoer, anders kunnen we geen hogere frequentie verkrijgen. De amplitude van de module is erg laag, dus om dat te verbeteren, hebben we enkele op-amp-circuits nodig om de uitgangsspanning te versterken. Om de uitgangsamplitude te variëren kan een potentiometer worden aangesloten. Een schakelaar om het signaal te compenseren kan worden aangesloten; dit is ook een must-have functie. En verder, de code heeft veel verbetering nodig omdat het een kleine buggy is. Ten slotte moeten OLED-schermen worden gewijzigd, anders is het onmogelijk om gemakkelijk te begrijpen code te schrijven.
Dit markeert het einde van deze tutorial, ik hoop dat je het artikel leuk vond en iets nieuws hebt geleerd. Als je vragen hebt over het artikel, kun je deze achterlaten in het commentaargedeelte hieronder of je kunt ons Elektronicaforum gebruiken.