Costruisci il tuo generatore di funzioni con arduino e il modulo generatore di funzioni dds ad9833

Se sei un appassionato di elettronica come me che vuole modificare diversi circuiti elettronici, a volte diventa obbligatorio avere un generatore di funzioni decente. Ma possederne uno è un problema perché tali attrezzature di base possono costare una fortuna. Costruire la tua attrezzatura di prova non è solo più economico, ma anche un ottimo modo per migliorare le tue conoscenze.

Quindi, in questo articolo, costruiremo un semplice generatore di segnale con Arduino e modulo generatore di funzioni DDS AD9833 che può produrre onde sinusoidali, quadrate e triangolari con una frequenza massima di 12 MHz in uscita. Infine, testeremo la frequenza di uscita con l'aiuto del nostro oscilloscopio.

Abbiamo già costruito un generatore di onde sinusoidali semplice, un generatore di onde quadre e un generatore di onde triangolari con l'aiuto di circuiti analogici di base. Puoi verificarli se stai cercando alcuni circuiti generatori di forme d'onda di base. Inoltre, se desideri creare un generatore di funzioni Arduino più economico senza utilizzare il modulo AD9833, puoi dare un'occhiata al progetto DIY Arduino Waveform Generator.

Cos'è un generatore di funzioni DDS?

Come suggerisce il nome, un generatore di funzioni è un dispositivo che può emettere una forma d'onda specifica con una frequenza specifica al momento dell'impostazione. Ad esempio, si consideri che si dispone di un filtro LC per il quale si desidera testare la risposta in frequenza di uscita, è possibile farlo facilmente con l'aiuto di un generatore di funzioni. Tutto quello che devi fare è impostare la frequenza di uscita e la forma d'onda desiderate, quindi puoi abbassarle o alzarle per testare la risposta. Questo era solo un esempio, puoi fare più cose con esso man mano che l'elenco va avanti.

DDS è l'acronimo di Direct Digital Synthesis. È un tipo di generatore di forme d' onda che utilizza convertitori da digitale ad analogico (DAC) per costruire un segnale da zero. Questo metodo viene utilizzato specificamente per generare un'onda sinusoidale. Ma l'IC che stiamo usando può produrre segnali d'onda quadrata o triangolare. Le operazioni che sono avvenute all'interno di un chip DDS sono digitali, quindi può cambiare la frequenza molto velocemente o può passare da un segnale all'altro molto rapidamente. Questo dispositivo ha una risoluzione di frequenza fine con un ampio spettro di frequenze.

Comprendere il funzionamento del circuito integrato del generatore di funzioni AD9833

Al centro del nostro progetto c'è il CI del generatore di forme d'onda programmabile AD9833, progettato e sviluppato da dispositivi analogici. È un generatore di forme d'onda programmabile a bassa potenza in grado di produrre onde sinusoidali, triangolari e quadre con una frequenza massima di 12 MHz. È un circuito integrato davvero unico che è in grado di alterare la frequenza e la fase di uscita con un semplice programma software. Ha un'interfaccia SPI a 3 fili, motivo per cui la comunicazione con questo IC diventa molto semplice e facile. Lo schema a blocchi funzionale di questo IC è mostrato di seguito.

Il funzionamento di questo IC è molto semplice. Se diamo uno sguardo al diagramma a blocchi funzionale sopra, osserveremo che abbiamo un Accumulatore di fase il cui compito è memorizzare tutti i possibili valori digitali di un'onda sinusoidale, a partire da 0 a 2π. Successivamente, abbiamo la ROM SIN il cui compito è convertire le informazioni di fase che possono essere successivamente mappate direttamente in ampiezza. La ROM SIN utilizza le informazioni sulla fase digitale come indirizzo in una tabella di ricerca e converte le informazioni sulla fase in ampiezza. Infine, abbiamo un convertitore da digitale ad analogico a 10 bit il cui compito è quello di ricevere i dati digitali dalla ROM SIN e convertirli nelle corrispondenti tensioni analogiche, che è ciò che otteniamo dall'uscita. In uscita, abbiamo anche un interruttore che possiamo attivare o disattivare con un piccolo codice software. Ne parleremo più avanti nell'articolo.I dettagli che vedi sopra sono una versione molto ridotta di ciò che sta accadendo all'interno dell'IC e la maggior parte dei dettagli che vedi sopra sono presi dalla scheda tecnica di AD9833, puoi anche verificarla per ulteriori informazioni.

Componenti necessari per costruire il generatore di funzioni basato su AD9833

I componenti richiesti per costruire il generatore di funzioni basato su AD9833 sono elencati di seguito, abbiamo progettato questo circuito con componenti molto generici, il che rende il processo di replica molto semplice.

Arduino Nano - 1
Generatore di funzioni DDS AD9833 - 1
Display OLED 128 x 64-1
Encoder rotativo generico - 1
Jack Barilotto DC - 1
Regolatore di tensione LM7809 - 1
Condensatore 470uF - 1
Condensatore 220uF - 1
Condensatore 104pF - 1
Resistenza 10K - 6
Interruttori tattili - 4
Terminale a vite 5,04 mm - 1
Intestazione femminile - 1
Fonte di alimentazione 12V - 1

Generatore di funzioni basato su AD9833 - Diagramma schematico

Di seguito è mostrato lo schema circuitale completo per AD9833 e generatore di funzioni basato su Arduino.

Useremo AD9833 con Arduino per generare la nostra frequenza desiderata. E in questa sezione spiegheremo tutti i dettagli con l'aiuto dello schema; lascia che ti dia una breve panoramica di ciò che sta accadendo con il circuito. Cominciamo con il modulo AD9833. Il modulo AD9833 è il modulo generatore di funzioni ed è collegato ad Arduino secondo lo schema. Per alimentare il circuito, stiamo usando un IC regolatore di tensione LM7809, con un discreto condensatore di disaccoppiamento, questo è necessario perché il rumore di alimentazione può interferire con il segnale di uscita con conseguente uscita indesiderata. Come sempre, Arduino sta lavorando come cervello per questo progetto. Per visualizzare la frequenza impostata e altre preziose informazioni, abbiamo collegato un modulo display OLED 128 X 64. Per modificare la gamma di frequenza, utilizziamo tre interruttori. Il primo imposta la frequenza su Hz, il secondo imposta la frequenza di uscita su KHz e il terzo imposta la frequenza su MHz, abbiamo anche un altro pulsante che può essere utilizzato per abilitare o disabilitare l'uscita. Infine, abbiamo l'encoder rotativo,e dobbiamo collegare un resistore di pull-up con esso altrimenti quegli interruttori non funzioneranno perché stiamo controllando l'evento di pressione del pulsante sul metodo di pooling. Il codificatore rotante viene utilizzato per modificare la frequenza e l'interruttore tattile all'interno del codificatore rotante viene utilizzato per selezionare la forma d'onda impostata.

Generatore di funzioni basato su AD9833 - Codice Arduino

Il codice completo utilizzato in questo progetto si trova in fondo a questa pagina. Dopo aver aggiunto i file di intestazione e di origine richiesti, dovresti essere in grado di compilare direttamente il file Arduino. È possibile scaricare la libreria Arduino ad9833 e altre librerie dal collegamento indicato di seguito oppure è possibile utilizzare il metodo del gestore della scheda per installare la libreria.

Scarica AD9833 Library di Bill Williams
Scarica la libreria OLED SSD1306 di Adafruit
Scarica la libreria GFX di Adafruit

La spiegazione del codice in ino. il file è il seguente. Innanzitutto, iniziamo includendo tutte le librerie richieste. La libreria per il modulo DDS AD9833 viene prima seguita dalla libreria per OLED e la libreria matematica è richiesta per alcuni dei nostri calcoli.

#include // Libreria per AD9833 Modulo #include // Libreria Wire per OLED #include // Libreria di supporto per OLED #include // Libreria OLED #include // Libreria matematica

Successivamente, definiamo tutti i pin di input e output necessari per pulsanti, interruttore, codificatore rotante e OLED.

#define SCREEN_WIDATA_PINH 128 // Larghezza display OLED in pixel #define SCREEN_HEIGHT 64 // Altezza display OLED, in pixel #define SET_FREQUENCY_HZ A2 // Pulsante per impostare la frequenza in Hz #define SET_FREQUENCY_KHZ A3 // Pulsante per impostare la frequenza in Khz #QUdefine SET_MHZ A6 // Pulsante per impostare la frequenza in Mhz #define ENABLE_DISABLE_OUTPUT_PIN A7 // Pulsante per abilitare / disabilitare l'uscita #define FNC_PIN 4 // Fsync richiesto dal modulo AD9833 #define CLK_PIN 8 // Pin orologio dell'encoder #define DATA_PIN 7 / / Data Pin dell'encoder #define BTN_PIN 9 // Pulsante interno sull'encoder

Successivamente, definiamo tutte le variabili necessarie che sono richieste in questo codice. Innanzitutto, definiamo un contatore di variabili intere che memorizzerà il valore dell'encoder rotativo. Le successive due variabili clockPin e clockPinState memorizzano la statua del pin necessaria per comprendere la direzione dell'encoder. Abbiamo una variabile temporale che contiene i valori correnti del contatore del timer, questa variabile viene utilizzata per l'antirimbalzo dei pulsanti. Successivamente, abbiamo un modulo variabile lungo senza segno Frequenza che contiene la frequenza calcolata che verrà applicata. Successivamente, abbiamo il ritardo antirimbalzo. Questo ritardo può essere regolato secondo necessità. Successivamente, abbiamo tre variabili booleane set_frequency_hz,set_frequency_Khz e set_frequency_Mhz queste tre variabili vengono utilizzate per determinare l'impostazione corrente del modulo. Ne parleremo più in dettaglio più avanti nell'articolo. Successivamente, abbiamo la variabile che memorizza lo stato della forma d'onda di uscita, la forma d'onda di uscita predefinita è un'onda sinusoidale. Infine, abbiamo la variabile encoder_btn_count che contiene il conteggio del pulsante dell'encoder che viene utilizzato per impostare la forma d'onda di uscita.

int counter = 1; // Questo valore del contatore aumenterà o diminuirà se quando si ruota l'encoder rotativo int clockPin; // Segnaposto per lo stato del pin utilizzato dall'encoder rotativo int clockPinState; // Segnaposto per lo stato del pin utilizzato dall'encoder rotativo unsigned long time = 0; // Usato per il debouncing lungo moduleFrequency non firmato; // usato per impostare la frequenza di uscita long debounce = 220; // Ritardo antirimbalzo bool btn_state; // utilizzato per abilitare l'output di disabilitazione del modulo AD98333 bool set_frequency_hz = 1; // Frequenza di defult del modulo AD9833 bool set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // Forma d'onda di avvio del modulo int encoder_btn_count = 0; // usato per controllare il pulsante dell'encoder premere Avanti, abbiamo i nostri due oggetti uno è per il display OLED e un altro è per il modulo AD9833.Display Adafruit_SSD1306 (SCREEN_WIDATA_PINH, SCREEN_HEIGHT, & Wire, -1); AD9833 gen (FNC_PIN);

Successivamente, abbiamo la nostra funzione setup (), in quella funzione di configurazione, iniziamo con l'abilitazione del seriale per il debug. Inizializziamo il modulo AD9833 con l'aiuto del metodo begin (). Successivamente, impostiamo tutti i pin dell'encoder rotativo assegnati come Input. E memorizziamo il valore del pin clock nella variabile clockPinState, questo è un passaggio necessario per l'encoder rotativo.

Successivamente, impostiamo tutti i pin dei pulsanti come input e abilitiamo il display OLED con l'aiuto del metodo display.begin () , e controlliamo anche eventuali errori con un'istruzione if . Al termine, cancelliamo il display e stampiamo una schermata iniziale di avvio, aggiungiamo un ritardo di 2 secondi che è anche il ritardo per la schermata iniziale e infine chiamiamo la funzione update_display () che cancella lo schermo e aggiorna visualizzare ancora una volta. I dettagli del metodo update_display () saranno discussi più avanti nell'articolo.

void setup () {Serial.begin (9600); // Abilita seriale a 9600 baud gen.Begin (); // Questo DEVE essere il primo comando dopo la dichiarazione dell'oggetto AD9833 pinMode (CLK_PIN, INPUT); // Impostazione dei pin come input pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Impostazione dei pin come input pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Indirizzo 0x3D per Serial.println 128x64 (F ("Allocazione SSD1306 non riuscita")); per (;;); } display.clearDisplay (); // Cancella lo schermo display.setTextSize (2); // Imposta la dimensione del testo display.setTextColor (WHITE); // imposta display LCD a colori.setCursor (30, 0); // Imposta la posizione del cursore display.println ("AD9833"); // Stampa il display di questo testo.setCursor (17, 20); // Imposta la posizione del cursore display.println ("Funzione"); // Stampa questo testo display.setCursor (13, 40); // Imposta la posizione del cursore display.println ("Generator"); // Stampa questo testo display.display (); // Aggiorna il ritardo di visualizzazione (2000); // Ritardo di 2 SEC update_display (); // Chiama la funzione update_display}

Successivamente, abbiamo la nostra funzione loop (), tutte le principali funzionalità sono scritte nella sezione loop.

Per prima cosa, leggiamo il pin Clock del codificatore a rotazione e lo memorizziamo nella variabile clockPin che abbiamo dichiarato in precedenza. Successivamente, nell'istruzione if , controlliamo se il valore precedente del pin e il valore corrente del pin sono simili o meno e controlliamo anche il valore corrente del pin. Se è tutto vero, controlliamo per pin di dati, se è vero che i mezzi di encoder sta ruotando in senso antiorario e che viene decrementata il valore del contatore con l'aiuto di counter-- comando. Altrimenti incrementiamo il valore del contatore con il comando counter ++. Infine, inseriamo un'altra istruzione if per impostare il valore minimo su 1. Successivamente, aggiorniamo il clockPinState con il clockPin correntevalore per un uso futuro.

void loop () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {counter -; } else {counter ++; // Il codificatore ruota in senso orario quindi incrementa} if (counter <1) counter = 1; Serial.println (contatore); update_display (); }

Successivamente, abbiamo il nostro codice per rilevare la pressione di un pulsante. In questa sezione, abbiamo rilevato il pulsante all'interno dell'encoder con l'aiuto di alcune istruzioni if annidate, if (digitalRead (BTN_PIN) == LOW && millis () - time> denounce), in questa istruzione, controlliamo prima se il pulsante il pin è basso o no, se è basso, allora è premuto. Quindi controlliamo di nuovo il valore del timer con il ritardo antirimbalzo, se entrambe le istruzioni sono vere, quindi la dichiariamo un'azione di pressione del pulsante riuscita, in tal caso incrementiamo il valore encoder_btn_count. Successivamente, dichiariamo un'altra istruzione if per impostare il valore massimo del contatore su 2, ne abbiamo bisogno perché la stiamo usando per impostare la forma d'onda di uscita.Le tre istruzioni if consecutive lo fanno, se il valore è zero, viene selezionata la forma d'onda sinusoidale, se è una, è un'onda quadra e se il valore è 2, è un'onda triangolare. In tutte e tre queste istruzioni if, aggiorniamo il display con la funzione update_display () . Infine, aggiorniamo la variabile time con il valore corrente del contatore del timer.

// Se rileviamo un segnale LOW, il pulsante viene premuto if (digitalRead (BTN_PIN) == LOW && millis () - time> debounce) {encoder_btn_count ++; // Incrementa i valori if (encoder_btn_count> 2) // se il valore è maggiore di 2 resettalo a 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// se il valore è 0 è selezionata l'onda sinusoidale waveSelect = "SIN"; // aggiorna la variabile stringa con il valore sin update_display (); // aggiorna il display} if (encoder_btn_count == 1) {// se il valore è 1 onda quadra è selezionato waveSelect = "SQR"; // aggiorna la variabile stringa con il valore SQR update_display (); // aggiorna il display} if (encoder_btn_count == 2) {// se il valore è 1 è selezionata un'onda triangolare waveSelect = "TRI"; // aggiorna la variabile stringa con il valore TRI update_display ();// aggiorna il display} time = millis (); // aggiorna la variabile temporale}

Successivamente, definiamo tutto il codice necessario richiesto per impostare tutti i pulsanti con un ritardo antirimbalzo. Poiché i pulsanti sono collegati ai pin analogici di Arduino, stiamo usando il comando di lettura analogica per identificare la pressione di un pulsante se il valore di lettura analogico raggiunge sotto 30, quindi rileviamo che è stato premuto il pulsante con successo e aspettiamo 200 ms controllare se si tratta di una pressione effettiva di un pulsante o solo di un rumore. Se questa affermazione è vera, assegniamo alle variabili booleane i valori utilizzati per impostare i valori Hz, Khz e Mhz del generatore di funzioni. Successivamente, aggiorniamo la visualizzazione e aggiorniamo la variabile temporale. Lo facciamo per tutti e quattro i pulsanti collegati ad Arduino.

if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - time> debounce) {set_frequency_hz = 1; // aggiorna i valori booleani set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // aggiorna il display time = millis (); // aggiorna la variabile time} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // aggiorna i valori booleani set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = counter * 1000; update_display (); // aggiorna il display time = millis (); // aggiorna la variabile del tempo} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - time> debounce) {// controlla il pin analogico con ritardo di debounce set_frequency_hz = 0; // aggiorna i valori booleani set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = counter * 1000000; update_display ();// aggiorna il display time = millis (); // aggiorna la variabile time} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - time> debounce) {// controlla il pin analogico con ritardo antirimbalzo btn_state =! btn_state; // Inverte lo stato del pulsante gen.EnableOutput (btn_state); // Abilita / disabilita l'output del generatore di funzioni a seconda dello stato del pulsante update_display (); // aggiorna il display time = millis (); // aggiorna la variabile temporale}}// aggiorna la variabile temporale}}// aggiorna la variabile temporale}}

Infine, abbiamo la nostra funzione update_display (). In questa funzione, abbiamo fatto molto di più che aggiornare questo display perché una certa parte del display non può essere aggiornata in un OLED. Per aggiornarlo, devi ridipingerlo con nuovi valori. Questo rende il processo di codifica molto più difficile.

All'interno di questa funzione, iniziamo con la cancellazione del display. Successivamente, impostiamo la dimensione del testo richiesta. Successivamente, impostiamo il cursore e il generatore di funzioni stampato con display.println ("Funzione Funzione"); comando. Impostiamo nuovamente la dimensione del testo su 2 e il cursore su (0,20) con l'aiuto della funzione display.setCursor (0, 20).

Qui è dove stampiamo le informazioni per quale onda è.

display.clearDisplay (); // Cancella prima il display display.setTextSize (1); // imposta la dimensione del testo display.setCursor (10, 0); // Imposta la posizione del cursore display.println ("Generatore di funzioni"); // stampa il testo display.setTextSize (2); // imposta la dimensione del testo display.setCursor (0, 20); // Imposta la posizione del cursore

Successivamente, controlliamo le variabili booleane per i dettagli della frequenza e aggiorniamo il valore nella variabile moduleFrequency. Lo facciamo per i valori Hz, kHz e MHz. Successivamente, controlliamo la variabile waveSelect e identifichiamo quale onda è selezionata. Ora abbiamo i valori per impostare il tipo di onda e la frequenza.

if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// controlla se il pulsante per l'impostazione della frequenza in Hz è premuto moduleFrequency = counter; // aggiorna la variabile moduleFrequency con il valore corrente del contatore} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// controlla se il pulsante per impostare la frequenza in KHz è premuto moduleFrequency = counter * 1000; // aggiorna la variabile moduleFrequency con il valore corrente del contatore ma moltiplichiamo 1000 per impostarlo su KHZ} se (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// controlla se il pulsante per impostare la frequenza in MHz è premuto moduleFrequency = contatore * 1000000; if (moduleFrequency> 12000000) {moduleFrequency = 12000000;// non lasciare che la frequenza sia maggiore di un contatore a 12 Mhz = 12; }} if (waveSelect == "SIN") {// Sine wave è selezionato display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// Sqr wave è selezionato display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave è selezionato display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // aggiorna il modulo AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr wave è selezionato display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave è selezionato display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // aggiorna il modulo AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr wave è selezionato display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave è selezionato display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // aggiorna il modulo AD9833. Serial.println (moduleFrequency); }

Impostiamo nuovamente il cursore e aggiorniamo i valori del contatore. Ancora una volta controlliamo il valore booleano per aggiornare la gamma di frequenze sul display, dobbiamo farlo perché il principio di funzionamento dell'OLED è molto strano.

display.setCursor (45, 20); display.println (contatore); // stampa le informazioni del contatore sul display. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // stampa Hz sul display display.display (); // quando tutto è impostato aggiorna il display} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // quando tutto è impostato aggiorna il display} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // quando tutto è impostato aggiorna il display}

Successivamente, controlliamo la variabile di pressione del pulsante per stampare l'output on / off sull'OLED. Anche in questo caso è necessario farlo a causa del modulo OLED.

if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Uscita ON"); // stampa l'output sul display display.display (); display.setTextSize (2); } else {display.setTextSize (1); display.setCursor (65, 45); display.print ("Uscita OFF"); // stampa l'output sul display display.display (); display.setTextSize (2); }

Questo segna la fine del nostro processo di codifica. Se sei confuso a questo punto, puoi controllare i commenti nel codice per ulteriori informazioni.

Test del generatore di funzioni basato su AD9833

Per testare il circuito, viene utilizzata la configurazione di cui sopra. Come puoi vedere, abbiamo collegato un adattatore di alimentazione CC da 12 V al jack a barilotto CC e abbiamo collegato l'oscilloscopio Hantek all'uscita del circuito. Abbiamo anche collegato l'oscilloscopio al laptop per visualizzare e misurare la frequenza di uscita.

Una volta fatto questo, impostiamo la frequenza di uscita a 5 Khz con l'aiuto dell'encoder rotativo e testiamo l'onda sinusoidale in uscita e, abbastanza sicuro, è un'onda sinusoidale di 5 Khz in uscita.

Successivamente, abbiamo modificato la forma d'onda di uscita in un'onda triangolare ma la frequenza è rimasta la stessa, la forma d'onda di uscita è mostrata di seguito.

Quindi abbiamo cambiato l'uscita in un'onda quadra e abbiamo osservato l'uscita, ed era un'onda quadra perfetta.

Abbiamo anche modificato le gamme di frequenza e testato l'uscita, e funzionava bene.

Ulteriori miglioramenti

Questo circuito è solo una dimostrazione del concetto e necessita di ulteriori miglioramenti. Innanzitutto, abbiamo bisogno di un PCB di buona qualità e di un connettore BNC di buona qualità per l'uscita altrimenti non possiamo ottenere una frequenza più alta. L'ampiezza del modulo è molto bassa, quindi per migliorarla, abbiamo bisogno di alcuni circuiti op-amp per amplificare la tensione di uscita. È possibile collegare un potenziometro per variare l'ampiezza di uscita. È possibile collegare un interruttore per l'offset del segnale; anche questa è una caratteristica indispensabile. Inoltre, il codice necessita di molti miglioramenti poiché è un po 'difettoso. Infine, i display OLED devono essere modificati altrimenti è impossibile scrivere codice facilmente comprensibile.

Questo segna la fine di questo tutorial, spero che l'articolo ti sia piaciuto e abbia imparato qualcosa di nuovo. Se hai domande sull'articolo, puoi lasciarle nella sezione commenti qui sotto o puoi utilizzare il nostro Forum di elettronica.