Полностью автоматическое зарядное устройство для аккумуляторов 12V (автомобильных, ИБП и т.д.) на Arduino

Приветствую вас, дорогие читатели! После почти четырёхмесячного перерыва я снова в деле и в качестве отчёта о проделанной работе считаю необходимым написать данную статью. Долго думал, с чего же начать, ну не постить же в четвёртый раз про видимость нулевую и т.д. - эта цитата и так исправно работала на меня на протяжении трёх последних статей, так что с неё хватит - пусть отправляется на заслуженный отдых! Ну а я тем временем воспользуюсь новой экспериментальной фишкой, назовём её "минуткой наркомании" - такой весёлой и непринуждённой минуткой "с приветом", плавно наводящей на основную мысль статьи. 🙄

Итак, как уже было озвучено в "минутке", сегодня я расскажу вам о том, как я превратил старинное зарядное устройство начала семидесятых в новое, современное, с управлением от микроконтроллера. Мысль такая пришла мне оттого, что мой друг позвал меня к себе на пиво в момент, когда у меня заряжался аккумулятор. Я бы и рад был пойти, но вот незадача - зарядное-то нужно было постоянно контролировать! Бегать к нему раз в полчаса, а то и чаще, чтобы проверить напряжение на аккумуляторе, и если бы оно превысило максимум - уменьшать мощность соответствующим переключателем на передней панели. Согласитесь, неудобно: ты постоянно прикован к заряжающемуся аккумулятору и не можешь никуда отойти, а если вдруг проворонишь нужный момент - аккумулятор тебе спасибо не скажет. С другой стороны, он и так его не скажет: он же памятник говорить не умеет))))

Шутки - шутками, а мне давно хотелось сделать что-то серьёзное на Arduino, с которым я познакомился ещё в ноябре, забрав заветную посылку от китайцев из Aliexpress с микроконтроллером, шилдом и другими ништяками на почте. И вот она, отличная возможность - бери, да делай! Так что я взял и начал, непосредственно, делать!

Схема зарядного устройства

В начале приведу вам весьма кликабельную схему готового устройства:

Список основных компонентов

Далее было бы неплохо определиться со списком основных компонентов, которые я использовал при доработке этого устройства (всё с удобными ссылками на Aliexpress, всё для вас!):

• 8 конденсаторов: 2 по 22 пФ, 1 на 100пФ, пару штук по 100 мФ, и для питания - один большой на 6.3 вольта и два больших на 16, например на 3300, 1000 и 1500 мФ соответственно (можно и все на 16 вольт или больше, без разницы).
• Программируемый микроконтроллер Atmega328 с кварцем на 16 МГц и желательно шилд для него (листать несколько страниц до первого шилда, это будет самый дешевый вариант), чтобы было удобно прошивать.
• По той же причине - зажимные сокеты для вышеназванной микросхемы. Хотя можно, в качестве эконом-варианта обойтись и обычными. Ну или припаять провода к МК и прошивать по ним другой ардуиной или прошивальщиком - как вам удобно.
• 9 транзисторов КТ315 и 1 КТ815 (или аналоги) - выпаять из любой старой советской техники.
• 8 белых рассеивающих светодиодов и 1 зелёный.
• 9 релюх с катушками на 12 вольт: одна на 220 V, четыре под 12 V 16 A и четыре поменьше под 12 V 12 A. Последние 8 нужны как можно меньшего размера.
• 40 резисторов: 15 по 560 Ом, 12 килоомных, 8 по 220, 2 по 10k и по одному экземпляру 3k3, 4k7 и 30k.
• Парочка диодов под 12 вольт: один на полампера, второй минимум на ампер, запас не помешает. Выпаивается откуда угодно, например из дохлых БП.
• Какая-нибудь лампочка, можно светодиод с резистором, горящие от 220 вольт. Вообще неонка бы там круто смотрелась!
• Шестнадцатисегментный экранчик из старого системника для вывода на него текущего напряжения. Ну или три семисегментных. Или вообще забить болт на отображение текущего напряжения: это, всё-таки, автоматическое устройство, напряжение оно контролирует само, вам его знать не обязательно, в крайнем случае тестером померяете. Вместо экранчика можно просто парочку светодиодов поставить, чтобы ардуина ими перемигивала, мол, не зависла я, работаю, всё под контролем! (Нет, я ни разу не видел зависшей Ардуины, но тем не менее надо быть готовым ко всему.) 🙄
• 3 сдвиговых регистра 74HC595
• Ну и что-нибудь типо половинки вот такой монтажной платы (я купил на ебэе 10 штук за стакан компота):

Хочу заметить, что практически все компоненты, используемые в данном проекте, не имеют точных номиналов и могут быть заменены на аналогичные или похожие либо с минимальной адаптацией схемы и прошивки, либо вообще без каких-либо изменений. Я старался использовать те детали, которые буквально валялись у меня под рукой: например, подавляющее большинство используемых тут резисторов и транзисторов я недавно выпаял из допотопного магнитофона Vilma, останки которого после распаивания благополучно отправились на свалку. Так что потраченная сумма на покупку деталей для этого устройства не превышает $15, и то, большая часть бюджета ушла на релюхи.

Исходная версия зарядного

К сожалению, у меня не нашлось фотографии этого зарядного в исходном состоянии, поэтому всё, что я могу вам предложить на данном этапе - фото с уже снятой крышкой, открученной механической частью переключателя мощности (слева) и ручки этого переключателя (справа). Электрическая же его часть торчит сверху устройства. Также из своего родного отверстия вынут тумблер переключения напряжений (6 или 12 вольт):

После проведения вышеназванных манипуляций я также отпаял силовой провод от предохранителя и первичной обмотки трансформатора, хотя он ещё лежит в правом верхнем углу следующего кадра. Но вы к нему особо не привыкайте - я нашёл ему отличную замену, так что больше вы его не увидите.

Принцип работы исходного устройства

Само зарядное устройство построено по простому принципу - на первичную обмотку трансформатора подаётся 220 вольт, соответственно на вторичной также появляется переменное напряжение. Мощностью можно управлять благодаря тому, что со вторичной обмотки есть несколько выводов (всего 9). Это означает, что между первым и каждым из последующих восьми выводов получается всё большее количество витков, а чем больше витков, как известно, - тем выше напряжение (то есть ток или мощность - как вам будет угодно). Эти 8 выводов приходят на тот самый переключатель, с помощью которого вы и выбираете текущую мощность заряда аккумулятора.

Выходит, что между первым выводом вторичной обмотки и выходом с переключателя мы имеем выбранное этим переключателем переменное напряжение. Но им ещё нельзя заряжать аккумулятор, ведь для этого его нужно превратить в постоянное, то есть выпрямить. Отсюда и название данного устройства - выпрямитель.

Для выпрямления переменного напряжения в этом зарядном устройстве используется такая простая и надёжная штука, как диодный мост, состоящий из четырёх мощных диодов Д242, посаженных на индивидуальные радиаторы и закреплённых на диэлектрической подложке. Так что с переключателя ток идёт сначала на вход диодного мостика, а потом уже с его выхода через амперметр на аккумулятор.

Выбор способа коммутации вторичных обмоток

Самой главной проблемой этого проекта стал выбор способа коммутации вышеназванных выводов вторичной обмотки. Вариантов было много, но сразу я решил попробовать самый бредовый и ненадёжный из них, зато самый простой с точки зрения трудозатрат - подключение сервопривода вместо ручного переключения положения переключателя:

Я прикрепил сервомотор к переключателю, по-быстрому написал прошивку и попробовал покрутить его, но, как оказалось, мощности немного не хватило и он иногда застревал в самом ответственном месте, так что этот вариант, увы, не прокатил.

Ах, да! Чуть не забыл! На самом деле со вторичной обмотки было не 9 а 10 выводов, первых два были один для шести вольт, другой для двенадцати, оба шли к тумблеру, а уж потом к диодному мостику:

Но так как я не планировал заряжать аккумуляторы на 6V - от этой функции я отказался, поэтому выкинул тумблер (из конструкции, а не вообще) и заизолировал провод для шести вольт, а двенадцативольтовый пустил с трансформатора напрямую на диодный мост.

Так как же всё-таки коммутировать? Тут уже либо транзисторами, либо тиристорами, либо с помощью реле. И я выбрал последний вариант, ведь релюхи меньше транзисторов / тиристоров и, в отличие от них, совсем не греются, если взять их с запасом по току. Так я и сделал - купил 8 небольших релюшек с катушками на 12 вольт, 4 штуки на 16 ампер и 4 на 12. По размеру они как раз умещались в свободное пространство внутри корпуса зарядного:

Алгоритм работы устройства

И вот тут, окончательно определившись со способом коммутации выводов вторичной обмотки, я считаю нужным сделать некоторое "лірычнае адступленне" и поговорить об алгоритме функционирования устройства. Первоначально для его составления я просто проанализировал свои действия во время зарядки аккумулятора этой шайтан машиной и на основе этого начал набрасывать первые штрихи нового скетча, который вы можете забрать прямо здесь. Я частенько буду цитировать некоторые его кусочки, чтобы вы понимали, что там к чему, так что, на вашем месте, я бы открыл его прямо сейчас и изучал бы по ходу этого повествования.

Для начала введём 3 важнейших параметра:

// Максимальное напряжение * 10
byte maxVoltageX10 = 148;

// Напряжение * 10, при котором уже нельзя увеличивать мощность
byte powerUpMaxTreshold = 142;

// Напряжение * 10, при котором мощность повысится принудительно
byte powerUpMinTreshold = 136;

Умножены на 10 они во-первых потому, что при их вычислении удобнее пользоваться целыми числами - никаких округлений и т.д., во-вторых потому, что на экран, фактически, и выводятся такие числа, а запятая - она как-бы виртуальная, поэтому незачем делать в коде никому не нужные вычисления, и так понятно, что это 14.8, 14.2 и 13.6 вольт соответственно.

Первый параметр сообщает программе максимально допустимое напряжение, при превышении которого будет произведено снижение мощности на один уровень, а в случае, если снижать уже некуда - зарядное должно просто отключиться.

Второй параметр будет использоваться в начале процесса зарядки - после включения мощность будет повышаться, пока напряжение на аккумуляторе будет меньше заданного им значения.

Третий параметр введён специально для случаев, когда заряжаться будет подключённый к машине аккумулятор. Например, кто-то включил радио -> напряжение просело ниже этого значения -> поднимаем мощность. Но что, если нагрузка, просаживающая напряжение до этого уровня, является кратковременной (включение фар или прикуривателя), либо периодической, с определённой частотой (например от ударов сабвуфера), и будет выходить так, что как только мозги повысят мощность - её нужно будет сразу снижать, потом сразу опять повышать и т.д.? Получится замкнутый круг, релюхи будут постоянно щёлкать, изнашиваясь, да и для аккумулятора, возможно, это будет не очень полезно... Специально для этого можно сделать нашу систему как-бы самообучающейся, введя дополнительный параметр:

// Если между повышением мощности по powerUpMinTreshold и её понижением прошло менее, чем столько миллисекунд, то powerUpMinTreshold снизится на 1
unsigned int powerUpMinTresholdTimeout = 60000;

Как видно из комментария, благодаря этому параметру powerUpMinTreshold будет снижаться на одну десятую вольта каждый раз, как мозги будут понижать мощность менее чем через powerUpMinTresholdTimeout миллисекунд после её повышения. Всё, проблема решена: пощёлкают релюхи один раз, пощёлкают второй, а на третий они уже 10 раз подумают перед тем, как щёлкнуть. Ха-ха-ха, не с теми связались!

Ну вот, с основой алгоритма вроде более-менее разобрались, теперь переходим к подробностям и нюансам.

Я сразу запланировал, что питание всей системы будет осуществляться от самого аккумулятора, а 220 вольт - подключены через реле, управляемое мозгами (то есть Ардуиной), благодаря чему у нас будет возможность отключить подачу питания на устройство в случае аварийной ситуации или по завершению зарядки аккумулятора. Более того, от реле будет меньше искрения, чем от засовывания вилки в розетку, так что этот вариант ещё и надёжнее. Про её подключение будет, естественно, написано ниже, ведь пока мы обсуждаем лишь теоретические вопросы.

Процесс включения будет происходить следующим образом: сначала нужно будет воткнуть вилку питания в розетку, после чего, конечно же, ничего не произойдёт, а далее необходимо будет подключить сам аккумулятор, и если напряжение на нём больше восьми вольт - вся система запустится и начнёт его заряжать. Но уже тут в дело вступает очередной хитрый параметр:

// Задержка в миллисекундах перед включением зарядки
unsigned int powerOnDelay = 2000;

Нужен он для того, чтобы, например, уменьшить искрообразование в блоке реле, с помощью которого в конечном устройстве будет происходить коммутация выводов вторичной обмотки трансформатора, ведь на первой релюхе блока реле ток будет выше, чем на релюхе, подающей питание на трансформатор, к тому же эту вторую релюху, в случае чего, будет намного проще заменить. То есть при подключении аккумулятора сначала мощность поднимется до единицы, а потом, после этой задержки, включится силовая релюха. За это отвечают вот эти четыре строчки кода в процедуре повышения мощности:

if (powerLevel == 1) {
delay(powerOnDelay);
digitalWrite(relay220Pin, HIGH);
}

Вообще в этом условном операторе можно было бы уточнить, чтобы он исполнялся лишь один раз при первом включении, но, по идее, если это случится потом, когда мощность понизится до первого уровня с более высоких - ничего ж не изменится, релюха и так будет включена, так что я решил не городить дополнительный огород.

Кстати, в коде есть весьма интересный параметр:

// Уровень мощости (начальный)
byte powerLevel = 0;

Он, как вы уже догадались, устанавливает начальный уровень мощности и был введён на очень ранней стадии разработки прошивки и на данный момент используется там просто как текущий уровень. Любопытно то, что если сейчас его увеличить, то условие, описанное в предыдущем пункте, никогда не сработает, то есть 220 вольт на первичную обмотку трансформатора так и не попадут, а значит устройство заряжать аккумулятор не будет. Пичалька.

Ну да ладно, не будем о грустном. Допустим, мы включили устройство и зарядка пошла. Всё хорошо, но не стоит забывать, что после поднятия тока напряжение на аккумуляторе поднимается не мгновенно, и если не делать задержек перед повышением, то мозги после включения мгновенно переведут мощность на максимальный уровень, а это неправильно, поэтому и вводится следующий параметр:

// Время, через которое можно повышать мощность на один уровень, в миллисекундах
int powerUpTime = 5000;

То есть между двумя повышениями мощности должно будет пройти как минимум 5000 миллисекунд, за которые напряжение уже может подняться выше powerUpMaxTreshold и тогда повышать мощность будет уже не нужно.

Что касается понижения мощности, то тут вообще всё просто: программа периодически проверяет, а не превышает ли текущее напряжение максимально допустимый уровень, и если превышает - мощность надо снижать:

// Понижение мощности
if (voltageX10 > maxVoltageX10) {

Но при выполнении этого условия должны быть два варианта развития событий. Первый, это когда текущий уровень мощности больше единицы:

if (powerLevel > 1) {

В этом случае нам нужно выставить мощность на уровень ниже и дальше продолжать зарядку. В противном же случае, когда уровень мощности уже и так стоял самый низкий - просто выключаем питание и моргаем экранчиком. Улыбаемся и машем, короче говоря, аккумулятор полностью заряжен!

Вообще, как показала практика, те аккумуляторы, которые заряжал я, ещё на втором уровне мощности можно было спокойно снимать с зарядки, ведь ток при этом уже опускается ниже 500 мА. Тем не менее не стоит пренебрегать функцией автоотключения - аккумуляторы же разные бывают...

Также для понижения мощности есть свой параметр задержки, схожий с параметром powerUpTime для повышения:

//Пауза после понижения мощности, в миллисекундах
int powerDownPause = 500;

Правда, реализован он проще, через обычный delay() после непосредственного снижения. Я посчитал, что полсекунды - это не настолько большой промежуток, чтобы использовать его как дополнительное условие в операторе выбора, но каждому своё, так что если кому-то из вас будет нечем заняться - в первую очередь можно было бы доработать этот кусок кода по принципу powerUpTime.

Удивительно, как это я столько уже написал и не сказал, откуда же я беру, собственно, само текущее напряжение. Исправляемся:

void loop() {
ct=millis();
voltageX10=(analogRead(voltageInput)+voltageX10Shift)/voltageX10Coefficient;

Получается, что в начале каждой итерации loop'а, который, как известно, просто бесконечно повторяется после запуска системы, мы делаем две вещи. Сначала записываем в переменную ct текущее время с момента запуска микросхемы, в миллисекундах, а далее мы как раз вычисляем текущее напряжение с помощью процедуры analogRead(), используя заданный в начале скетча номер аналогового входа мониторинга:

// Аналоговый вход для мониторинга напряжения
byte voltageInput = 5;

А также 2 коэффициента, о которых я подробно расскажу позже:

// Коэффициент вычисления напряжения (на него делится)
float voltageX10Coefficient = 5.11;

// Сдвиг вычисления напряжения (он прибавляется)
int voltageX10Shift = 35;

Но всё было бы слишком просто, если бы всё было так просто. Поэтому для усложнения алгоритма в код были введены ещё 2 переменные:

boolean goingUp = true, isUpAfter = false;

Первая переменная сообщает нам, в каком состоянии находится сейчас процесс зарядки. Её значение истинно до тех пор, пока мощность не снизится в первый раз. То есть goingUp = true говорит нам о том, что мы не так давно включили зарядное и оно ещё заряжает аккумулятор максимально возможным током, ни разу не снизив его для защиты от перенапряжения.

Со второй ваще всё сложно - она нам говорит о том, происходило ли повышение мощности после того, как goingUp стал равен false и устанавливается следующим простым кусочком кода в конце процедуры повышения мощности:

if (goingUp == false) {isUpAfter = true;}

Вы щас, наверное, думаете, а нахрена всё это нужно? Щас обьясню!

Причиной добавления этих двух переменных явилась как раз реализация возможности заряжать стоящий на автомобиле аккумулятор с подключенной к нему переменной нагрузкой. Первое назначение функции goingUp - определение параметра, по которому сработает повышение мощности:

if ((powerLevel <8) && (ct > powerTime + powerUpTime) && ((goingUp == true && voltageX10 < powerUpMaxTreshold) || (goingUp == false && voltageX10 < powerUpMinTreshold))) {

Как видим, в первой фазе зарядки мы повышаем мощность, если текущее напряжение меньше powerUpMaxTreshold, а во второй фазе - если оно меньше powerUpMinTreshold: это те самые параметры, о которых я говорил в начале.

Если условный оператор, написанный выше, всё же выполняется, а этот самый goingUp равен false, то в дело вступает запатентованная система дополнительной проверки напряжения:

boolean stillLow = true;
if (goingUp == false) {
for (int x=0; x <= upCycles; x++){
voltageX10=(analogRead(voltageInput)+voltageX10Shift)/voltageX10Coefficient;
if (voltageX10 > powerUpMinTreshold) {stillLow=false; break;}
delay(1);
}
}
if (stillLow == true) {

В которой на сцену выходит новое действующее лицо:

//Количество миллисекундных итераций проверки напряжения перед поднятием мощности
int upCycles = 5000;

Дело в том, что при сигнале на повышение мощности после того, как goingUp стала false, мы скорее всего имеем дело с какой-то непостоянной нагрузкой - тот же сабвуфер, как я уже предполагал, или ещё какая-нибудь неведомая фигня. А раз так, то почему бы нам вместо того, чтобы тупо поднимать мощность, лишний раз щёлкая нашими драгоценными релюхами и рискуя получить на мгновение напряжение на аккумуляторе выше максимально заданного, не устроить простую проверку: 5 тысяч раз (upCycles) с интервалом в одну миллисекунду проверить текущее напряжение, и если оно хоть раз, слышите, хоть один раз превысит powerUpMinTreshold - всё, хана, никакого повышения не будет, сворачивайте удочки! Простая, но действенная проверка.

isUpAfter, в свою очередь, помогает нам реализовать функцию уменьшения powerUpMinTreshold (я говорил о ней в начале), вот, как она выглядит:

if ((isUpAfter == true) && (powerTime > ct - powerUpMinTresholdTimeout)) {powerUpMinTreshold = powerUpMinTreshold - 1;}

Здесь powerTime - это время последнего повышения мощности на текущий момент.

Дело в том, что, кроме условия упомянутого выше powerUpMinTresholdTimeout, уменьшать его нам нужно лишь тогда, когда мы опускаем мощность после того, как предварительно её подняли после того, как уже начали опускать. Я ж говорил, что с этим isUpAfter всё сложно!

Вот такой вот алгоритм, хотите - верьте, хотите - нет . Об остальных его подробностях и тонкостях я буду рассказывать по ходу дальнейшего повествования о, непосредственно, сборке устройства.

Подготовка блока реле

Итак, разобравшись с тем, какие контакты релюшек за что отвечают и определившись с их размещением друг относительно друга, я приступил к склеиванию:

Для этого я использовал валявшийся неподалёку "Момент - Кристалл". Не буду говорить, что это какой-то там супер-пупер клей, но по своим свойствам он меня устраивает. Лучше, конечно, использовать Хайгировский "Склею Насмерть", он сохнет быстрее и вообще затвердевает в конце, но его в тюбике в 2-3 раза меньше, а стоит он раза в полтора дороже Момента, поэтому, как говорил герой одного хорошего советского мультика, "И так сойдёт!".

По склейке всё просто и написано на тюбике - нанести на обе поверхности, подождать 5-10 минут и сильно сжать (ага, так сильно, чтобы зажатый между релюшками уголёк превратился в алмаз 😆 ):

Вот и всё, релюшки сжаты. Как видите, центральные контакты я разместил рядом друг с другом, их всё равно надо будет соединять между собой:

Точно так же я поступил и с большими релюхами, а потом склеил эти 2 получившихся блока вместе друг с другом, после чего начал припаивать к контактам провода. Толстый жёлтый провод подключён по очереди ко всем релюхам - это выходная шина, которая дальше пойдёт на диодный мост, красные провода - на 4 первых вывода со вторичной обмотки трансформатора, а маленький жёлтый проводок, идущий по очереди через все релюшки - это постоянные +12 вольт катушек. А минусы катушек, как вы уже догадались - это коричневые и бело-какие-то-там проводки, к ним мы в скором времени ещё вернёмся.

Та же конструкция, но уже с другой стороны, с новыми припаянными проводками для подсоединения выводов вторичной обмотки. Причём с больших релюх на 1 вывод приходится по 2 проводка - так уж сделана эта модель реле, для более равномерного распределения нагрузки и, как следствие, меньшему тепловыделению:

Так как ток, который жрут катушки в таких релюхах (~100 мА), намного превышает максимальный ток, который можно брать с выходов Arduino (~40 mA) или сдвигового регистра 74HC595 (~25 mA), для включения катушек реле нужно использовать транзисторы. И старые добрые оранжевые КТ315 будто созданы для этого!

Это n-p-n транзисторы, поэтому в схеме, если объяснять по-простому, ток должен идти от плюса к катушке, потом из неё на коллектор транзистора и дальше из эмиттера транзистора в минус. Открывается же этот транзистор током из базы в эмиттер, но ток там нужен совсем небольшой, поэтому базы транзисторов мы подключаем через резисторы в 1 кОм (1000 Ом):

Теперь осталось припаять к резисторам недлинные проводки, не забывая всё тщательно изолировать, и можно закреплять - лично я решил приклеить транзисторы к релюхам сбоку, чтобы они не путались и ничего не оторвалось:

Как видно на фото, транзисторы отлично расположились с двух сторон блока реле, также я залил клеем остальные контакты, чтобы быть уверенным, что ничего нигде не закоротит и не сгорит:

Транзисторы приклеены и блок почти готов:

Теперь перед нами встаёт вопрос - к чему же подключить транзисторы? К Arduino? Нет, тогда не хватит выходов для других компонентов, и вот в таких ситуациях в дело вступает спасительная микросхема - сдвиговый регистр 74HC595. Про него и так много написано в интернете, поэтому я не буду расписывать тут 3 абзаца, скажу лишь, что благодаря таким вот микросхемам можно увеличить количество выходов Arduino, пожертовав для этого лишь тремя. Причём их можно соединять последовательно в цепочку. Есть разные варианты подобных микросхем, например на 16 выходов или на 8, в разных корпусах. В данном проекте я решил использовать вариант на 8 выходов в маленьком корпусе SO-16. Работа хоть и ювелирная, зато всё это занимает мало места, которого и так не хватает в компактном корпусе устройства, не рассчитанного на подобные доработки:

Для индикации текущей мощности устройства я решил использовать 8 светодиодов, по одному на каждую пару транзистор / реле, для этого я использовал восьмижильный шлейф, подпаяв каждую жилу к соответствующему каналу управления, но не сразу к регистру, а к резисторам, электрически разницы нет, но механически так надёжнее, я считаю. Микросхему я, после тщательной проверки (о ней будет ниже), залил тем же самым клеем и ещё раз прошёлся им по всем транзисторам - теперь эта система стала ещё более "цельной" и крепкой:

Система индикации напряжения

Настала пора теоретических испытаний системы индикации. Для вывода текущего напряжения аккумулятора я использовал экранчик от старого системника времён первых пентиумов. С ним нет никаких премудростей, каждый сегмент - это простой зелёный светодиод, работающий от 2-2,1 вольт. Исключение составляет лишь единица - в ней 2 сегмента запараллелены и выведены на одну ножку. Всего у экранчика 16 ног: 1 плюс и 15 минусов. То есть на плюс всегда подаётся питание, а подача земли на определённую ножку зажигает нужный нам сегмент - всё предельно просто, но как это реализовать? Для этого опять же используем сдвиговые регистры, на этот раз 2 штуки. Для прототипирования на макетной плате я использовал такие же 74HC595, но уже в корпусе DIP-16, ведь с ними работать намного удобнее. На следующей картинке, как вы видите, система уже собрана и работает:

Но данная система сильно отличается от того, что вошло в конечное устройство. Начнём с того, что изначально для питания экранчика я решил использовать стабилизатор, хотя в итоге я от него отказался и каждую ногу экрана подключил через резистор в 560 Ом, во вторых на этой схеме питание светодиодов идёт через ещё один стабилизатор, более того, он питает и сам сдвиговый регистр. Но в итоге стабилизатор в моём зарядном остался только один - сделанный ещё в СССР КРЕН5В, как вы уже догадались, на 5 вольт.

Тем не менее, на этом этапе способ запитывания железа был не столь важен - главное было научиться выводить на экран осмысленную информацию, для чего нужно было выяснить, какому сегменту соответствует каждый из выводов регистров и далее уже в прошивке создать два массива - десятков и единиц, в которые с помощью единиц и нулей забить нужную маску для каждого отображаемого числа, то есть 0-19 для первых двух знаков экрана и 0-9 для третьего знака:

// Шаблоны для экрана
char* dozens[]={"10000001","10111011","01100001","00101001","00011011","00001101","00000101","10101011","00000001","00001001", "10000000","10111010","01100000","00101000","00011010","00001100","00000100","10101010","00000000","00001000"};
char* ones[]={"10000010","10111110","10001001","10011000","10110100","11010000","11000000","10111010","10000000","10010000"};

Также, порядок подключения регистров в процессе дальнейшей работы поменялся - первой в цепочке будет стоять блок реле, а уже потом экранчик, релюшки же всё таки важнее, правда, на данный момент это не столь существенно, ведь порядок не имеет особого значения - просто в прошивке, в процедуре вывода, нужно поменять пару строчек местами и все дела.

Когда система заработала - к ней вместо третьего сдвигового регистра я подключил готовый блок реле. А чтобы релюхи ещё и щёлкали - мне понадобился двенадцативольтовый блок питания (не от китайского свитча, а стабилизированный, с плавным выбором напряжения). Если хотите использовать нестабилизированный - используйте девятивольтовый, или даже 7,5 - на них как раз без нагрузки вольт 12 будет. Главное - не попутайте постоянку с перемнкой! На следующей фотке видно, как 12 вольт подведены на соплях двумя штекерами с проводами в правом верхнем углу 🙄

Вот уже и экранчик работает! Написал скетч, который на экран поочерёдно выводит числа от нуля до 199, а на светодиоды справа - их двоичное представление. Ну весело же!

Работа со сдвиговыми регистрами, как я уже говорил, осуществляется по трём проводам. Номера их контактов задаются в самом начале моего скетча:

// Контакт, который подключён к ST_CP входу 74HC595
int latchPin = 8, voltageX10,voltageGuard,ons,dz,
// Контакт, который подключён к SH_CP входу 74HC595
clockPin = 12,
// Контакт, который подключён к DS входу 74HC595
dataPin = 11;

При запуске системы режим работы этих контактов, как и остальных, используемых нами, устанавливается как OUTPUT:

void setup() {
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(relay220Pin, OUTPUT);
pinMode(fanPin, OUTPUT);

Ну а сам вывод информации на регистры выглядит следующим образом:

digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, bitseq(ones[ons]));
shiftOut(dataPin, clockPin, MSBFIRST, bitseq(dozens[dz]));
shiftOut(dataPin, clockPin, MSBFIRST, bitseq(relays[powerLevel]));
digitalWrite(latchPin, HIGH);

Причём изначально shiftOut() принимает на вход переменную типа byte, а так как нам намного нагляднее записывать в регистры напрямую единицы и нули - в коде используется специальная функция bitseq(), которая преобразует вышеприведённые шаблоны как раз в то, что от нас хочет shiftOut():

byte bitseq (char s[8]){
byte ab=0;
for (byte ba=0; ba<8; ba++){
if (s[ba] == '0') {bitWrite(ab,ba,0);} else {bitWrite(ab,ba,1);}
}
return ab;
}

К тому времени мой рабочий стол выглядел примерно так, как на следующей фотке. Не ломайте голову, задаваясь вопросом, что на монторе - это Скорая Помощь. Классный сериал, второй раз уже пересматриваю. 🙄 Кстати, для соединения не силовых цепей в своём устройстве я использовал витую пару, ту самую, которая категории 5е, у меня её просто уйма - старые кабели с крыши я не выбрасываю, а распускаю. Но для таких вещей хороши не любые проводки. Те, что я использовал - внутри не цельные, а многожильные, благодаря чему они очень эластичные и не ломкие, также у них качественная изоляция. А вот обычную витую пару с цельными жилами я бы не использовал - она очень туго гнётся (ну, относительно), и припаивать её к маленьким микросхемам в корпусе SO-16 было бы вообще неразумно. Что, скажете, мол, надо было ДИПовские микрухи использовать? Ха, вы ещё не видели, какой мазохизм начнётся прямо сейчас, так что не будем тянуть кота за рога (ага) - поехали!

На самом деле это не такая уж и плохая идея - разместить маленькие микросхемки внутри индикатора. Ведь места в старом корпусе и так нет, переднюю панель пришлось ставить на небольшие проставки, а если бы я использовал регистры в ДИПовских корпусах - уууууу, я не знаю, как бы всё туда залезло!

Как я уже говорил, в финальном варианте сегменты подключены через резисторы, а не напрямую, но, тем не менее, первый вариант я решил тоже показать: может быть, кому-то так больше понравится. Так как сам этот экранчик с обратной стороны чем-то залит (какая гадость эти ваши заливные экранчики), а поверхность этой заливки ко всему прочему ещё и вогнута внутрь, я вырезал из пластиковой карточки оплаты угадайте какого белорусского монополиста в области электросвязи маленькую плоскую пластинку, которую приклеил прямо к экранчику и уже на неё потом приклеил сами регистры, предварительно пометив на обратной стороне каждого из них первую ножку (потому что "Смотры не перапутай, Кутузау!").

Ну и всё, дальше я начал припаивать проводки:

После припаивания всех проводов и, опять же, проверки, показавшей, что всё работает - я залил всё клеем. Потому что одно неверное движение и проводок отломается от контакта, что-нибудь закоротит и будет большая-пребольшая пичалька. А с клеем такого не произойдёт, с клеем всё хорошо. Клей, короче, рулит. До тех пор, пока его не придётся отдирать 😆 👿 Но не будем о грустном, вот, что получилось после этих манипуляций:

Вот я уже даже соединил эти два блока вместе (правда, временно) чтобы ещё раз насладиться мигающими цыферками и щёлкающими релюшками:

К сожалению, при объединении экранчика с регистрами в одно целое мне пришлось слегка изменить порядок подключения его ног, поэтому после запуска всей системы я вместо арабских цифр увидел какие-то инопланетные:

Хотя, по сути, в единице и девятке мало инопланетного, лишь по середине была какая-то фигня, но это всё мелочи. Следующим шагом было прикручивание вольтметра, то бишь создание датчика напряжения, ведь именно от текущего напряжения должен зависеть алгоритм работы моего зарядного устройства.

Измерение напряжения с помощью Arduino

Ардуино - вещь хорошая, в ней изначально есть аналоговые входы, на которых можно в реальном времени мониторить напряжение. Загвоздка состоит лишь в том, что диапазон измерения этих входов простирается от нуля лишь до пяти вольт, а у нас напряжения будут почти до 15, так что эту проблему надо как-то решать. И тут нам на помощь приходит простейший делитель напряжения на двух резисторах. Например, за абсолютный максимум мы возьмём 20 вольт (ну, на всякий случай, чтобы ничего, если что, не сгорело), а потолок у нас - 5, то есть четвёртая часть от максимума, значит делить напряжение нам надо именно на 4. Для этого возьмём 2 резистора таких номиналов, чтобы номинал первого составлял 1/4, а номинал второго - 3/4 от суммы их номиналов. Например, 10 и 30 кОм. Или 5 и 15 кОм, или 2,5 и 7,5, ну вы поняли. Меньше брать не стоит, потому что ток там небольшой. Ну и подключаете по схеме: 10 между аналоговым входом и землёй, а 30 между аналоговым входом и выходом зарядки на аккумулятор.

Но не всё так просто - процедура analogRead() выдаст вам значение от 0 до 1024, где ноль это ноль, а 1024 - это 5 вольт для неё или 20 вольт для нас. Поэтому для пересчёта этого значения нам нужно ввести определённый коэффициент, который мы будем задавать как константу в шапке прошивки (float voltageX10Coefficient = 5.11;). Забегая немного вперёд скажу, что в последствии напряжение, которое видит Arduino, при большом токе начинало прыгать с разбросом до полувольта, поэтому пришлось наш импровизированный датчик подключить через диод, после которого я поставил конденсатор 16V 1000 мФ, и туда же я подключил реле на 220 В, но об этом в конце. Почему я говорю об этом сейчас? Потому что диод, как известно, слегка понижает напряжение, поэтому я ввёл и второй коэффициент, компенсирующий наличие этого диода (int voltageX10Shift = 35;), то есть сначала к выходному значению прибавляется второй коэффициент, а потом то, что получилось, делится на первый.

В итоге мониторинг напряжения выдался на славу - сравните показания с тестером (это не аккумулятор подключен к устройству, а тот самый самодельный стабилизированный блок питания):

Передняя панель зарядного устройства

Далее пришло время заняться мордой нашего устройства. Изначально у меня были мысли вообще сделать и прилепить туда новую панель, но, поразмыслив, я придумал, как использовать старые надписи, так что всё получилось достаточно осмысленно. На месте регулятора тока сверлятся отверстия под светодиоды, а стрелка сверху как раз показывает, в каком направлении ток будет больше, ну классно же!

Вот уже и светодиоды поставлены на свои места, и экранчик вставлен на новое место, и даже остальным отверстиям нашлось применение: в дырке от регулятора тока будет лампочка, подключённая к первичной обмотке трансформатора - она будет гореть, когда идёт зарядка, то есть когда на трансформатор подаётся 220 вольт. А если зарядка вроде и заряжает, а лампочка не горит - значит проверяйте, не забыли ли вставить вилку в розетку! В остверстии же от переключателя 6-12 вольт вставлена пластмассовая окантовка для светодиода, который через резистор без стабилизатора будет подключен напрямую к аккумулятору и по яркости его свечения будет видно, насколько заряжен аккумулятор. Это полезно, если аккум будет вообще дохлый и даже пяти вольт на нём не будет для питания мозгов - тогда диод будет тускло светиться и не возникнет вопросов, мол, может устройство сломалось. Хотя, конечно, я оправдываюсь: не было бы дырки - я бы и не думал о том, чтобы туда что-нибудь вставить. У мужиков так обычно всегда и бывает, если вы понимаете о чём я

Кстати, вот вы скажете, мол, где ты, Андрюша, видел разряженные до 5ти вольт автомобильные аккумуляторы? Ну, на тот момент я их нигде не видел, а вот после окончания работ над этой зарядкой мне один такой принесли. 3 вольта. И я даже зарядил его, и он даже живой, хоть, как я полагаю, и засульфатирован вусмерть. Был и второй в похожем состоянии, но его уже ничего не спасло 😆

Вот так вот выглядела на тот момент морда с обратной стороны:

А на следующей фотке я потихоньку обдираю клей и заменяю проводки на резисторы. Стабилизатор в левом нижнем углу фотки я, конечно же, тоже ампутировал за ненадобностью. И. кстати, резисторы припаивать гораздо проще, чем проводки - если бы я сейчас делал всё этого заново - делал бы сразу так, с резисторами и этими маленькими микросхемами.

Также на этой фотке в левом верхнем углу вы можете подсмотреть, как я подключил светодиоды. Минус у них общий, идёт по внутреннему радиусу и подключён к общему минусу устройства через резистор в 3.3 кОм - это я такой подобрал, чтобы и ярко было, и не слепили они. Вроде как в самый раз получилось. Почему резистор один? Потому что в любой момент времени, за исключением момента переключения нагрузки между релюхами, на табло будет гореть лишь один светодиод.

Почему за исключением момента переключения? Потому что если одна релюха будет выключаться, а вторая потом включаться - в момент выключения первой и в момент включения второй на их контактах будет появляться искра, от этих искр будет образовываться нагар на контактах, из-за которого они выйдут из строя со временем - он увеличит их сопротивление, они начнут греться, и всё, мементо море! Так что правильно сначала включать вторую релюху, и как только она включится - выключать первую, тогда мы избавляемся от искр и релюхи будут жить долго и счастливо! Кстати, на родном переключателе всё именно так и сделано, так что нет, это не я придумал, апплодисменты и цветы в машину направляются в данном случае конструкторам оригинального устройства, а не вашему покорному слуге. Ну что ж, не всё коту масленица. 🙄

Кстати, задержка переключения между релюхами задаётся вот этим параметром:

// Длительность перехода между релюхами в миллисекундах
byte relayTransition = 80;

Но что будет, если каким-то волшебным образом две или больше релюх окажутся одновременно включёнными на время, большее, чем отведённое на переключение, вследствие какого-то глюка? А будет очень плохо: вы, считайте, закоротите участок вторичной обмотки. Провода начнут плавится, с трансформатора пойдёт дым и вообще случится армагеддон. Тот самый, который Майкл Бэй снимал.

Так вот, дорогие господа, дамы и ван-даммы, специально для этого я придумал систему защиты от подобного армагедца. К плюсу каждого светодиода подключён резистор на 220 Ом. Почему именно 220? Во-первых потому что в тот день Луна была в Сатурне, а во-вторых потому что перед Новым Годом мне довелось распаять пару магнитофонов отечественных, а также не менее отечественное электронное пианино (или фортепиано, я хз, но не рояль короче), так вот оттуда я выпаял целый коробок этих резисторов на 220 Ом, надо ж их куда-то сувать - так вот, отличное применение!

С другой же стороны все эти резисторы соединены и притянуты к земле через 4к7 резистор (это значит 4,7 кОм, пора уже называть вещи своими именами!), которых у меня тоже дохрена и больше. Так вот мы меряем в этой точке G, куда сходятся все эти 9 резисторов, напряжение, то есть подключаем эту точку к очередному аналоговому входу Ардуины, который задаётся следующим параметром:

// Аналоговый вход для мониторинга количества включённых релюх
byte guardInput = 4;

И по этому напряжению мы сразу видим - сколько в данный момент горит там светоиодов, а так, как они подключены напрямую к транзисторам, то это то же самое, что мы видим, сколько в данный момент включено релюх, а это именно то, что нам и надо в данной ситуации! То есть мы задаём порог напряжения, при превышении которого мы во-первых сразу обрубаем 220 вольт с помощью соответствующей релюхи, а во-вторых пытаемся исправить ситуацию с релюхами, и как только она исправлена - включаем опять 220 и продолжаем работать как ни в чём не бывало. Всё просто и надёжно, я проверял!

Этот порог задаётся здесь:

// Максимально допустимое значение guardInput
byte guardTreshold = 160;

А сама процедура вышеописанной проверки выполняется каждый цикл loop`а и выглядит следующим образом:

// Проверка на количество включенных релюх и автоматическое отключение - восстановление - включение
if (voltageGuard > guardTreshold) {
digitalWrite(relay220Pin, LOW);
while (voltageGuard > guardTreshold) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, bitseq(ones[ons]));
shiftOut(dataPin, clockPin, MSBFIRST, bitseq(dozens[dz]));
shiftOut(dataPin, clockPin, MSBFIRST, bitseq(relays[powerLevel]));
digitalWrite(latchPin, HIGH);
voltageGuard=analogRead(guardInput);
}
digitalWrite(relay220Pin, HIGH);
}

А теперь я всё-таки покажу обещанную 9 абзацев назад фотку, хотя бы просто для приличия:

А снятая крышка показывает нам напряжение. Милота!

Реле подключения к сети переменного тока

Тем не менее нам нужно двигаться дальше. Как видите, зарядное постепенно собирается, провода постепенно удлиняются и на сцену выходят два новых персонажа - та самая релюха на 220 вольт и небольшой двенадцативольтовый кулер - восьмидесятка от компа:

Релюха это обычная, ничем не отличающаяся от других. Тянет 220 вольт при, вроде 10 амперах. Но нам такого не надо, у нас и предохранитель-то на 1 ампер стоит. Но запас в таких вещах - это хорошо, это надёжность. Катушка у этой релюхи работает от 12 вольт, но есть такие же и на 5. Я купил сразу 25 штук таких на Али, по дешёвке. Почему я взял на 12, а не на 5? Вот смотрите, куда бы я её не включал - всё равно бы нужен был транзистор, правильно? Даже если б она на 5 вольт была. Только вот если она на 5 - её надо через стаб подключать, через который и так все мозги запитываются, он бы от этого ещё больше грелся - нахрена это надо? Можно напрямую тыркнуть в 12, да хоть 15 там будет - ей пофигу, она работает. Причём, начиная вольт с восьми. Светодиод я к ней подключил просто для индикации на время тестирования, типо если светодиод загорелся - значит она работает и виртуально на трансформатор пошло 220 вольт. Подключена она напрямую к выходу ардуины, через тот же самый КТ315, точно так же, как и остальные релюхи в том самом блоке. И да, резюк тоже на 1кОм, хотя там, наверное, и 2 прокатит, можете ставить те, которых больше, но учтите, что чем меньше номинал резюка - тем больший ток будет уходить вникуда через транзистор. Для общей энергоэффективности эти +- пару миллиампер пофигу, а вот для слаботочных выходов ардуины и регистров - не совсем, так что вот.

Включение этой релюхи, как вы и так, наверное, поняли, происходит с помощью

digitalWrite(relay220Pin, HIGH);

А отключение с помощью

digitalWrite(relay220Pin, LOW);

Подключение кулера для охлаждения зарядного

Но вот кулер жрёт вроде как 140 миллиампер, судя по наклейке на нём, так что КТ315 тут уже не прокатят, они по спецификации только до сотни, поэтому я взял КТ815А. Они идут до полутора тыщ миллиампер и его хватит с головой. Есть и другие варианты, я просто всегда стараюсь использовать то, чего у меня много, может у вас, например, будет для кулера какой-нибудь другой транзистор, если он потянет до 20 вольт и до 150 миллиампер - ставьте, если n-p-n, то просто по ногам смотрите распиновку, а если p-n-p - то надо немного схему изменить, но в данном случае это всё несущественно. Только вот тут есть ещё один нюанс...

Вы когда-нибудь слышали, как пищит кулер? Нет не от вращения, просто пищит? Я тоже не слышал, но вот тут посчастливилось. А всё потому, что Arduino промежуточные значения выходных напряжений (больше нуля, но меньше пяти) формирует с помощью ШИМ, то есть это быстрые-быстрые колебания напряжения, сам широтно-импульсный модулятор работает на определённой частоте, а транзисторы, как известно, тоже умеют работать на оперелённых частотах, поэтому эти импульсы через транзистор передаются на кулер и он, в силу своей архитектуры, начинает пищать. Не буду вдаваться в подробности, поскольку сам их не знаю, но лечится всё это втыканием кондёра на 100 мФ плюсом на базу и минусов на эмиттер этого транзистора. Напряжения там до 5ти вольт, соответственно кондёр можно хоть на 6.3 вольта ставить. Всё, писк пропадёт и будет вообще лепота!

Номер ШИМ-контакта, по которому происходит управление кулером, задаётся следующим параметром:

// Выход на управление вентилятором
byte fanPin = 6;

Его скорости от нуля (0V) до 255 (5V) с привязкой к уровням мощности задаются следующим массивом:

// Настройки скорости вращения вентилятора
byte fanSpeeds[]={0,0,80,90,100,110,120,180,255};

А само задание этих скоростей прописано в процедурах повышения и понижения мощности:

analogWrite(fanPin,fanSpeeds[powerLevel]);

Вот, кстати, релюха с кулером поближе:

Дальнейшая работа над лицевой панелью

Но идём дальше. Тут я уже примерил на своё место предохранитель в новом корпусе - на старом было типо несколько напряжений, хотя по факту использовалось только одно, и от него был отколот кусок, а этот как новенький, на 220 вольт, из отцовских запасов. Ну и тот самый нижний светодиодик поставил и вклеил на тот же самый клей.

Наконец, пришло время собирать и ставить на место лицевую панель! Как видите, все провода уже припаяны, даже пятивольтовая КРЕНка торчит внизу кадра, в корпус вкручены проставки, чтобы немного отодвинуть панель (я уже говорил об этом), ведь раньше она крепилась вплотную к корпусу. Как видите, провода во многих местах я просунул в кембрики, чтобы нигде ничего не перетёрлось и не коротнуло. 12 вольт на КРЕНку приходят напрямую с диодного моста, проводом классом выше, чем простая витая пара. Минус подключен к общему минусу напрямую, а вот плюс - через диод, а то Вася Пупкин перепутает полярность при подключении аккумулятора и всё, финита ля комедия, перепаивайте половину сгоревших компонентов! А так можно быть спокойным.

После того, как я пару раз прикинул, как будут идти провода между корпусом и панелью - я решил приклеить их в нужных местах, чтобы они не болтались и не мешались, сверху придавил подручныи предметами, закрепил прищепками и оставил так на ночь, чтобы клей высох:

Монтаж контроллера Atmega328P c обвязкой и другими элементами

К этому времени на половинке одной из тех самых монтажных платок я уже смонтировал львиную долю оставшихся компонентов - сокету для микросхемы, кварц, кондёры, транзистор для кулера и т.д. и т.п.:

Саму плату пришлось с одной стороны обрезать - она была слишком большая и не влазила. Нижнюю часть, а потом и всю полностью я замотал бумажным скотчем, чтобы она в процессе работы ни на что не закоротила.

К тому времени передняя панель уже окончательно была установлена на своё почётное место, а пятивольтовая КРЕНка - прикручена к корпусу за панелью через теплопроводящую изоляционную прокладку и пластиковую вставку для винта - благодаря этому микросхема будет надёжно охлаждаться через массивный металлический корпус, при этом не соединяясь с ним электрически.

Финальная настройка параметров устройства

Тут уже видно, как работает полусобранная система, но опять же, пока только от блока питания, ведь в моей конструкции розетка для включения аккумулятора подключается в самый последний момент. Ну так уж вышло, что поделать...

После включения было обнаружено, что при большом токе, когда ажно амперметр зашкаливает - зарядное устройство видит напряжение на 0.5-0.8 вольта больше, чем реально на аккумуляторе есть в данный момент. Проверка показала, что целых полвольта теряется на проводах, поэтому я их заменил на более качественные, с большим сечением и припаял к клёвой вилке, очень подходящей к общему дизайну устройства. Это решило проблему, но не 100 процентов - при больших токах некоторая разница всё равно осталась. Но я посчитал, что это не бага, а фича, ведь нечего такими большими токами заряжать аккумулятор - пусть это работает как некоторый ограничивающий фактор!

Тут, между прочим, зарядка папиного аккумулятора идёт полным ходом, это видно по амперметру. Правда, лампочка на 220 вольт оказалась достаточно тусклой и на фотографиях почти не видно, что она горит. Но она горит, верьте мне!

Зарядное устройство готово!

Вот вам вид устройства снизу. Изначально я планировал заделать всю эту щель между корпусом и панелью, но потом передумал - лучше пусть вентилируется!

Вид с левого борта. Ну или с правого - это смотря, как смотреть, извините за каламбур.

Ну а это сверху. Тут видно, что я приклеил панель к выступающей части амперметра - получилась большая третья точка опоры, а то панель сидела как-то неуверенно. А так всё зашибись, надёжно и красиво! Вот, кстати, представьте, если бы вместо Кристалла я использовал обычный Момент, и через щель было бы видно всю это светло-жёлтую хрень. Фууууууу! 😳

Ну и, конечно же, вид сзади. На вентилятор я нацепил красивую решётку, защищающую пальцы и другие конечности людей и животных от травм. А ещё тут видно новый провод питания, который после зарядки удобно накручивается на кулер и никому не мешает!

Кстати, после сборки и тестирования устройства мне пришлось его опять разбирать, чтобы смазать этот долбанный кулер, почему только я его сразу не смазал, была же такая мысль???

Вот такой вот у меня получился первый проект на программируемом микроконтроллере. Потратил я на него почти месяц работы по вечерам. делал даже перерыв недельный, потому что надоедало, работа эта такая, нудноватая что-ли. Но я доволен. Доволен полученным опытом, доволен, что я смог довести это дело до конца, доволен, что у меня теперь есть отличное автоматическое зарядное устройство класса "включил и забыл". И я доволен тем, что когда мои друзья или знакомые будут спрашивать, нет ли у меня зарядного для их аккумулятора, я буду протягивать его им и с гордостью говорить, что эту крутую штуку сделал именно я!

P.S. О незначительной доработке устройства - встраивании в него защиты от перегрева, вы можете прочитать в следующей статье.

Понравился материал?

Похожие записи: