- Mi az a DDS funkciógenerátor?
- Ismerje meg az AD9833 funkciógenerátor IC működését
- Az AD9833 alapú funkciógenerátor felépítéséhez szükséges alkatrészek
- AD9833 alapú funkciógenerátor - sematikus ábra
- AD9833 alapú funkciógenerátor - Arduino kód
- Az AD9833 alapú funkciógenerátor tesztelése
- További fejlesztések
Ha olyan elektronikus rajongó vagy, mint én, aki különböző elektronikus áramkörökkel akar trükközni, néha kötelezővé válik egy tisztességes Funkciógenerátor. De az egyik birtoklása problémát jelent, mert az ilyen alapfelszerelések egy vagyonba kerülhetnek. Saját tesztberendezés megépítése nemcsak olcsóbb, hanem egyben nagyszerű módja is ismereteinek bővítésére.
Tehát ebben a cikkben egy egyszerű jelgenerátort fogunk építeni az Arduino és az AD9833 DDS funkciógenerátor modullal, amely szinusz, négyzet és háromszög hullámokat képes létrehozni, legfeljebb 12 MHz frekvenciával a kimeneten. Végül pedig az oszcilloszkóp segítségével teszteljük a kimeneti frekvenciát.
Korábban felépítettünk egy egyszerű szinuszhullám-generátort, egy négyzetes hullámgenerátort és egy háromszög hullámgenerátort az alapvető analóg áramkörök segítségével. Ezeket megnézheti, ha néhány alapvető hullámforma-generátor áramkört keres. Továbbá, ha olcsóbb Arduino Function generátort szeretne építeni az AD9833 modul használata nélkül, akkor megnézheti a DIY Arduino Waveform Generator projektet.
Mi az a DDS funkciógenerátor?
Ahogy a neve is mutatja, a funkciógenerátor olyan eszköz, amely a beállításkor egy adott hullámformát adott frekvenciával képes kimenni. Például vegye figyelembe, hogy van egy LC szűrője, amelyhez tesztelni szeretné a kimeneti frekvencia válaszát, ezt egyszerűen megteheti egy funkciógenerátor segítségével. Csak annyit kell tennie, hogy beállítja a kívánt kimeneti frekvenciát és hullámformát, majd lefelé vagy felfelé forgathatja a válasz teszteléséhez. Ez csak egy példa volt: a lista folytatásával több dolgot is megtehet vele.
A DDS a Direct Digital Synthesis rövidítést jelenti. Ez egy olyan hullámalakú generátor, amely digitális-analóg átalakítókat (DAC) használ a jel felépítéséhez az alapoktól kezdve. Ezt a módszert kifejezetten szinuszhullám előállítására használják. De az általunk használt IC képes négyzet vagy háromszög hullámjeleket előállítani. A DDS chip belsejében végrehajtott műveletek digitálisak, így nagyon gyorsan képes váltani a frekvencián, vagy nagyon gyorsan válthat egyik jelről a másikra. Ennek az eszköznek finom frekvenciafelbontása van, széles frekvenciaspektrummal.
Ismerje meg az AD9833 funkciógenerátor IC működését
Projektünk középpontjában az AD9833 programozható hullámforma generátor IC található, amelyet analóg eszközök terveztek és fejlesztettek ki. Kis teljesítményű, programozható hullámalakú generátor, amely szinuszos, háromszög alakú és négyzet alakú hullámokat képes létrehozni, maximális frekvenciája 12 MHz. Ez egy nagyon egyedi IC, amely csak szoftverrel képes megváltoztatni a kimeneti frekvenciát és a fázist. 3 vezetékes SPI interfésszel rendelkezik, ezért válik az IC-vel való kommunikáció nagyon egyszerűvé és egyszerűvé. Az IC funkcionális blokkvázlata az alábbiakban látható.
Ennek az IC-nek a működése nagyon egyszerű. Ha megnézzük a fenti funkcionális blokkdiagramot, akkor megfigyelhetjük, hogy van egy fázis akkumulátorunk, amelynek feladata a szinusz hullám összes lehetséges digitális értékének tárolása, 0-tól 2π-ig kezdődően. Ezután megvan a SIN ROM, amelynek feladata a később közvetlenül leképezhető fázisinformációk konvertálása amplitúdóvá. A SIN ROM a digitális fázisinformációt címként használja egy keresőtáblára, és a fázisinformációt amplitúdóvá konvertálja. Végül van egy 10 bites digitális-analóg átalakítónk, amelynek feladata a digitális adatok fogadása a SIN ROM-ról és a megfelelő analóg feszültségekké alakítása, ezt kapjuk a kimenetből. A kimeneten van egy kapcsolónk is, amelyet csak egy kis szoftverkóddal tudunk be- vagy kikapcsolni. Erről később a cikkben fogunk beszélni.A fenti részletek egy nagyon lecsupaszított változata annak, ami az IC-n belül történik, és a fenti részletek nagy része az AD9833 adatlapjából származik, további információkért ellenőrizheti is.
Az AD9833 alapú funkciógenerátor felépítéséhez szükséges alkatrészek
Az AD9833 alapú funkciógenerátor felépítéséhez szükséges alkatrészeket az alábbiakban soroljuk fel, ezt az áramkört nagyon általános alkatrészekkel terveztük, ami nagyon megkönnyíti a replikációs folyamatot.
- Arduino Nano - 1
- AD9833 DDS funkciógenerátor - 1
- 128 X 64 OLED kijelző - 1
- Általános rotációs kódoló - 1
- DC hordó Jack - 1
- LM7809 feszültségszabályozó - 1
- 470uF kondenzátor - 1
- 220uF kondenzátor - 1
- 104pF kondenzátor - 1
- 10K ellenállás - 6
- Tapintható kapcsolók - 4
- Csavaros kapocs 5,04 mm - 1
- Női fejléc - 1
- 12 V-os áramforrás - 1
AD9833 alapú funkciógenerátor - sematikus ábra
Az AD9833 és az Arduino alapú funkciógenerátor teljes kapcsolási rajza az alábbiakban látható.
Az AD9833-at az Arduinóval fogjuk használni a kívánt frekvencia előállításához. Ebben a részben pedig az összes részletet elmagyarázzuk a vázlat segítségével; hadd adjak egy rövid áttekintést arról, hogy mi történik az áramkörrel. Kezdjük az AD9833 modullal. Az AD9833 modul a funkciógenerátor modul, amely a vázlat szerint kapcsolódik az Arduino-hoz. Az áramellátáshoz LM7809 feszültségszabályozó IC-t használunk, tisztességes leválasztó kondenzátorral, erre azért van szükség, mert a táplálási zaj megzavarhatja a kimeneti jelet, ami nem kívánt kimenetet eredményez. Mint mindig, az Arduino is ennek a projektnek az agya. A beállított frekvencia és egyéb értékes információk megjelenítéséhez csatlakoztattunk egy 128 X 64 OLED kijelző modult. A frekvenciatartomány megváltoztatásához három kapcsolót használunk. Az első a frekvenciát Hz-re, a második a kimeneti frekvenciát KHz-re, a harmadik pedig a frekvenciát MHz-re állítja, van egy másik gombunk is, amellyel engedélyezhetjük vagy letilthatjuk a kimenetet. Végül megvan a rotációs kódoló,és hozzá kell kötnünk néhány felhúzós ellenállást, különben ezek a kapcsolók nem fognak működni, mert ellenőrizzük a gombnyomás eseményét a pooling módszeren. A forgókódolóval változtathatjuk meg a frekvenciát, a forgókódoló belsejében található tapintókapcsolóval válthatjuk ki a beállított hullámformát.
AD9833 alapú funkciógenerátor - Arduino kód
A projektben használt teljes kód az oldal alján található. A szükséges fejlécfájlok és forrásfájlok hozzáadása után képesnek kell lennie az Arduino fájl közvetlen fordítására. Letöltheti az ad9833 Arduino könyvtárat és más könyvtárakat az alábbi linkről, vagy használhatja a tábla kezelő módszerét a könyvtár telepítéséhez.
- Bill Williams által letöltött AD9833 könyvtár
- Adafruit SSD1306 OLED könyvtárának letöltése
- Töltse le az Adafruit GFX könyvtárat
A kód magyarázata az ino-ban. fájl a következő. Először az összes szükséges könyvtár beillesztésével kezdjük. Az AD9833 DDS modul könyvtárát először az OLED könyvtár követi, és néhány számításhoz matematikai könyvtárra van szükség.
#include // Könyveskönyv az AD9833 modulhoz #include
Ezután meghatározzuk az összes szükséges bemeneti és kimeneti csapot a gombokhoz, a kapcsolóhoz, a forgókódolóhoz és az OLED-ekhez.
#define SCREEN_WIDATA_PINH 128 // OLED kijelző Szélesség pixelekben #define SCREEN_HEIGHT 64 // OLED megjelenítési magasság, pixelben #define SET_FREQUENCY_HZ A2 // Nyomógomb A frekvencia beállításához Hz-ben #define SET_FREQUENCY_KHZ A3 // Frissítés A6 // Nyomógomb a frekvencia beállításához az Mhz-ben #define ENABLE_DISABLE_OUTPUT_PIN A7 // Nyomógomb a kimenet engedélyezéséhez / letiltásához #define FNC_PIN 4 // Fsync szükséges az AD9833 modulhoz #define CLK_PIN 8 // Clock # A kód kódja / A kódoló adatlapja #define BTN_PIN 9 // A kódoló belső nyomógombja
Ezt követően meghatározzuk az összes szükséges változót, amelyre szükség van ebben a kódban. Először meghatározunk egy egész változó számlálót, amely tárolja a forgó kódoló értékét. A következő két változó: clockPin és clockPinState tárolja azt a tűszobrot, amely a kódoló irányának megértéséhez szükséges. Van egy időben változó, amely tartalmazza az aktuális időzítő-számláló értékek, ezt a változót használjuk gomb lebontási. Ezután van egy elő nem írt hosszú változó moduleFrequency, amely megtartja az alkalmazott számított frekvenciát. Ezután megkapjuk a visszavonási késleltetést. Ez a késés szükség szerint beállítható. Ezután három logikai változónk van: set_frequency_hz,set_frequency_Khz és set_frequency_Mhz ez a három változó a modul aktuális beállításának meghatározására. A cikk későbbi részében részletesebben beszélünk róla. Ezután megkapjuk azt a változót, amely tárolja a kimeneti hullámforma állapotát, az alapértelmezett kimeneti hullámforma egy szinusz hullám. Végül megvan az encoder_btn_count változó, amely megtartja a kódoló gombok számát, amelyet a kimeneti hullámforma beállításához használnak.
int számláló = 1; // Ez a számláló értéke növekszik vagy csökken, ha a forgókódolót int clockPin; // Helyőrző a pin állapothoz, amelyet a forgó kódoló használ az int clockPinState; // A rotációs kódoló által használt pin állapot helyőrzője hosszú ideig nem aláírt = 0; // Aláíratlan hosszú moduleFrequency; // a kimeneti frekvencia beállításához hosszú visszacsatolás = 220; // Debounce delay bool btn_state; // az AD98333 modul bool kimenetének letiltásához használható: set_frequency_hz = 1; // Az AD9833 modul bool alapértelmezett gyakorisága set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // A modul indítási hullámformája int encoder_btn_count = 0; // a kódoló gombjának ellenőrzéséhez használjuk a Next gombot. Megvan a két objektumunk, az egyik az OLED-kijelző, a másik pedig az AD9833 modul.Adafruit_SSD1306 kijelző (SCREEN_WIDATA_PINH, SCREEN_HEIGHT & Wire, -1); AD9833 gen (FNC_PIN);
Ezután megkapjuk a setup () függvényünket, abban a beállítási funkcióban kezdjük a Serial engedélyezésével a hibakereséshez. Az AD9833 modult inicializáljuk a begin () metódus segítségével. Ezután az összes hozzárendelt rotációs kódolócsapot bemenetként állítjuk be. És az órajel értékét a clockPinState változóban tároljuk, ez a forgókódoló szükséges lépése.
Ezután az összes gombcsapot bemenetként állítjuk be és engedélyezzük az OLED megjelenítést a display.begin () metódus segítségével, és az if utasítással is ellenőrizzük az esetleges hibákat. Ha ez megtörtént, kitisztítjuk a képernyőt és kinyomtatjuk az indítási splash képernyőt, hozzáadunk egy 2 másodperces késleltetést, amely egyben a splash screen késleltetése is, végül pedig meghívjuk az update_display () függvényt, amely törli a képernyőt és frissíti a ismét megjelenik. Az update_display () metódus részleteiről később a cikkben lesz szó.
void setup () {Soros.kezdés (9600); // Serial @ 9600 baud gen engedélyezése. Kezdés (); // Ennek KELL lennie az első parancsnak az AD9833 objektum pinMode (CLK_PIN, INPUT) deklarálása után; // A csapok beállítása bemeneti pinMode módként (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Pinek beállítása bemenetként pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// 0x3D cím 128x64-es Serial.println számára (F ("Az SSD1306 kiosztása sikertelen")); for (;;); } display.clearDisplay (); // Törölje a képernyőt display.setTextSize (2); // Szövegméret beállítása display.setTextColor (FEHÉR); // LCD színes kijelző beállítása.setCursor (30, 0); // A kurzor helyzetének beállítása display.println ("AD9833"); // Nyomtassa ki ezt a szöveges képernyőt.setCursor (17, 20); // A kurzor pozíciójának beállítása display.println ("Funkció"); // Nyomtassa ki ezt a szöveget display.setCursor (13, 40); // A kurzor pozíciójának beállítása display.println ("Generátor"); // Nyomtassa ki ezt a szöveget display.display (); // A kijelző késleltetésének frissítése (2000); // 2 SEC késleltetés update_display (); // update_display függvény hívása}
Ezután megkapjuk a loop () függvényünket, az összes főbb funkciót a ciklus szakaszba írjuk.
Először elolvassuk a Rotary kódoló Clock pin-jét, és eltároljuk a korábban deklarált clockPin változóban. Ezután az if utasításban ellenőrizzük, hogy a csap előző értéke és a csap aktuális értéke hasonló-e vagy sem, és ellenőrizzük a csap aktuális értékét is. Ha mindez igaz, akkor ellenőrizzük az adatcsapot, ha igaz, az azt jelenti, hogy a kódoló az óramutató járásával ellentétes irányban forog, és a számláló értékét csökkentjük a counter-- parancs segítségével. Egyébként a számláló értékét a + + paranccsal növeljük. Végül feltettünk egy másik if utasítást a minimális érték 1-re állításához. Ezután frissítjük a clockPinState- t az aktuális clockPin-telérték a jövőbeni felhasználásra.
void loop () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {számláló -; } else {számláló ++; // A kódoló forgatja a CW-t, így növekszik}, ha (számláló <1) számláló = 1; Soros.println (számláló); update_display (); }
Ezután megvan a kódunk a gombnyomás észleléséhez. Ebben a szakaszban a kódoló belsejében lévő gombot észleltük néhány beágyazott if utasítás segítségével, ha (digitalRead (BTN_PIN) == LOW && millis () - idő> felmondás), ebben az utasításban először ellenőrizzük, hogy a gomb a pin alacsony vagy nem, ha alacsony, akkor megnyomják. Ezután ismét ellenőrizzük az időzítő értékét a visszavonási késleltetéssel, ha mindkét állítás igaz, akkor sikeres gombnyomási műveletnek nyilvánítjuk, ha így növeljük az encoder_btn_count értéket. Ezután deklarálunk egy másik if utasítást a maximális számláló érték 2-re állításához, szükségünk van rá, mert a kimeneti hullámforma beállítására használjuk .Az egymást követő három, ha az utasítások ezt teszik, ha az érték nulla, akkor a szinusz hullámformát választjuk, ha egy, akkor négyzet alakú hullámot, ha pedig 2, akkor háromszög alakú hullámot. Mindhárom if utasításban frissítjük a kijelzőt az update_display () függvénnyel. És végül frissítjük az időváltozót az aktuális időzítő számláló értékével.
// Ha LOW jelet észlelünk, a gombot megnyomjuk, ha (digitalRead (BTN_PIN) == LOW && millis () - idő> debounce) {encoder_btn_count ++; // Növelje az értékeket, ha (kódoló_btn_szám> 2) //, ha az érték nagyobb, mint 2, állítsa vissza 0 értékre {kódoló_btn_szám = 0; } if (kódoló_btn_szám == 0) {// ha az érték 0 szinusz hullám van kiválasztva waveSelect = "SIN"; // frissítse a karakterlánc változót a sin értékkel update_display (); // frissítse a kijelzőt} if (kódoló_btn_szám == 1) {// ha az érték 1 négyzet alakú hullám van kiválasztva waveSelect = "SQR"; // frissítse a karakterlánc változót az SQR értékkel update_display (); // frissítse a kijelzőt} if (kódoló_btn_szám == 2) {// ha az érték 1 Háromszög alakú hullám van kiválasztva waveSelect = "TRI"; // frissítse a karakterlánc változót a TRI értékkel update_display ();// frissítse a kijelzőt} time = millis (); // frissítse az időváltozót}
Ezután meghatározzuk az összes szükséges kódot, amely szükséges az összes gomb visszavonási késleltetéssel történő beállításához. Mivel a gombok az Arduino analóg csapjaihoz vannak csatlakoztatva, az analóg olvasási paranccsal azonosítjuk a gombnyomást, ha az analóg olvasási érték eléri a 30 értéket, majd észleljük annak sikeres gombnyomását, és 200 ms-ot várunk a ellenőrizze, hogy ez tényleges gombnyomás vagy csak zaj. Ha ez az állítás igaz, a logikai változókat olyan értékekkel rendeljük hozzá, amelyek a függvénygenerátor Hz, Khz és Mhz értékeinek beállításához használatosak. Ezután frissítjük a kijelzőt és az időváltozót. Tesszük ezt az Arduinóval összekapcsolt mind a négy gomb esetében.
if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - idő> visszavonás) {set_frequency_hz = 1; // a logikai értékek frissítése set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // megjelenítési idő frissítése = millis (); // update the változó} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // a logikai értékek frissítése set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = számláló * 1000; update_display (); // frissítse a megjelenítési időt = millis (); // frissítse az időváltozót} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - idő> debounce) {// ellenőrizze az analóg csapot a debounce delay késleltetéssel 0; // a logikai értékek frissítése set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = számláló * 1000000; update_display ();// frissítse a megjelenítési időt = millis (); // frissítse az időváltozót} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - idő> visszavonás) {// ellenőrizze az analóg csapot visszavonási késleltetéssel btn_state =! btn_state; // Fordítsa meg a gomb állapotát gen.EnableOutput (btn_state); // A funkciógenerátor kimenetének engedélyezése / letiltása a gomb állapotától függően update_display (); // display display time = millis (); // update time változó}}// frissítse az időváltozót}}// frissítse az időváltozót}}
Végül megvan az update_display () függvényünk. Ebben a funkcióban sokkal többet tettünk, mint egyszerűen frissítettük ezt a kijelzőt, mert a kijelző bizonyos része nem frissíthető OLED-ben. Frissítéséhez új értékekkel kell újrafesteni. Ez sokkal megnehezíti a kódolási folyamatot.
Ezen a funkción belül a kijelző törlésével kezdjük. Ezután beállítjuk a szükséges szövegméretet. Ezt követően beállítottuk a kurzort és a kinyomtatott Funkciógenerátort a display.println ("Funkció Funkció") kijelzővel; parancs. A display.setCursor (0, 20) függvény segítségével ismét 2-re állítjuk a szöveg méretét, a kurzort pedig (0,20) értékre.
Itt nyomtatjuk ki az információt, hogy milyen hullámról van szó.
display.clearDisplay (); // FIrst törölje a kijelző display.setTextSize (1); // szöveg beállítása size display.setCursor (10, 0); // A kurzor helyzetének beállítása.println ("Funkciógenerátor"); // kinyomtatja a szöveges kijelzőt.setTextSize (2); // szövegméret beállítása display.setCursor (0, 20); // kurzor pozíciójának beállítása
Ezután ellenőrizzük a logikai változókat a frekvencia részleteiről, és frissítjük az értéket a moduleFrequency változóban. Ezt a Hz, kHz és MHz értékekre tesszük. Ezután ellenőrizzük a waveSelect változót, és azonosítjuk, hogy melyik hullám van kiválasztva. Most megadjuk az értékeket a hullám típusának és frekvenciájának beállításához.
if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// ellenőrizze, hogy megnyomják-e a frekvencia Hz-ben történő beállításának modulját modulFrequency = számláló; // frissítse a moduleFrequency változót az aktuális számláló értékével} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// ellenőrizze, hogy megnyomják-e a frekvencia KHz-ben történő beállítását modulFrequency = számláló * 1000; // frissítse a moduleFrequency változót az aktuális számláló értékkel, de megsokszorozzuk az 1000-et, hogy KHZ-re állítsuk = számláló * 1000000; if (moduleFrequency> 12000000) {moduleFrequency = 12000000;// ne hagyja, hogy a frekvencia legyen reszelő, hogy 12Mhz számláló = 12; }} if (waveSelect == "SIN") {// Szinuszhullám van kiválasztva display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// Sqr hullám van kiválasztva display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Három hullám van kijelölve display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // frissítse az AD9833 modult. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr hullám van kiválasztva display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Három hullám van kijelölve display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // frissítse az AD9833 modult. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr hullám van kiválasztva display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Három hullám van kijelölve display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // frissítse az AD9833 modult. Serial.println (moduleFrequency); }
Újra beállítjuk a kurzort, és frissítjük a számláló értékeit. Ismét ellenőrizzük a logikai értéket, hogy frissítsük a kijelző frekvenciatartományát, ezt meg kell tennünk, mert az OLED működési elve nagyon furcsa.
display.setCursor (45, 20); display.println (számláló); // kinyomtatja a számláló információkat a kijelzőn. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // Hz nyomtatása a kijelzőre.display (); // amikor az összes készlet frissíti a kijelzőt} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // amikor az összes készlet frissíti a kijelzőt} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // amikor az összes készlet frissíti a kijelzőt}
Ezután ellenőrizzük a gombnyomás változót, hogy a kimenetet az OLED-be nyomtassuk / kimenjünk. Ezt megint az OLED modul miatt kell megtenni.
if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Kimenet BE"); // nyomtassa ki a kimenetet a kijelzőre.display (); display.setTextSize (2); } else {display.setTextSize (1); display.setCursor (65, 45); display.print ("Kimenet KI"); // kinyomtatja a kimenetet a kijelzőre.display (); display.setTextSize (2); }
Ez a kódolási folyamatunk végét jelenti. Ha ezen a ponton zavart, ellenőrizheti a kódban található megjegyzéseket a további megértés érdekében.
Az AD9833 alapú funkciógenerátor tesztelése
Az áramkör teszteléséhez a fenti beállítást kell használni. Amint láthatja, csatlakoztattunk egy 12 V-os egyenáramú tápegységet a DC-hordó aljzathoz, és csatlakoztattuk a Hantek oszcilloszkópot az áramkör kimenetéhez. Csatlakoztattuk az oszcilloszkópot a laptophoz a kimeneti frekvencia vizualizálása és mérése érdekében.
Miután ez megtörtént, a rotációs kódoló segítségével 5 kHz-re állítottuk a kimeneti frekvenciát, és teszteljük a kimeneti szinusz hullámot, és bizony, ez egy 5 khz szinusz hullám a kimeneten.
Ezután megváltoztattuk a kimeneti hullámformát háromszög alakú hullámra, de a frekvencia változatlan maradt, a kimeneti hullámforma alább látható.
Ezután a kimenetet négyzethullámra változtattuk, és megfigyeltük a kimenetet, és ez tökéletes négyzethullám volt.
Megváltoztattuk a frekvenciatartományokat és teszteltük a kimenetet is, és ez jól működött.
További fejlesztések
Ez az áramkör csak a koncepció bizonyítéka, és további fejlesztéseket igényel. Először jó minőségű NYÁK-ra és jó minőségű BNC csatlakozóra van szükségünk a kimenethez, különben nem tudunk magasabb frekvenciát elérni. A modul amplitúdója nagyon alacsony, ezért ennek fokozásához szükségünk van néhány op-amp áramkörre a kimeneti feszültség felerősítéséhez. A kimeneti amplitúdó változtatásához potenciométer csatlakoztatható. A jel kikapcsolására kapcsoló csatlakoztatható; ez is kötelező funkció. És a kódot tovább kell fejleszteni, mivel kissé hibás. Végül meg kell változtatni az OLED kijelzőket, különben lehetetlen könnyen érthető kódot írni.
Ezzel vége ennek az oktatóanyagnak, remélem, tetszett a cikk, és valami újat tanultál. Ha bármilyen kérdése van a cikkel kapcsolatban, akkor hagyja meg őket az alábbi megjegyzés részben, vagy használhatja Elektronikai fórumunkat.