3 fázisú szinuszhullám -generátor az Arduino miatt: 5 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

ennek a megosztásnak az a célja, hogy segítsen valakinek, aki megpróbálja kihasználni Due nagyobb teljesítményét + a referencia hiányát + a nem hasznos adatlapot.

ez a projekt képes akár 3 fázisú szinuszhullámot generálni 256 mintánként ciklusonként alacsony frekvencián (<1 kHz) és 16 mintát / cikluson @ magas frekvencián (akár 20 kHz -ig), ami elég jó ahhoz, hogy egyszerű LPF -ek és a a kimenet szinte tökéletes.

a mellékelt fájl nem volt a végleges verzióm, mert hozzáadtam néhány további funkciót, de a mag ugyanaz. Vegye figyelembe, hogy a mintákat/ciklust alacsonyabbra állították, mint a fenti állítást.

mivel a CPU kapacitása a mellékelt fájlban bemutatott módszerrel maximalizálható, vezérlőegységként egy Arduino Uno -t használtam, amely az Arduino Due külső megszakítását használja fel a frekvenciaérték átadására az Arduino Due -nak. A frekvenciavezérlés mellett az Arduino Uno az amplitúdót is szabályozza (digitális potenciálmérő + OpAmp segítségével), valamint az I/O --- sok játéklehetőség lesz.

1. lépés: Sine Data Array létrehozása

Mivel a valós idejű számítás CPU-igényes, szinuszos adattömbre van szükség a jobb teljesítmény érdekében

uint32_t sin768 PROGMEM =…. közben x = [0: 5375]; y = 127+127*(sin (2*pi/5376/*vagy néhány #, amit előnyben részesít, a követelménytől függ*/))

2. lépés: A párhuzamos kimenet engedélyezése

Az Unóval ellentétben a Due korlátozott hivatkozással rendelkezik. Ahhoz azonban, hogy háromfázisú szinuszhullámot állítsunk elő az Arduino Uno alapján, először is, a teljesítmény nem dicséretes az alacsony MCLK (16 MHz, míg a Due 84 MHz) miatt, másodsorban a korlátozott GPIO max. 2 fázisú kimenetet tud előállítani, és további analóg áramkör a 3. fázis előállításához (C = -AB).

A GPIO engedélyezése többnyire a próba és próba+nem hasznos SAM3X adatlapon alapult

PIOC-> PIO_PER = 0xFFFFFFFE; // PIO vezérlő PIO engedélyezési regiszter (lásd az ATMEL SAM3X adatlapjának 655. oldalát) és https://arduino.cc/en/Hacking/PinMappingSAM3X, Arduino Due 33-41 és 44-51 pin engedélyezve

PIOC-> PIO_OER = 0xFFFFFFFE; // PIO vezérlő kimeneti engedélyezési regisztere, lásd az ATMEL SAM3X adatlapjának P657. Oldalát, PIOC-> PIO_OSR = 0xFFFFFFFE; // A PIO vezérlő kimeneti állapotregisztere, lásd az ATMEL SAM3X adatlapjának 655. oldalát

PIOC-> PIO_OWER = 0xFFFFFFFE; // PIO kimenet írási engedélyezési regisztere, lásd az ATMEL SAM3X adatlapjának 670. oldalát

// PIOA-> PIO_PDR = 0x30000000; // opcionális, mint biztosítás, úgy tűnik, hogy nem befolyásolja a teljesítményt, a 10 -es digitális tű a PC29 -hez és a PA28 -hoz csatlakozik, a 4 -es digitális tű a PC29 -hez és a PA28 -hoz, itt a PIOA #28 és 29 letiltásához

3. lépés: A megszakítás engedélyezése

A teljesítmény maximalizálása érdekében a CPU terhelésének a lehető legalacsonyabbnak kell lennie. Azonban a CPU-pin és a Due-pin közötti 1-1-es megfelelés miatt a bit működése szükséges.

Tovább optimalizálhatja az algoritmust, de a hely nagyon korlátozott.

void TC7_Handler (void) {TC_GetStatus (TC2, 1);

t = t%minta; // használjon t%mintát az 'if' helyett, hogy elkerülje a t túlcsordulását

phaseAInc = (előre beállított*t)%5376; // a %5376 használatával kerülje el a tömbindex túlcsordulását

phaseBInc = (phaseAInc+1792)%5376;

phaseCInc = (phaseAInc+3584)%5376;

p_A = sin768 [phaseAInc] << 1; // lásd a PIOC-t: PC1-PC8, megfelelő Arduino Due tű: 33-40-es érintkező, ezért balra tolás 1 számjegyre

p_B = sin768 [phaseBInc] << 12; // lásd a PIOC-t: PC12-PC19, megfelelő Arduino Due csap: 51-44-es érintkező, ennélfogva eltolás balra 12 számjegy

p_C = sin768 [fázisCInc]; // a C fázisú kimenet PIOC -t használ: PC21, PC22, PC23, PC24, PC25, PC26, PC28 és PC29, a megfelelő Arduino Due tű: digitális tüske: 9, 8, 7, 6, 5, 4, 3, 10

p_C2 = (p_C & B11000000) << 22; // ez PC28 -at és PC29 -et generál

p_C3 = (p_C & B00111111) << 21; // ez PC21-PC26-ot generál

p_C = p_C2 | p_C3; // ez a C fázis párhuzamos kimenetét generálja

p_A = p_A | p_B | p_C; // 32 bites kimenet = A fázis (8 bites) | B fázis | C fázis

PIOC-> PIO_ODSR = p_A; // kimeneti regiszter = p_A

t ++; }

4. lépés: R/2R DAC

3x8bit R/2R DAC felépítése, rengeteg ref a google -ban.

5. lépés: Teljes kód

#define _BV (x) (1 << (x)); uint32_t sin768 PROGMEM = /* x = [0: 5375]; y = 127+127*(sin (2*pi/5376))*/

uint32_t p_A, p_B, p_C, p_C2, p_C3; // A fázis B fázis C érték-bár a kimenet csak 8 bit, a p_A és p_B értékek működtetve új 32 bites értéket hoznak létre, hogy megbirkózzanak a 32 bites PIOC kimenettel

uint16_t phaseAInc, phaseBInc, phaseCInc, freq, freqNew; uint32_t intervallum; uint16_t minták, előre beállított; uint32_t t = 0;

void setup () {

// párhuzamos kimenet PIOC beállítás: Az Arduino Due 33-40-es csap A fázis kimenetként használható, míg a 44-51 érintkező a B fázis kimenetén működik

PIOC-> PIO_PER = 0xFFFFFFFE; // PIO vezérlő PIO engedélyezési regiszter (lásd az ATMEL SAM3X adatlapjának 655. oldalát) és https://arduino.cc/en/Hacking/PinMappingSAM3X, Arduino Due 33-41 és 44-51 pin engedélyezve

PIOC-> PIO_OER = 0xFFFFFFFE; // A PIO vezérlő kimeneti engedélyezési regisztere, lásd az ATMEL SAM3X adatlapjának 655. oldalát

PIOC-> PIO_OSR = 0xFFFFFFFE; // A PIO vezérlő kimeneti állapotregisztere, lásd az ATMEL SAM3X adatlapjának 655. oldalát

PIOC-> PIO_OWER = 0xFFFFFFFE; // PIO kimenet írási engedélyezési regisztere, lásd az ATMEL SAM3X adatlapjának 670. oldalát

// PIOA-> PIO_PDR = 0x30000000; // opcionális, mint biztosítás, úgy tűnik, hogy nem befolyásolja a teljesítményt, a 10 -es digitális tű a PC29 -hez és a PA28 -hoz csatlakozik, a 4 -es digitális tű a PC29 -hez és a PA28 -hoz is csatlakozik, itt a PIOA #28 és 29 letiltásának letiltásához // lásd az https://arduino.cc/en/Hacking/PinMappingSAM3X, pmc_set_writeprotect (hamis); // letiltja a Power Management Control regiszterek írásvédelmét

pmc_enable_periph_clk (ID_TC7); // engedélyezze a perifériás óra időszámlálóját 7

TC_Configure (/ * óra */TC2,/ * csatorna */1, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1); // TC óra 42MHz (óra, csatorna, összehasonlítási mód beállítása) TC_SetRC (TC2, 1, intervallum); TC_Start (TC2, 1);

// időzítő megszakítások engedélyezése az időzítőn TC2-> TC_CHANNEL [1]. TC_IER = TC_IER_CPCS; // IER = megszakítás engedélyezési regiszter TC2-> TC_CHANNEL [1]. TC_IDR = ~ TC_IER_CPCS; // IDR = megszakítás letiltó regiszter

NVIC_EnableIRQ (TC7_IRQn); // A megszakítás engedélyezése a beágyazott vektoros megszakítási vezérlőben freq = 60; // inicializálja a frekvenciát 60 Hz -re előre beállítva = 21; // tömbindex növekedés 21 mintával = 256; // kimeneti minták 256/ciklusintervallum = 42000000/(frekvencia*minták); // megszakítási számok TC_SetRC (TC2, 1, intervallum); // indítsa el a TC Serial.begin (9600); // tesztelés céljából}

void checkFreq ()

{freqNew = 20000;

if (freq == freqNew) {} más

{freq = freqNew;

if (freq> 20000) {freq = 20000; /*maximális frekvencia 20 kHz*/};

ha (freq <1) {freq = 1; /*min frekvencia 1Hz*/};

if (gyakoriság> 999) {előre beállított = 384; minták = 14;} // frekvencia> = 1 kHz esetén 14 minta minden ciklushoz

else if (gyakoriság> 499) {előre beállított = 84; minták = 64;} // 500 esetén <= gyakoriság99) {előre beállított = 42; minták = 128;} // 100 Hz esetén <= frekvencia <500 Hz, 128 minta/ciklus

else {előre beállított = 21; minták = 256;}; // 100 Hz -es frekvencia esetén 256 minta minden ciklusra

intervallum = 42000000/(gyakori*minták); t = 0; TC_SetRC (TC2, 1, intervallum); }}

void loop () {

checkFreq (); késleltetés (100); }

void TC7_Handler (érvénytelen)

{TC_GetStatus (TC2, 1);

t = t%minta; // t%minták használatával elkerülhető a t phaseAInc = (előre beállított*t)%5376; // a %5376 használatával kerülje el a tömbindex túlcsordulását

phaseBInc = (phaseAInc+1792)%5376;

phaseCInc = (phaseAInc+3584)%5376;

p_A = sin768 [phaseAInc] << 1; // lásd a PIOC-t: PC1-PC8, megfelelő Arduino Due tű: 33-40-es érintkező, ezért balra tolás 1 számjegyre

p_B = sin768 [fázisBInc] << 12; // lásd a PIOC-t: PC12-PC19, megfelelő Arduino Due csap: 51-44-es érintkező, ezért balra tolás 12 számjegy

p_C = sin768 [fázisCInc]; // a C fázis kimenete PIOC -t használ: PC21, PC22, PC23, PC24, PC25, PC26, PC28 és PC29, a megfelelő Arduino Due tű: digitális tű: 9, 8, 7, 6, 5, 4, 3, 10

p_C2 = (p_C & B11000000) << 22; // ez PC28 -at és PC29 -et generál

p_C3 = (p_C & B00111111) << 21; // ez létrehozza a PC21-PC26 // Serial.println (p_C3, BIN); p_C = p_C2 | p_C3; // ez a C fázis párhuzamos kimenetét generálja

p_A = p_A | p_B | p_C; // 32 bites kimenet = A fázis (8 bites) | B fázis | C fázis // Sorozat.println(p_A>> 21, BIN); // PIOC-> PIO_ODSR = 0x37E00000;

PIOC-> PIO_ODSR = p_A; // kimeneti regiszter = p_A t ++; }