Serwisy partnerskie:
Close icon
Serwisy partnerskie

Zbuduj swój własny zasilacz laboratoryjny 0-24 V/3 A z ograniczeniem prądu

W tym projekcie podzielę się z wami przewodnikiem jak można zbudować solidny, w pełni funkcjonalny zasilacz laboratoryjny.
Uwaga! W projekcie występują napięcia niebezpieczne dla zdrowia i życia. Należy zachować szczególną ostrożność w trakcie montażu i uruchamiania urządzenia.
Light icon
Article Image

Podzielę się tym jak wykonać "Super Lab Power Supply" zbudowany przez "Danielrp". Zasilacz Super Lab Power jest zamknięty w pięknej obudowie, która bierze pod uwagę znaczenie funkcjonalności bez kompromisów estetycznych.

Najważniejsze parametry zasilacza Super Lab to:

  • Napięcie nominalne: 24V.
  • Prąd znamionowy: 3A.
  • Tętnienia napięcia wyjściowego: 0,01%.
  • Rozdzielczość pomiaru napięcia: 10mV.
  • Rozdzielczość pomiaru prądu: 1mA.
  • Tryby CV i CC.
  • Zabezpieczenie nadprądowe.
  • Zabezpieczenie nadnapięciowe.

Zasilacz SuperLab oparty jest na super tanim module DIY VkMaker z regulowanym napięciem DC, sprzedawanym na eBayu. Zasilacz, który jest dostarczany jako zestaw z elementami typu THT i płytką drukowaną (więc jest łatwy do lutowania), pobiera na wejściu napięcie 24V AC i podaje na wyjściu napięcie w zakresie 0-30V w zależności od danych wprowadzonych przez użytkownika za pomocą wb udowanego potencjometru. Moduł jest w stanie dostarczyć prąd o natężeniu do 3A i jest wyposażony w funkcje bezpieczeństwa, które pomagają zapobiegać przeciążeniom i zwarciom.

Podczas gdy moduł posiada wszystko, co jest potrzebne do regulacji i zmiany napięcia/prądu, brakuje mu funkcji sprzężenia zwrotnego, które mogłyby uczynić go bardziej użytecznym. Na przykład, jeśli nie podłączysz woltomierza/amperomierza do zacisków wyjściowych, nie ma sprzężenia zwrotnego, aby wiedzieć, jaki wpływ ma obracanie potencjometrem na wyjście. Aby zapewnić to pożądane sprzężenie zwrotne i inne funkcje w cyfrowy i schludny sposób, Daniel opracował układ pomiarowy oparty na Arduino Uno. Układ pomiarowy, który został zaprojektowany jako Arduino Shield, znajduje się pomiędzy wyjściem zasilacza VKmaker a obciążeniem, mierząc napięcie i prąd na wyjściu zasilacza Vkmaker i wyświetlając je w innowacyjny sposób na wyświetlaczu LCD 20×4.

Oprócz monitorowania napięcia i prądu, układ pomiarowy zawiera również przyciski służące do włączania i wyłączania urządzenia, a także kilka dodatkowych potencjometrów służących do ustawiania punktu, w którym urządzenie uruchamia m.in. zabezpieczenie nadnapięciowe i nadprądowe. Wszystkie te cechy pozwalają na bezpieczne zasilanie urządzeń do testów w laboratorium bez obawy o ewentualne uszkodzenie obwodu na skutek przepięcia lub nadmiaru prądu.

Przewodnik będzie prowadzony krok po kroku, a na jego końcu powinieneś być w stanie zbudować swój własny zasilacz laboratoryjny, potencjalnie z ulepszeniami.

Aby lista nie była zbyt długa i niechlujna, BOM zawierający komponenty użyte do budowy tarczy pomiarowej jest załączony w sekcji download. Zawiera on informacje referencyjne potrzebne do wyszukania komponentów.

Mając wszystkie komponenty na miejscu, możemy teraz przystąpić do złożenia ich razem w celu zbudowania projektu.

Montaż zestawu zasilającego

Proces montażu zestawu zasilacza jest dość prosty. Komponenty w zestawie są typu przelotowego, więc wszystko co musisz zrobić, to znaleźć miejsce na płytce, gdzie każdy komponent ma się znajdować, umieścić go i przylutować. Przed lutowaniem należy upewnić się, że orientacja elementu jest prawidłowa, szczególnie w przypadku takich elementów jak diody i układy scalone, ponieważ niewłaściwe umieszczenie może spowodować uszkodzenie samego elementu lub całej płytki. Aby ułatwić umieszczanie elementów, poniżej znajduje się tabela pokazująca etykiety na płytce PCB oraz wartość elementu, który należy umieścić.

Wykaz elementów - moduł zasilający
Ilość
Symbol
Nazwa/opis/gdzie kupić
1
R2
82R
1
R3
220R
1
R4
4.7k
5
R5, R6, R13, R20, R21
10k
2
R8, R11
27K
2
R9, R19
2.2k
1
R10
270k
2
R12, R18
56k
1
R14
1.5k
2
R15, R16
1k
1
R17
33R
1
R22
3.9k
2
C2, C3
47uF/50V
2
C6, C9
100pF (101)
4
D1, D2, D3, D4
1N5408
4
D5, D6, D9, D10
1N4148
1
D11
1N4004
1
D12
LED
3
U1, U2, U3
TL081

Jeśli nie jesteś zaznajomiony z takimi rzeczami jak kodowanie kolorami dla rezystorów, pomocne może być posiadanie przy sobie miernika, aby sprawdzić wartość rezystorów i potwierdzić orientację przed lutowaniem. W przypadku układów scalonych, możesz sprawdzić schematy wyprowadzeń/ karty katalogowe.

Po zamontowaniu wszystkich elementów, płytka powinna wyglądać jak na poniższym zdjęciu.

Zmontowana płytka sterowania zasilaczem

Potencjometry do regulacji napięcia i prądu można wlutować bezpośrednio na płytce PCB, jak pokazano powyżej, ale aby zapewnić większą elastyczność obudowy, należy podłączyć je do płytki poprzez gniazda i zworki, jak pokazano poniżej.

Zmontowana płytka sterowania zasilaczem z wyprowadzonymi potencjometrami poza PCB

Potencjometr oznaczony literą A jest potencjometrem ograniczenia prądu, a V jest potencjometrem napięcia. W miejsce zwykłych potencjometrów, dla łatwiejszej i dokładniejszej regulacji, możesz zastąpić potencjometr napięcia dostarczony w zestawie, potencjometrem wieloobrotowym 10k z drutu.

Po przylutowaniu wszystkich elementów na płytce drukowanej, ostatnią rzeczą jaką musimy zrobić, aby przetestować moduł zasilacza jest zamontowanie na Q4 (D1047) sporej wielkości radiator chłodzący, odizolowany od obwodu. Na wyjściu układu będzie się wytwarzać dużo ciepła i może to doprowadzić do awarii. Jeśli radiator chłodzący nie jest wystarczająco duży, można użyć wentylatora chłodzącego. Gniazdo 24V na płytce zostało umieszczone właśnie w tym celu. Po zamontowaniu radiatora i wentylatora, płykta powinna wyglądać jak na poniższym obrazku.

Zmontowana płytka sterowania zasilaczem z zamontowanym radiatorem z wentylatorem

Przejrzyj jeszcze raz połączenia, aby upewnić się, że wszystko jest tak jak powinno być. Po wykonaniu tych czynności, zasilacz jest gotowy do pracy. Możemy teraz przejść do innych części projektu.

Zbuduj tarczę pomiarową /Metering Shield/

Tarcza pomiarowa pomaga w digitalizacji sterowania i dostarcza wizualną informację zwrotną dla użytkownika. Implementuje ona również funkcje wyłączania nadnapięciowego i nadprądowego, które odłączają obciążenie poprzez przekaźnik.

Jak sama nazwa wskazuje, układ pomiarowy został zaprojektowany jako shield, kompatybilny ze wszystkimi płytkami, które mają układ i wymiary wersji R3 Arduino Uno. Ze względu na charakter ekranowania, został on zaimplementowany na płytce PCB, która została zaprojektowana przy użyciu programu Eagle CAD.

Poniższy schemat pokazuje sposób połączenia poszczególnych elementów.

Schemat elektryczny zasilacza

Wszystkie pliki projektowe, w tym, schematy, PCB i pliki Gerber są załączone w sekcji download artykułu. Ułatwia to pracę zarówno tym, którzy chcą wprowadzić zmiany do projektu, jak i tym, którzy chcą po prostu wysłać Gerbery do producentów i odtworzyć dokładny projekt.

Obraz PCB po wyprodukowaniu jest zamieszczony poniżej.

Płytka PCB gotowa do montażu

Po zmontowaniu, shield powinien wyglądać jak na poniższym zdjęciu.

Shield po zmontowaniu

Z tarczą pomiarową i zasilaczem na miejscu, nadszedł czas na połączenie ich razem w celu zbudowania zasilacza laboratoryjnego.

Schemat

Podłącz zasilacz, tarczę pomiarową, Arduino, wyświetlacz i inne części systemu razem, jak pokazano na schemacie poniżej.

Schemat połączeń modułów zasilacza

Schemat jest oznaczony etykietami, aby łatwo było zidentyfikować, który element gdzie pasuje. Tablica poglądowa dla etykiet na schemacie jest załączona w sekcji download.

Źródło zasilania AC jest doprowadzane do urządzenia poprzez transformator, który obniża napięcie do 24Vac. Należy pamiętać, że napięcie wejściowe AC do modułu zasilacza wynosi 24V i należy upewnić się, że używamy transformatora, który jest do tego przystosowany. Wyjście z zestawu zasilacza Vkmaker jest podłączone do bloku zacisków IN tarczy pomiarowej, a blok zacisków OUT tarczy pomiarowej idzie bezpośrednio do zacisków zasilacza laboratoryjnego. Arduino jest zasilane przez gniazdo zasilania DC, z zacisku 24V na zasilaczu.

Po podłączeniu wszystkich komponentów możemy teraz przystąpić do analizy kodu projektu.

Kod

Kod dla tego projektu został stworzony przy użyciu Arduino IDE. Poza stworzeniem fascynującego interfejsu użytkownika, kod w zasadzie wyświetla ustawiony poziom napięcia i prądu zasilacza i aktualizuje wyświetlacz, gdy te wartości są zmieniane poprzez regulację potencjometrów.

Kod jest dość obszerny, ale postaram się omówić podstawowe części i wyjaśnić rolę każdej z nich.

Kod zaczął się jak zwykle od dołączenia bibliotek, które będą używane. W tym przypadku użyta została biblioteka ciekłokrystaliczna w wersji I2C wraz z biblioteką wire. Biblioteka wire implementuje niektóre z funkcji wymaganych do komunikacji I2C, podczas gdy biblioteka I2C Liquid Crystal pomaga w wyświetlaniu danych na wyświetlaczu LCD opartym na I2C. Biblioteka wire jest preinstalowana w Arduino IDE, a biblioteka I2C Liquid Crystal może być zainstalowana poprzez menedżera bibliotek lub ręcznie, poprzez załączony link.

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>  //Library: https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/

Następnie określamy typ LCD, wraz z liczbą wierszy i kolumn.

//Conditional build:
#define LCD4x20
//#define LCD2x16

//LCD display parameters
#ifdef LCD4x20
  #define N_ROWS 4u
  #define N_COLS 20u
#endif //LCD4x20 
#ifdef LCD2x16
  #define N_ROWS 2u
  #define N_COLS 16u
#endif //LCD4x20
#define LCD_TBL 5000u     //Time that backlight remain active

Następnie tworzymy kilka makr i zmiennych, które reprezentują stan przycisków oraz konkretne komendy.

//Macros
//Relay
#define RELAY_ON    digitalWrite(2, HIGH); \
                    pinMode(2, OUTPUT)
#define RELAY_OFF   digitalWrite(2, LOW); \
                    pinMode(2, OUTPUT)
#define IS_RELAY_ON (HIGH == digitalRead(2))

//Aruduino builtin LED                    
#define STATUS_ON   digitalWrite(LED_BUILTIN, HIGH); \
                    pinMode(LED_BUILTIN, OUTPUT)
#define STATUS_OFF  digitalWrite(LED_BUILTIN, LOW); \
                    pinMode(LED_BUILTIN, OUTPUT)
//MODE Pin                    
#define INIT_MODE   pinMode(12, INPUT)                      //Config MODE pin
#define IS_MODE_CV  (HIGH == digitalRead(12))               //true if mode CV
//ON pushbutton
#define INIT_PON    pinMode(4, INPUT)                       //Config ON pushbutton pin
#define IS_PON_ON   (LOW == digitalRead(4))                 //true if ON pushed
//OFF pushbutton
#define INIT_POFF   pinMode(7, INPUT)                       //Config OFF pushbutton pin
#define IS_POFF_ON  (LOW == digitalRead(7))                 //true if OFF pushed
//OC potentiometer
#define READ_ADC_CP() analogRead(0)
//OV potentiometer
#define READ_ADC_VP() analogRead(1)

Następnie tworzymy zmienne związane z przetwornikiem ADC MCP3422, aby przechowywać adres kanału i inne wartości.

//MCP3422
#define MCP3422_CH1 0x00
#define MCP3422_CH2 0x01
//#define MCP3422_SR 0x00 //240 SPS (12bit)
#define MCP3422_SR 0x01 //60 SPS (14bit)
//#define MCP3422_SR 0x02 //15 SPS (16bit)
//#define MCP3422_SR 0x03 //3.75 SPS (18bit)
#define MCP3422_GAIN 0x00 //x1
//#define MCP3422_GAIN 0x01 //x2
//#define MCP3422_GAIN 0x02 //x4
//#define MCP3422_GAIN 0x03 //x8
#define MCP3422_CR_STARTONESHOT 0x80 // /RDY bit = 1, /O/C bit = 0
#define MCP3422_CR_READY 0x80        // /RDY bit mask
#define MCP3422_NCH 2u    //Number of channels available
#define MCP3422_ADD 0x68  //Slave address
#define MCP3422_TP 5u     //Number of msec between pollings to MCP3422

Następnie tworzymy kilka stałych, szczególnie tych używanych do wyświetlania na LCD znaków specjalnych, takich jak pasek postępu.

//Special chars for progress bar
const uint8_t a6x8u8ProgressBarChars[6][8] = 
{
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00},
  {0x00, 0x00, 0x10, 0x10, 0x10, 0x15, 0x00, 0x00},
  {0x00, 0x00, 0x08, 0x08, 0x08, 0x1D, 0x00, 0x00},
  {0x00, 0x00, 0x04, 0x04, 0x04, 0x15, 0x00, 0x00},
  {0x00, 0x00, 0x02, 0x02, 0x02, 0x17, 0x00, 0x00},
  {0x00, 0x00, 0x01, 0x01, 0x01, 0x15, 0x00, 0x00}
};
//Status messages
const char strStatusCC_ON[6]  = {"CC ON"};
const char strStatusCV_ON[6]  = {"CV ON"};
const char strStatusOFF[4]    = {"OFF"};
const char strStatusOV_OFF[7] = {"OV OFF"};
const char strStatusOC_OFF[7] = {"OC OFF"};
/////////////////////////////////////////////////////////////////////////////////////
//Display
//Double buffer..
#ifdef LCD4x20
char displayBufferA[N_ROWS][N_COLS] =  
{
  {'V', 'O', '=', '0', '0', '.', '0', '0', 'V', ' ', ' ', 'C', 'O', '=', '0', '.', '0', '0', '0', 'A'},
  {'0', '0', '0', '0', '0', '0', '0', '0', '0', ' ', ' ', '0', '0', '0', '0', '0', '0', '0', '0', '0'},
  {'O', 'V', 'P', '=', '0', '.', '0', '0', 'V', ' ', ' ', 'O', 'C', 'P', '=', '0', '.', '0', '0', 'A'},
  {'S', 'T', 'A', 'T', 'U', 'S', ':', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'O', 'F', 'F'}
};   
char displayBufferB[N_ROWS][N_COLS]=   
{
  {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
  {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
  {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
  {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'}
};
#endif //LCD4x20
#ifdef LCD2x16
char displayBufferA[N_ROWS][N_COLS] =  
{// 0    1    2    3    4    5    6    7    8    9    10   11   12   13   14   15
  {'V', '=', '0', '0', '.', '0', '0', ' ', '0', '0', '0', '0', '0', '0', '0', '0'},
  {'C', '=', '0', '.', '0', '0', '0', ' ', '0', '0', '0', '0', '0', '0', '0', '0'}
};   
char displayBufferB[N_ROWS][N_COLS]=   
{
  {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
  {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'}
};
#endif //LCD4x20

Następnie tworzymy kilka ogólnych parametrów i zmiennych, takich jak maksymalny prąd i napięcie oraz wartości wyjściowe, które będą używane w kodzie.

//General parameters
#define MAXVP 2600u           //Maximum OV in 1/100V units
#define MAXCP 3100u           //Maximum OC in 1/1000A units
#define DEBOUNCEHARDNESS 10u  

//General variables
uint16_t u16VOValue = 0; //Voltage output value
uint16_t u16COValue = 0; //Current output value
uint16_t u16VPValue = 0; //Voltage protect value
uint16_t u16CPValue = 0; //Current protect value
uint16_t a3u16VP[3u] = {0, 0, 0}; //Array for filtering voltage protect
uint16_t a3u16CP[3u] = {0, 0, 0}; //Array for filtering current protect
uint8_t u8Index_a3u16VP = 0; //Index of a3u16VP 
uint8_t u8Index_a3u16CP = 0; //Index of a3u16CP 
bool bOnPressed = false;      //State of On push button
bool bLastOnPressed = false;  //Last state of On push button, used for flange detection
bool bOffPressed = false;     //State of Off push button
bool bLastOffPressed = false; //Last state of Off push button, used for flange detection
uint8_t u8OnDebounce = 0;     //Debounce counter for On push button
uint8_t u8OffDebounce = 0;    //Debounce counter for Off push button
bool bMODECV = false;         //Mode of power supply, true: constant voltage, false: constant current
uint32_t u32MCP3422Value = 0;       //Last conversion value from MCP3422
bool bMCP3422ValIsPositive = true;  //Last conversion sign, in this circuit it's always positive
bool bValuesOK = false;             //Indicates in the main loop if the last execution of MCP3422_Machine updated u16VOValue and u16COValue 
/////////////////////////////////////////////////////////////////////////////////////

Następnie przechodzimy do funkcji void setup(). Rozpoczynamy ją od wywołania funkcji setupDisplay(), która inicjalizuje wyświetlacz LCD między innymi numerami kolumn i wierszy. Następnie ustawiamy prędkość komunikacji przewodowej, tak aby ustawić prędkość komunikacji dla wyświetlacza i przetwornika ADC, włączamy podświetlenie LCD, a na koniec inicjalizujemy przetwornik ADC MCP.

void setup()
{
  RELAY_OFF;
  setupDisplay();
  Wire.setClock(400000);  //Speed for both display and MCP3422
  restartBackLight();
  MCP3422_MachineInit();
}

Następnie piszemy funkcję void loop(). Funkcja pętli void jest dość prosta dzięki wszystkim funkcjom wykonującym ciężką pracę. Pętla() rozpoczyna się od funkcji UpdateInputs(), która w zasadzie pobiera stan przycisków wraz z wartością napięcia i prądu z przetwornika ADC.

void loop() 
{
  updateInputs();

Następnie wywołujemy funkcję refreshbacklight(), która jest wywoływana cyklicznie, aby upewnić się, że podświetlenie ekranu jest włączone. Następnie sprawdzamy stan przetwornika ADC i jeśli wszystko jest w porządku, wywołujemy funkcję updateStatus() (która ustawia stan przekaźnika), po czym wywołujemy funkcję updateDisplaybuffer(), która modyfikuje bufor wyświetlacza o aktualne wartości pomiarów, Na koniec wywołujemy funkcję updateDisplay(), która przegląda bufor displayBufferA. Jeśli jakiś znak jest inny w displayBufferA niż w displayBufferB zapisuje go do displayBufferB i na LCD.

void loop() 
{
  updateInputs(); 
  refreshBackLight();
  bValuesOK  = MCP3422_Machine();
  if(true == bValuesOK)
  {
    updateStatus();
    updateDisplayBuffer();
    updateDisplay();
  }
}

Pozostałe części kodu to funkcje, które zostały wywołane w funkcjach setup() oraz loop() i są one odpowiednio skomentowane, więc powinny być łatwe do zrozumienia.

Kompletny kod projektu został załączony w sekcji download.

Obudowa

Obudowa dla tego projektu jest oparta na aluminiowej obudowie firmy Cheval (ich samodzielna obudowa z serii SA).

Obudowa serii SA

Z braku routera do modyfikacji obudowy na potrzeby zasilacza zastosowano stary sposób wycinania, przycinania pilnikiem i używania liter transferowych do tekstu. Plik Inkscape z szablonem użytym do wycięcia przedniego panelu jest dołączony do pliku zip w sekcji download. Możesz go wydrukować i użyć do odrysowania swojego projektu na przednim panelu lub wyciąć go za pomocą frezarki.

Szablon panelu przedniego

Panel przedni po wycięciu i przycięciu powinien wyglądać jak na zdjęciu poniżej.

Panel przedni po przycięciu

Tylny panel obudowy również wymaga modyfikacji, aby można było zamontować radiator i złącze zasilania IEC. Aby to osiągnąć, należy wykonać poniższe kroki;

  1. Zaznaczyć położenie radiatora, w tym otwór na tranzystor mocy i położenie śrub mocujących.
Zaznaczenie położenia radiatora
  1. Zaznaczyć otwór umożliwiający dostęp do radiatora od wewnątrz obudowy zasilacza, ja użyłem izolatora jako punktu odniesienia.
  2. Zaznaczyć otwór na złącze IEC.
  3. Wywiercić kontur kształtu.
  4. Wywiercić otwory pod śruby.
Nawiercenie otworów
  1. Przyciąć kształty za pomocą szczypiec tnących.
  2. Poprawić kształty za pomocą pilnika.
 Panel tylny po wycięciu i przycięciu

Ważne jest, aby powtórzyć znaczenie radiatora w tym miejscu, ponieważ obwód zasilacza nie jest samodzielnie zabezpieczony przed przegrzaniem. Zgodnie z katalogiem tranzystor 2SD1047 ma rezystancję termiczną złącza do obudowy Rth-j,c = 1.25ºC/W, dlatego przed zakupem radiatora należy wziąć pod uwagę jego rezystancję termiczną i ocenić jego przydatność na podstawie innych czynników. Przewodnik po tym jak obliczyć radiator znajduje się tutaj, ale na potrzeby tego projektu użyto tego radiatora, o rezystancji termicznej Rth-hs, air = 0.61ºC/W, który po obliczeniach wydawał się być wystarczająco dobry.

Montaż projektu

Mając obudowę i elektronikę na miejscu, nadszedł czas na montaż elektron iki w obudowie.

Aby rozpocząć od panelu przedniego, wykonaj następujące kroki, aby rozmieścić elementy;

  • Wyciąć przewód wielożyłowy ze złomu, aby uzyskać przewody.
  • Zbudować "złącze Molex", przewód i rurkę termokurczliwą dla potencjometrów, przycisków i LCD. Usunąć wszelkie wypukłości w potencjometrach.
  • Usunąć pierścień wskazówkowy z pokręteł.
  • Przyciąć pręt potencjometrów do rozmiaru gałki. Ja użyłem kawałka tektury jako przymiaru.
  • Zamocować przyciski i przycisk zasilania.
  • Zmontuj potencjometry i zainstaluj gałki, potencjometry wieloobrotowe mają wałek ¼ cala, a modele jednoobrotowe mają wałek 6mm. Możesz użyć podkładek jako dystanserów, aby zmniejszyć odległość potencjometrów.
  • Przykręć kable połączeniowe.
  • Przyklej taśmę dwustronną do wyświetlacza LCD i przyklej go do panelu.
  • Przylutuj przewody dodatni i ujemny do kostek połączeniowych.
  • Zamontować zacisk GND w zielonym słupku wiążącym.
Panel przedni po montażu

Gdy panel przedni jest na swoim miejscu, ułóż panel tylny z radiatorem zgodnie z poniższymi krokami;

  1. Farba na obudowie jest dobrym izolatorem termicznym, ale można dodać trochę smaru do radiatora, aby zwiększyć transfer ciepła z radiatora do obudowy.
Można dodać trochę smaru do radiatora na obudowę, aby zwiększyć transfer ciepła z radiatora do obudowy
  1. Przykręć radiator do tylnego panelu.
  2. Zmontować złącze IEC.
Tylna ściana obudowy z zamontowanymi: radiatorem i złączem IEC
  1. Umieść samoprzylepne elementy dystansowe, korzystając z zestawu zasilacza.
  2. Przykręcić tranzystor mocy i izolator, na każdej powierzchni musi znajdować się smar termiczny.
  3. Zmontować układ 7812 do zasilania Arduino, powinien on być skierowany w stronę obudowy, aby umożliwić odprowadzanie ciepła, używając jednej ze śrub, które trzymają radiator. Można też użyć plastikowej podkładki, ale w projekcie użyto tego samego izolatora co tranzystor mocy i wygiętego kawałka obudowy.
  4. Na koniec, podłącz tranzystor mocy i 7812 do obwodu zasilającego.
Przymocowany tranzystor do radiatora

Na koniec zmontuj transformator, miernik DC, Arduino + tarczę pomiarową i inne elementy w obudowie. Możesz wykonać następujące kroki, aby to zrobić:

  1. Zaznacz i wywierć otwory pod transformator.
  2. Zmontować transformator.
  3. Przykleić samoprzylepne nóżki obudowy.
  4. Przykleić obwód miernika prądu stałego za pomocą przekładek samoprzylepnych.
Arduino Uno z shieldem i transformatorem przymocowane do obudowy
  1. Zdrapać farbę, aby przykręcić końcówkę GND.
  2. Zbudować zespoły przewodów napięcia sieciowego, wszystkie końcówki to 3/16" Faston. Do odizolowania końcówek użyto rurek termokurczliwych.
  3. Wyciąć przednią część uchwytu obudowy po prawej stronie, aby uzyskać miejsce na przycisk zasilania.
  4. Podłączyć wszystkie przewody zgodnie z instrukcją montażu zamieszczoną w części schematycznej.
  5. Zamontować bezpiecznik (1A).
  6. Ustawić potencjometr napięcia wyjściowego (potencjometr VO), na minimum CCW i wyregulować napięcie wyjściowe jak najbliżej zera woltów za pomocą wieloobrotowego potencjometru precyzyjnej regulacji obwodu zasilacza vkmaker.
Kompletny zasilacz w obudowie
  1. Zamknąć obudowę.
Zamknięta obudowa projektu

Po wykonaniu tych czynności, zasilacz Super Lab jest gotowy do testowania i użytkowania.

Demo

Po zmontowaniu wszystkich elementów i wgraniu kodu do Arduino, poświęć chwilę na podziwianie siebie za dobrze wykonaną pracę i podłącz zasilacz do gniazdka sieciowego. Wciśnij przycisk i powinieneś zobaczyć ekran jak na obrazku poniżej.  Powinieneś również zobaczyć pasek postępu (wraz z napięciem/prądem na wyjściu) zmieniający się wraz z przekręcaniem gałki potencjometrów.

Działający zasilacz laboratoryjny 0-24V/3A
Działający zasilacz laboratoryjny 0-24V/3A

Idź dalej i przetestuj inne funkcje i modyfikuj je, aż będziesz zadowolony.

To jest to! Twój własny zasilacz laboratoryjny!!!

Idąc dalej

Tak wiele postępu może być wniesione do tego projektu dzięki tarczy pomiarowej. Jedną z pierwszych rzeczy, które przychodzą mi na myśl jest możliwość sterowania i monitorowania zasilacza za pomocą aplikacji przez Wi-Fi lub Bluetooth poprzez dodanie do projektu ESP8266 WiFi lub modułu BT/BLE. Czy masz inne fajne pomysły?

Referencje

Do pobrania
Download icon Materiały dodatkowe do projektu zasilacza laboratoryjnego 0-24V/3A

Artykuł BUILD YOUR OWN 0-24V/3A LAB POWER SUPPLY WITH CURRENT LIMIT opracowano w wersji polskiej na podstawie współpracy z portalem www.electronics-lab.com.

AUTOR
Źródło
www.electronics-lab.com
Udostępnij
UK Logo