Bumuo ng iyong sariling adjustable electronic dc load gamit ang arduino

Kung nakipagtulungan ka sa Baterya, mga circuit ng SMPS o iba pang mga circuit ng supply ng kuryente, madalas na maganap na kailangan mong subukan ang iyong mapagkukunan ng kuryente sa pamamagitan ng paglo-load nito upang suriin kung paano ito gumaganap sa ilalim ng iba't ibang mga kundisyon ng paglo-load. Ang isang aparato na karaniwang ginagamit upang maisagawa ang ganitong uri ng pagsubok ay tinatawag na isang Constant Kasalukuyang DC Load, na nagbibigay-daan sa amin upang ayusin ang kasalukuyang output ng iyong mapagkukunan ng kuryente at pagkatapos ay panatilihin itong pare-pareho hanggang sa maiayos muli itong mga pagbabago. Sa tutorial na ito, matututunan namin kung paano bumuo ng aming sariling Adjustable Electronic Load gamit ang Arduino, na maaaring tumagal ng isang maximum na boltahe ng pag-input ng 24V at maubos ang kasalukuyang kasing taas ng 5A. Para sa proyektong ito, gumamit kami ng mga PCB board na kung saan ay gawa ng AllPCB, isang batay sa china na propesyonal na PCB manufacturing at assembling service provider.

Sa aming nakaraang tutorial na pinagmulan ng boltahe na kinokontrol ng boltahe, ipinaliwanag namin kung paano gumamit ng isang pagpapatakbo na amplifier na may isang MOSFET at gumawa ng isang kasalukuyang kinokontrol na boltahe na pinagkukunan ng boltahe. Ngunit sa tutorial na ito, ilalapat namin ang circuit na iyon at gumawa ng isang kasalukuyang kinokontrol na mapagkukunan ng digital. Malinaw na, ang isang kasalukuyang kinokontrol na digital na mapagkukunan ay nangangailangan ng isang digital circuit at upang maihatid ang layunin, isang Arduino NANO ang ginagamit. Magbibigay ang Arduino NANO ng mga kinakailangang kontrol para sa pag-load ng DC.

Ang circuit ay binubuo ng tatlong bahagi. Ang unang bahagi ay ang seksyon ng Arduino Nano, ang pangalawang bahagi ay ang digital sa analog converter, at ang pangatlong bahagi ay isang purong analog circuit kung saan ginagamit ang isang dalawahang amplifier ng pagpapatakbo sa isang solong pakete na makokontrol sa seksyon ng pag-load. Ang proyektong ito ay inspirasyon ng isang post sa Arduino, gayunpaman, ang circuit ay binago para sa hindi gaanong kumplikado sa mga pangunahing tampok para sa lahat na buuin ito.

Ang aming elektronikong pagkarga ay idinisenyo upang magkaroon ng mga sumusunod na seksyon ng pag-input at output.

Dalawang switch ng input para sa pagtaas at pagbawas ng load.
Isang LCD na ipapakita ang itinakdang pagkarga, aktwal na pagkarga, at boltahe ng pag-load.
Ang maximum na kasalukuyang pag-load ay limitado sa 5A.
Ang maximum na boltahe ng pag-input ay 24V para sa pag-load.

Mga Materyal na Kinakailangan

Ang mga sangkap na kinakailangan upang bumuo ng isang DC electronic load ay nakalista sa ibaba.

Arduino nano
16x2 character na LCD
Dalawang socket ng bariles
Mosfet irf540n
Mcp4921
Lm358
5watt shunt risistor.1 ohms
1k
10k - 6pcs
Heatsink
.1uF 50v
2k - 2pcs

Arduino DC Electronic Load Circuit Diagram

Sa iskemat sa ibaba, ang amplifier ng pagpapatakbo ay may dalawang seksyon. Ang isa ay upang makontrol ang MOSFET at ang isa pa ay upang palakasin ang kasalukuyang sensed. Maaari mo ring suriin ang video sa ilalim ng pahinang ito na nagpapaliwanag ng kumpletong pagtatrabaho ng circuit. Ang unang seksyon ay ang pagkakaroon ng R12, R13, at MOSFET. Ginagamit ang R12 upang mabawasan ang epekto ng paglo-load sa seksyon ng feedback at ang R13 ay ginagamit bilang risistor ng Mosfet gate.

Ang karagdagang dalawang resistors na R8 at R9 ay ginagamit upang maunawaan ang supply boltahe ng suplay ng kuryente na bibigyang diin ng dummy load na ito. Tulad ng panuntunan sa divider ng boltahe, sinusuportahan ng dalawang resistors ang maximum na 24V. Mahigit sa 24V ang makakagawa ng isang boltahe na hindi angkop para sa mga pin ng Arduino. Kaya't mag-ingat na huwag ikonekta ang suplay ng kuryente na mayroong higit sa 24V na boltahe ng output.

Ang Resistor R7 ay ang aktwal na resistor ng pag-load dito. Ito ay isang 5 Watt,.1 Ohm risistor. Alinsunod sa kapangyarihan-batas, susuportahan nito ang maximum na 7A (P = I ² R), ngunit para sa ligtas na panig, mas maingat na limitahan ang kasalukuyang karga sa maximum na 5A. Samakatuwid, sa kasalukuyan maximum na 24V, ang 5A load ay maaaring maitakda ng dummy load na ito.

Ang isa pang seksyon ng amplifier ay na-configure bilang isang gain amplifier. Magbibigay ito ng 6x na nakuha. Sa panahon ng daloy ng kasalukuyang, lilitaw ang isang drop ng boltahe. Halimbawa, kapag ang 5A ng kasalukuyang dumadaloy sa pamamagitan ng risistor, ang pagbagsak ng boltahe ay magiging.5V sa kabuuan ng.1 Ohms shunt risistor (V = I x R) alinsunod sa batas ng ohms. Ang non-inverting amplifier ay palalakasin ito sa x6, samakatuwid ang 3V ay ang output mula sa ikalawang bahagi ng amplifier. Ang output na ito ay madarama ng Arduino nano analog input pin at kakalkulahin ang kasalukuyang.

Ang unang bahagi ng amplifier ay naka-configure bilang isang boltahe tagasunod circuit na kung saan ay makontrol ang MOSFET ayon sa input boltahe at makuha ang nais na boltahe ng feedback dahil sa kasalukuyang pag-load na dumadaloy sa pamamagitan ng shunt risistor.

Ang MCP4921 ay ang Digital to Analog converter. Gumagamit ang DAC ng SPI komunikasyon protocol upang makuha ang digital data mula sa anumang yunit ng microcontroller at magbigay ng output ng analog boltahe depende dito. Ang boltahe na ito ay ang input ng op-amp. Nalaman din natin dati kung paano gamitin ang MCP4921 DAC na ito sa PIC.

Sa kabilang panig, mayroong isang Arduino Nano na magbibigay ng digital data sa DAC sa pamamagitan ng SPI protocol at makontrol ang pag-load, ipinapakita rin ang data sa pagpapakita ng 16x2 na character. Dalawang karagdagang mga bagay ang ginagamit, iyon ang pagbaba at pagtaas ng pindutan. Sa halip na kumonekta sa isang digital pin ay konektado ito sa mga analog pin. Samakatuwid, maaaring baguhin ito ng isa sa ibang uri ng mga switch tulad ng slider o analog encoder. Gayundin, sa pamamagitan ng pagbabago ng code ang isa ay maaaring magbigay ng hilaw na analog data upang makontrol ang pagkarga. Iniiwasan din nito ang problema sa switch debounce.

Sa wakas, sa pamamagitan ng pagtaas ng load, ang Arduino nano ay magbibigay ng data ng pag-load sa DAC sa digital format, ang DAC ay magbibigay ng analog data sa pagpapatakbo na amplifier, at ang pagpapatakbo ng amplifier ay makokontrol ang MOSFET ayon sa input boltahe ng pagpapatakbo amplifier. Sa wakas, nakasalalay sa kasalukuyang daloy ng pag-load sa pamamagitan ng shunt resistor, lilitaw ang isang drop ng boltahe na karagdagang papalakas ng pangalawang channel ng LM358 at makukuha ng Arduino nano. Ipapakita ito sa pagpapakita ng character. Ang magkatulad na bagay ang mangyayari kapag pinindot ng gumagamit ang button ng pagbaba.

Disenyo ng PCB at Gerber File

Dahil ang circuit na ito ay nagkakaroon ng isang mataas na kasalukuyang landas, ito ay isang mas matalinong pagpipilian na gumamit ng wastong mga taktika sa disenyo ng PCB para sa pagtanggal ng mga hindi nais na kaso ng pagkabigo. Kaya, isang PCB ay idinisenyo para sa pag-load ng DC na ito. Gumamit ako ng Eagle PCB Design Software upang idisenyo ang aking PCB. Maaari kang pumili ng anumang PCB Cad Software. Ang pangwakas na idinisenyong PCB sa CAD software ay ipinapakita sa larawan sa ibaba,

Ang isang mahalagang kadahilanan na mapapansin sa panahon ng disenyo ng PCB na ito ay ang paggamit ng isang makapal na eroplano ng kuryente para sa wastong kasalukuyang daloy sa buong circuit. Mayroon ding ground stitching VIAS (mga random na vias sa ground plane) na ginagamit para sa wastong pagdaloy ng lupa sa parehong mga layer hanggang sa itaas at ibaba.

Maaari mo ring i-download ang Gerber file ng PCB na ito mula sa link sa ibaba at gamitin ito para sa katha.

Mag-download ng Adjustable Electronic DC Load Gerber File

Pag-order ng iyong PCB mula sa AllPCB

Kapag handa ka na sa iyong Gerber file maaari mo itong gamitin upang makagawa ng iyong PCB na gawa-gawa. Pinag-uusapan kung saan dinadala ang sponsor ng artikulong ito na ALLPCB, na kilala sa kanilang mga de-kalidad na PCB at ultrafast na pagpapadala. Bukod sa Paggawa ng PCB, nagbibigay din ang AllPCBAng PCB Assembly at Sourcing ng Component.

Upang makuha ang iyong order ng PCB mula sa kanila, bisitahin allpcb.com at pag-signup. Pagkatapos sa home page, ipasok ang mga sukat ng iyong PCB at ang kinakailangang dami tulad ng ipinakita sa ibaba. Pagkatapos mag-click sa Quote ngayon.

Ngayon ay maaari mong baguhin ang iba pang mga parameter ng iyong PCB tulad ng bilang ng mga layer, kulay ng mask, kapal, atbp. Sa kanang bahagi, maaari mong piliin ang iyong bansa at ang ginustong pagpipilian sa pagpapadala. Ipapakita nito sa iyo ang oras ng tingga at kabuuang halaga na babayaran. Pinili ko ang DHL at ang aking kabuuang halaga ay $ 26, ngunit kung ikaw ay isang unang beses na customer ang mga presyo ay bababa sa pag-checkout. Pagkatapos mag-click sa Idagdag sa Cart at pagkatapos ay mag-click sa suriin ngayon.

Ngayon, maaari kang mag-click sa pag-upload ng iyong Gerber file sa pamamagitan ng pag-click sa "I-upload ang Gerber" at pagkatapos ay mag-click sa bumili.

Sa susunod na pahina, maaari mong ipasok ang iyong address sa pagpapadala at suriin ang pangwakas na presyo na babayaran mo para sa iyong PCB. Maaari mo ring suriin ang iyong order at mag-click sa isumite upang makapagbayad.

Sa sandaling nakumpirma ang iyong order maaari kang umupo at mag-relay para sa iyong PCB na makarating sa iyong pintuan. Natanggap ko ang aking order pagkatapos ng ilang araw at pagkatapos ay malinis ang packaging tulad ng ipinakita sa ibaba.

Ang kalidad ng PCB ay mabuti kagaya ng nakikita mo mismo sa mga larawan sa ibaba. Ang tuktok na bahagi at ang ibabang bahagi ng board ay ipinapakita sa ibaba.

Kapag nakuha mo ang iyong board, maaari kang magpatuloy sa pag-iipon ng lahat ng mga bahagi. Ang aking natapos na board ay mukhang tulad nito na ipinakita sa ibaba.

Susunod, maaari mong i-upload ang code at paganahin ang module upang suriin kung paano ito gumagana. Ang kumpletong code para sa proyektong ito ay ibinibigay sa ilalim ng pahinang ito. Ang paliwanag ng code ay ang mga sumusunod.

Arduino Code para sa Naaayos na DC Load

Ang code ay medyo simple. Sa una, isinama namin ang mga file ng header ng SPI at LCD pati na rin itakda ang maximum na boltahe ng lohika, mga pin ng pagpili ng chip, atbp.

# isama # isama #define SS_PIN 10 # tukuyin MAX_VOLT 5.0 // maximum na boltahe ng lohika # tukuyin ang load_resistor 0.1 // halaga ng resistor ng shunt sa Ohms #define opamp_gain 6 // makakuha ng op-amp #define average 10 // average time

Ang seksyon na ito ay binubuo ng mga kinakailangang pagdeklara na nauugnay sa daloy ng programa ng mga integer at variable. Gayundin, itinakda namin ang mga associate peripheral pin na may Arduino Nano.

const int slaveSelectPin = 10; // Chip select pin int number = 0; int dagdagan = A2; // Taasan ang pin int pagbaba = A3; // pagbawas ng pin int kasalukuyang_sense = A0; // current sense pin int voltage_sense = A1; // voltage sense pin int state1 = 0; int estado2 = 0; int Itakda = 0; float volt = 0; float load_current = 0.0; float load_voltage = 0.0; float kasalukuyang = 0.0; float boltahe = 0.0; LiquidCrystal lcd (7, 6, 5, 4, 3, 2); // LCD pin

Ginagamit ito para sa Pag-setup ng LCD at SPI. Gayundin, ang mga direksyon ng pin ay nakatakda dito.

void setup () { pinMode (slaveSelectPin, OUTPUT); pinMode (dagdagan, INPUT); pinMode (bawasan, INPUT); pinMode (kasalukuyang_sense, INPUT); pinMode (voltage_sense, INPUT); // initialize SPI: SPI.begin (); // i-set up ang bilang ng mga haligi at hilera ng LCD: lcd.begin (16, 2); // I-print ang isang mensahe sa LCD. lcd.print ("Digital Load"); lcd.setCursor (0, 1); lcd.print ("Circuit Digest"); pagkaantala (2000); }

Ginagamit ito para sa pag-convert ng halaga ng DAC.

void convert_DAC (unsigned int halaga) { / * Laki ng Hakbang = 2 ^ n, Samakatuwid 12bit 2 ^ 12 = 4096 Para sa 5V na sanggunian, ang hakbang ay 5/4095 = 0.0012210012210012V o 1mV (tinatayang) * / unsigned int container; unsigned int MSB; unsigned int LSB; / * Hakbang: 1, naimbak ang 12 bit na data sa lalagyan Ipagpalagay na ang data ay 4095, sa binary 1111 1111 1111 * / container = halaga; / * Hakbang: 2 Lumilikha ng Dummy 8 nang kaunti. Kaya, sa pamamagitan ng paghahati ng 256, ang itaas na 4 na piraso ay nakuha sa LSB LSB = 0000 1111 * / LSB = container / 256; / * Hakbang: 3 Ipinapadala ang pagsasaayos gamit ang pagsuntok sa 4 na data. LSB = 0011 0000 O 0000 1111. Ang resulta ay 0011 1111 * / LSB = (0x30) - LSB; / * Hakbang: 4 na lalagyan ay mayroon pa ring 21bit na halaga. Kinukuha ang mas mababang 8 piraso. 1111 1111 AT 1111 1111 1111. Ang resulta ay 1111 1111 na kung saan ay MSB * / MSB = 0xFF & container; / * Hakbang: 4 Ipinapadala ang data ng 16bits sa pamamagitan ng paghahati sa dalawang byte. * / digitalWrite (slaveSelectPin, LOW); pagkaantala (100); SPI.transfer (LSB); SPI.transfer (MSB); pagkaantala (100); // kunin ang SS pin mataas upang ma-de-select ang maliit na tilad: digitalWrite (slaveSelectPin, HIGH); }

Ang seksyon na ito ay ginagamit para sa kasalukuyang pagpapatakbo na nauugnay sa sensing.

float read_current (walang bisa) { load_current = 0; para sa (int a = 0; isang <average; a ++) { load_current = load_current + analogRead (current_sense); } load_current = load_current / average; load_current = (load_current * MAX_VOLT) / 1024; load_current = (load_current / opamp_gain) / load_resistor; ibalik ang load_current; }

Ginagamit ito para sa pagbabasa ng boltahe ng pag-load.

float read_voltage (walang bisa) { load_voltage = 0; para sa (int a = 0; isang <average; a ++) { load_voltage = load_voltage + analogRead (voltage_sense); } load_voltage = load_voltage / average; load_voltage = ((load_voltage * MAX_VOLT) /1024.0) * 6; ibalik ang load_voltage; }

Ito ang aktwal na loop. Dito, sinusukat ang mga hakbang sa paglipat at ipinadala ang data sa DAC. Matapos mailipat ang data, sinusukat ang aktwal na kasalukuyang daloy at ang boltahe ng pag-load. Ang parehong mga halaga ay sa wakas ay naka-print sa LCD.

void loop () { state1 = analogRead (pagtaas); kung (state1> 500) { pagkaantala (50); estado1 = analogRead (dagdagan); kung (state1> 500) { volt = volt + 0.02; } } state2 = analogRead (bawas); kung (estado2> 500) { pagkaantala (50); estado2 = analogRead (pagbaba); kung (state2> 500) { kung (volt == 0) { volt = 0; } iba pa { volt = volt-0.02; } } } numero = volt / 0.0012210012210012; convert_DAC (numero); boltahe = read_voltage (); kasalukuyang = read_current (); lcd.setCursor (0, 0); lcd.print ("Itakda ang Halaga"); lcd.print ("="); Itakda = (volt / 2) * 10000; lcd.print (Itakda); lcd.print ("mA"); lcd.setCursor (0, 1); lcd.print ("I"); lcd.print ("="); lcd.print (kasalukuyang); lcd.print ("A"); lcd.print ("V"); lcd.print ("="); lcd.print (boltahe); lcd.print ("V"); // lcd.print (load_voltage); //lcd.print("mA "); // pagkaantala (1000); //lcd.clear (); }

Sinusubukan ang aming naaayos na DC Load

Ang digital load circuit ay solder at pinalakas gamit ang isang 12V na mapagkukunan ng kuryente. Ginamit ko ang aking 7.4V Lithium na baterya sa bahagi ng pinagmulan ng kuryente at kumonekta sa isang clamp meter upang suriin kung paano ito gumagana. Tulad ng nakikita mo kapag ang itinakdang kasalukuyang 300mA ang circuit ay kumukuha ng 300mA mula sa baterya na sinusukat din ng clamp meter bilang 310mA.

Ang kumpletong pagtatrabaho ng circuit ay matatagpuan sa video na naka-link sa ibaba. Inaasahan kong naintindihan mo ang proyekto at nasiyahan sa pagbuo ng isang bagay na kapaki-pakinabang. Kung mayroon kang anumang mga katanungan iwanan ang mga ito sa seksyon ng komento o gamitin ang mga Forum.