Ren sinusomvandlare med arduino

Omformarkretsar behövs ofta där det inte går att få växelström från nätet. En växelriktarkrets används för att omvandla likström till växelström och den kan delas in i två typer som är ren sinusvågsomvandlare eller modifierade fyrkantvågsomvandlare. Dessa rena sinusväxelriktare är mycket dyra, där de modifierade fyrkantvågsomformarna är billiga. Läs mer om olika typer av växelriktare här.

I en tidigare artikel har jag visat hur man inte gör en modifierad fyrkantvågsomvandlare genom att ta itu med problemen som är associerade med den. Så i den här artikeln kommer jag att göra en enkel ren sinusvågsomformare med Arduino och förklara kretsens arbetsprincip.

Om du skapar den här kretsen, observera att den här kretsen inte har någon feedback, inget överströmsskydd, inget kortslutningsskydd och inget temperaturskydd. Därför är denna krets byggd och demonstrerad endast för utbildningsändamål, och det rekommenderas absolut inte att bygga och använda denna typ av krets för kommersiella apparater. Du kan dock lägga till dem i din krets om det behövs, de vanliga skyddskretsarna som

Överspänningsskydd, överströmsskydd, omvänd polaritetsskydd, kortslutningsskydd, hot swap-styrenhet, etc. har redan diskuterats.

FÖRSIKTIGHET: Om du gör denna typ av krets ska du vara extra försiktig med högspännings- och spänningstoppar som genereras av kopplingssignalen till ingången.

Vad är SPWM (sinusformad pulsbreddsmodulering)?

Som namnet antyder står SPWM för S inusoidal P ulse W idth M odulation. Som du kanske redan vet är en PWM-signal en signal där vi kan ändra frekvensen på pulsen såväl som på-och av-tid, som också kallas arbetscykeln. Om du vill lära dig mer om PWM kan du läsa det här. Så genom att variera arbetscykeln ändrar vi pulsens medelspänning. Bilden nedan visar att-

Om vi betraktar en PWM-signal som växlar mellan 0 - 5V som har en arbetscykel på 100%, kommer vi att få en genomsnittlig utspänning på 5V, igen om vi betraktar samma signal med en arbetscykel på 50%, kommer vi få utspänningen på 2,5 V, och för arbetscykeln på 25% är det hälften av det. Det summerar grundprincipen för PWM-signalen, och vi kan gå vidare till att förstå grundprincipen för SPWM-signalen.

En sinusspänning är främst en analogspänning som ändrar sin storlek över tiden, och vi kan återge detta beteende av en sinusvåg genom att kontinuerligt ändra PWM-vågens arbetscykel, bilden nedan visar det.

Om du tittar på schemat nedan ser det att det finns en kondensator ansluten vid transformatorns utgång. Denna kondensator är ansvarig för att utjämna växelsignalen från bärfrekvensen.

Den använda insignalen laddar och urladdar kondensatorn enligt insignalen och belastningen. Eftersom vi har använt en mycket högfrekvent SPWM-signal kommer den att ha en mycket liten arbetscykel som är som 1%, denna 1% arbetscykel laddar kondensatorn lite, nästa arbetscykel är 5%, detta laddas igen kondensatorn lite mer, efter puls kommer en arbetscykel på 10% och kondensatorn laddas lite mer, vi kommer att tillämpa signalen tills vi har nått en arbetscykel på 100% och därifrån kommer vi att gå ner igen till 1%. Detta skapar en mycket jämn kurva som en sinusvåg vid utgången. Så genom att tillhandahålla korrekta värden för arbetscykeln vid ingången kommer vi att ha en mycket sinusformad våg vid utgången.

Hur SPWM-omformaren fungerar

Ovanstående bild visar huvuddrivningssektionen i SPWM-omformaren, och som du ser har vi använt två N-kanals MOSFET i halvbryggkonfiguration för att driva transformatorn i denna krets, för att minska oönskat omkopplingsbrus och för att skydda MOSFET, vi har använt 1N5819-dioder parallellt med MOSFET. För att minska eventuella skadliga spikar som genereras i grinddelen har vi använt 4,7 ohm motstånd parallellt med 1N4148-dioder. Slutligen är BD139- och BD 140-transistorerna konfigurerade i en push-pull- konfigurationför att driva grinden till MOSFET, eftersom denna MOSFET har en mycket hög grindkapacitans och kräver minst 10V vid basen för att slå på ordentligt. Läs mer om hur Push-Pull-förstärkare fungerar här.

För att bättre förstå kretsens arbetsprincip har vi reducerat den till en punkt där denna del av MOSFET är PÅ. När MOSFET är på strömmen, strömmar först genom transformatorn och jordas sedan av MOSFET, så ett magnetiskt flöde kommer också att induceras i den riktning i vilken strömmen flyter, och transformatorns kärna kommer att passera det magnetiska flödet i sekundärlindningen, och vi kommer att få den positiva halvcykeln för den sinusformade signalen vid utgången.

I nästa cykel är kretsens nedre del på kretsens övre del av, det är därför jag har tagit bort den övre delen, nu strömmar strömmen i motsatt riktning och genererar ett magnetiskt flöde i den riktningen, vilket vänder riktningen för det magnetiska flödet i kärnan. Läs mer om hur MOSFET fungerar här.

Nu vet vi alla att en transformator fungerar med magnetiska flödesförändringar. Om du slår på och av både MOSFET: erna, en inverterad till en annan och gör det 50 gånger på en sekund, kommer det att genereras ett fint oscillerande magnetiskt flöde inuti transformatorns kärna och det förändrade magnetiska flödet kommer att inducera en spänning i sekundärspolen som vi känner till faradays lag. Så fungerar den grundläggande växelriktaren.

Den fullständiga SPWM-inverterarkretsen som används i detta projekt ges nedan.

Komponenter som krävs för att bygga SPWM-omformare

Sl. Nr	Delar	Typ	Kvantitet
1	Atmega328P	IC	1
2	IRFZ44N	Mosfet	2
3	BD139	Transistor	2
4	BD140	Transistor	2
5	22pF	Kondensator	2
6	10K, 1%	Motstånd	1
7	16 MHz	Kristall	1
8	0,1 uF	Kondensator	3
9	4.7R	Motstånd	2
10	1N4148	Diod	2
11	LM7805	Spänningsregulator	1
12	200uF, 16V	Kondensator	1
13	47uF, 16V	Kondensator	1
14	2.2uF, 400V	Kondensator	1

SPWM-omformarkretskonstruktion

För denna demonstration är kretsen konstruerad på Veroboard, med hjälp av schemat, Vid transformatorns utgång kommer en enorm mängd ström att strömma genom anslutningen, så anslutningsbygeln måste vara så tjock som möjligt.

Arduino-program för SPWM-omformare

Innan vi går vidare och börjar förstå koden, låt oss ta reda på grunderna. Från ovanstående arbetsprincip har du lärt dig hur PWM-signalen kommer att se ut vid utgången, nu kvarstår frågan hur vi kan göra en så varierande våg vid Arduinos utgångsstift.

För att göra den varierande PWM-signalen kommer vi att använda 16-bitars timer1 med en förinställningsinställning på 1, vilket ger oss 1600/16000000 = 0,1 ms tid för varje räkning om vi betraktar en enda halvcykel av en sinusvåg, som passar exakt 100 gånger inom en halv cykel av vågen. Enkelt uttryckt kommer vi att kunna prova sinusvåg 200 gånger.

Därefter måste vi dela sinusvåg till 200 bitar och beräkna deras värden med en korrelation av amplituden. Därefter måste vi konvertera dessa värden till timerräknarvärden genom att multiplicera det med räknargränsen. Slutligen måste vi sätta dessa värden i en uppslagstabell för att mata den till räknaren och vi får vår sinusvåg.

För att göra saker lite enklare använder jag en mycket välskriven SPWM-kod från GitHub som är gjord av Kurt Hutten.

Koden är mycket enkel. Vi börjar vårt program med att lägga till de nödvändiga rubrikfilerna

# inkludera # inkludera

Därefter har vi våra två uppslagstabeller från vilka vi kommer att få timerräknarvärdena.

int lookUp1 = {50, 100, 151, 201, 250, 300, 349, 398, 446, 494, 542, 589, 635, 681, 726, 771, 814, 857, 899, 940, 981, 1020, 1058, 1095, 1131, 1166, 1200, 1233, 1264, 1294, 1323, 1351, 1377, 1402, 1426, 1448, 1468, 1488, 1505, 1522, 1536, 1550, 1561, 1572, 1580, 1587, 1593, 1597, 1599, 1600, 1599, 1597, 1593, 1587, 1580, 1572, 1561, 1550, 1536, 1522, 1505, 1488, 1468, 1448, 1426, 1402, 1377, 1351, 1323, 1294, 1264, 1233, 1200, 1166, 1131, 1095, 1058, 1020, 981, 940, 899, 857, 814, 771, 726, 681, 635, 589, 542, 494, 446, 398, 349, 300, 250, 201, 151, 100, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0}; int lookUp2 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 100, 151, 201, 250, 300, 349, 398, 446, 494, 542, 589, 635, 681, 726, 771, 814, 857, 899, 940, 981, 1020, 1058, 1095, 1131, 1166, 1200, 1233, 1264, 1294, 1323, 1351, 1377, 1402, 1426, 1448, 1468, 1488, 1505, 1522, 1536, 1550, 1561, 1572, 1580, 1587, 1593, 1597, 1599, 1600, 1599, 1597, 1593, 1587, 1580, 1572, 1561, 1550, 1536, 1522, 1505, 1488, 1468, 1448, 1426, 1402, 1377, 1351, 1323, 1294, 1264, 1233, 1200, 1166, 1131, 1095, 1058, 1020, 981, 940, 899, 857, 814, 771, 726, 681, 635, 589, 542, 494, 446, 398, 349, 300, 250,201, 151, 100, 50, 0};

Därefter, i installationssektionen , initialiserar vi timerräknarregistret för att vara tydliga på var och en. För mer information måste du gå igenom databladet för atmega328 IC.

TCCR1A = 0b10100010; / * 10 klart på match, inställt på BOTTOM för compA. 10 klart på match, inställt på BOTTOM för compB. 00 10 WGM1 1: 0 för vågform 15. * / TCCR1B = 0b00011001; / * 000 11 WGM1 3: 2 för vågform 15. 001 ingen förskalning på räknaren. * / TIMSK1 = 0b00000001; / * 0000000 1 TOV1 Aktivera flaggavbrott. * /

Därefter initialiserar vi ingångsregistreringsregistret med ett fördefinierat värde på 16000, eftersom detta hjälper oss att generera exakt 200 sampel.

ICRl = 1600; // Period för 16MHz kristall, för en omkopplingsfrekvens på 100KHz för 200 underavdelningar per 50Hz sinusvågscykel.

Därefter möjliggör vi globala avbrott genom att anropa funktionen, sei ();

Slutligen sätter vi Arduino-stift 9 och 10 som utgång

DDRB = 0b00000110; // Ställ in PB1 och PB2 som utgångar.

Det markerar slutet på installationsfunktionen.

Slingavsnittet i koden förblir tomt eftersom det är ett timeravbrottsdrivet program.

ogiltig slinga () {; /*Göra ingenting…. evigt!*/}

Därefter har vi definierat överflödesvektorn timer1, den här avbrottsfunktionen får ett samtal när timern 1 överflödas och genererar ett avbrott.

ISR (TIMER1_OVF_vect) {

Därefter deklarerar vi några lokala variabler som statiska variabler och vi har börjat mata värdena till fångst- och jämförmotståndet.

statisk int num; statisk char trig; // ändra arbetscykel varje period. OCR1A = lookUp1; OCR1B = lookUp2;

Slutligen förstärker vi räknaren för att mata nästa värden till fångst- och jämförmotstånden, vilket markerar slutet på denna kod.

om (++ num> = 200) {// Pre-increment num ska du kontrollera att det är under 200. num = 0; // Återställ num. trig = trig ^ 0b00000001; digitalWrite (13, trig); }

Testar TL494 PWM-omriktarkretsen

För att testa kretsen används följande inställning.

12V blybatteri.
En transformator som har en 6-0-6 kran och en 12-0-12 kran
100W glödlampa som belastning
Meco 108B + TRMS-multimeter
Meco 450B + TRMS-multimeter

Utgångssignal från Arduino:

När jag väl har laddat upp koden. Jag mätte SPWM-utsignalen från de två stiften på Arduino som ser ut som bilden nedan,

Om vi zoomar in lite kan vi se PWM-vågens ständigt föränderliga arbetscykel.

Därefter visar bilden nedan utsignalen från transformatorn.

SPWM-omformarkrets i idealiskt tillstånd:

Som du kan se från bilden ovan drar den här kretsen cirka 13W medan den kör perfekt

Utgångsspänning utan belastning:

Omvandlarkretsens utgångsspänning visas ovan, detta är spänningen som kommer ut vid utgången utan någon belastning.

Ingångseffektförbrukning:

Ovanstående bild visar den ingångseffekt som jag förbrukar när en 40W belastning ansluts.

Effektförbrukning:

Bilden ovan visar den uteffekt som förbrukas av denna krets, (belastningen är en 40W glödlampa)

Med det avslutar vi testdelen av kretsen. Du kan kolla in videon nedan för en demonstration. Jag hoppas att du gillade den här artikeln och lärde dig lite om SPWM och dess implementeringstekniker. Fortsätt läsa, fortsätt lära, fortsätt bygga så ser jag dig i nästa projekt.