jan 13 2024
Ik heb een Pioneer XR-A550 hifi systeem dat ik gebruik als versterker voor muziek/geluid van mijn PC op mijn hobbytafel. Dit werkt op zich heel goed, maar op het einde van de dag zet ik de spanning van de tafel uit. Als ik dan de dag erna de spanning weer opzet dan is de versterker al zijn instellingen kwijt. Ik moet dan weer op aux drukken en het volume terug omhoog zetten. Na een paar jaar is het toch tijd om dit eens te automatiseren.
Hierbij heb ik ervoor gekozen om de IR codes van de afstandsbediening te reproduceren met een eigen schakeling. Voor de elektronica had ik nog een paar printen liggen van de Soldeer / SMD Inspectie Camera, die hebben een microcontroller met een mosfet op 1 van de uitgangen om zo een hogere stroom te schakelen voor de IR LED.
De behuizing is 3D geprint en is ontworpen om op de aluminium rail van mijn LED lamp te klikken.
Om de IR commando’s te achterhalen heb ik een IR receiver aan een logic analyzer gekoppeld. De signalen heb ik dan in een spreadsheet gedecodeerd, en vervolgens wat “quick and dirty code” gemaakt om deze te reproduceren.
Het signaal van de IR LED moet gemoduleerd worden op 38Khz. Om dit te doen gebruik ik de PWM module in de microcontroller. Deze staat ingesteld op PWM met een frequentie van 38Khz, vervolgens stuur ik duty-cycle 0 voor uit en 50% voor aan. Daarnaast heb ik LATAbits.LATA6 gebruikt voor debug.
Dit resulteert in volgende code:
void main(void)
{
uint8_t Buffer, Counter, VolumeCounter;
// initialize the device
SYSTEM_Initialize();
//**************************************************************************
//Startup delay
__delay_ms(2000);
__delay_ms(2000);
//**************************************************************************
//Send Aux
Irheader();
Buffer = 0b10011010;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
Buffer = 0b01100101;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
Buffer = 0b11001101;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
Buffer = 0b00110010;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
IrZero();
//**************************************************************************
//Delay after power on
__delay_ms(2000);
__delay_ms(2000);
//**************************************************************************
//Volume ++ 10x
for (VolumeCounter = 0; VolumeCounter < 10; VolumeCounter++){
Irheader();
Buffer = 0b10011010;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
Buffer = 0b01100101;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
Buffer = 0b10101111;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
Buffer = 0b01010000;
for (Counter = 0; Counter < 8; Counter++)
{
if (Buffer & 0x80){
IrOne();
}else{
IrZero();
}
Buffer = Buffer << 1;
}
IrZero();
__delay_ms(1000);
}
//**************************************************************************
//Infinite loop, don't do anything
while (1)
{
}
}
void Irheader(void){
LATAbits.LATA6 = 0;
PWM1_LoadDutyValue(127);
__delay_us(8550);
LATAbits.LATA6 = 1;
PWM1_LoadDutyValue(0);
__delay_us(4200);
}
void IrOne(void){
LATAbits.LATA6 = 0;
PWM1_LoadDutyValue(127);
__delay_us(550);
LATAbits.LATA6 = 1;
PWM1_LoadDutyValue(0);
__delay_us(550);
}
void IrZero(void){
LATAbits.LATA6 = 0;
PWM1_LoadDutyValue(127);
__delay_us(550);
LATAbits.LATA6 = 1;
PWM1_LoadDutyValue(0);
__delay_us(1560);
}
Een video van de schakeling in werking:
Please accept YouTube cookies to play this video. By accepting you will be accessing content from YouTube, a service provided by an external third party.
If you accept this notice, your choice will be saved and the page will refresh.
Gerelateerde producten:
mrt 17 2024
Voor een TCPS soldeerbout die ik een tijd terug bij een lot soldeerbouten bij ene veiling kocht wou ik een voeding maken. In mijn collectie transformatoren had ik nog een originele Weller transformator liggen. De behuizing van dit project is een kastje van een 230V naar 110V omzetter. Zo had ik er een tijd terug een aantal spotgoedkoop kunnen kopen bij een veiling. Het frontje is ge3Dprint. Onder de behuizing heb ik een 3D geprinte schuif gemonteerd om de soldeerbout en punten in op te bergen.
apr 01 2024
Vandaag ben ik naar de radiomarkt in Diest geweest.
Wat ik heb gekocht:
apr 03 2024
Ik heb ondertussen al meer dan genoeg labvoedingen gemaakt. Maar bij het opruimen van mijn opslagkast kwam ik printen tegen die ik ooit op Circuits Online gekocht heb bij een inkoopactie. Deze zijn voor een dubbele tracking voeding met max 0-34V 2,5A. Het zou zonde zijn om deze printen te hebben en toch niet op te bouwen.
(Bovenstaande fotos van op CircuitsOnline omdat ik zelf foto’s ben vergeten te maken)
Net zoals de vorige keer dat ik een bouwkit van een voeding van op CircuitsOnline bouwde wilde ik de specs weer “oprekken”. (Vorige keer Labvoeding 0-70V 0-3A Upgrade) Deze keer wil ik er 2x 0-48V 0-3A van maken. Dit zou wel betekenen dat de torren enorm veel vermogen moeten dissiperen. Dit heb ik opgelost door de trafo die ervoor komt om te wisselen door een geschakelde voeding. Deze geschakelde voeding is een 48V voeding, die ik heb omgebouwd om regelbaar te zijn van 20 to 60V. Dit kan ik aansturen met een 0-1.5mA stroompje. Op deze manier heb ik max 20V over de eindtorren staan, als de uitgang boven de 10V gaat probeer ik ongeveer 10V over de torren te laten staan. De schakeling die ik hiervoor gemaakt heb gebruikt 1 van de opamps van de hoofdprint en een andere opamp op een apart printje dat ik op een ongebruikte connector gemonteerd heb.
Buiten deze wijziging, moeten de printen ook aangepast worden om de hogere spanning aan te kunnen door een aantal componenten te vervangen door andere types. Een aantal weerstanden moeten aangepast worden om de juiste range in te kunnen stellen. En dan zijn er nog wat andere modificaties nodig om het weer stabiel te krijgen. Ik heb deze niet allemaal goed geregistreerd, dus ik ga deze hier niet oplijsten.
Nu de printen en voedingen werken was het tijd om aan de behuizing te beginnen. Ik kon niet direct iets vinden dat genoeg plaats bood voor alles en volledig naar mijn zin was. Daarom heb ik besloten zelf een behuizing uit te tekenen en te 3D printen. Op deze manier past alles exact en kon ik nog extra features toevoegen zoals bijvoorbeeld een scharnierend front om beter bij de printen te kunnen.
Op de bodem van de kast zitten 3 voedingen (2 gemodificeerde 48V voedingen, 1 12V voeding voor de ventilatoren te voeden) en 4 transformatoren voor het drive circuit van de labvoedingen.
Hierboven komen de koelblokken, deze komen uit oude PC’s. De transistoren worden er op geklemd met een metalen plaatje. De fans op de koelblokken kunnen met PWM aangestuurd worden. Daarom heb ik ook nog een simpel microcontroller bordje toegevoegd. Hierop lees ik 2 temperatuur sensoren in en stuur ik de 2 fans aan.
Van voor in de behuizing zitten de 2 labvoeding printen, en op het scharnierend frontpanel de display printen.
Het eind resultaat:
En tussen de andere apparatuur op de plank:
apr 18 2024
Ik had nogal veel getwiste draad nodig en kon deze nergens vinden in de juiste dikte / kleuren. Ik kan deze speciaal laten maken, maar dit is nogal duur. Een andere optie is met een boormachine stukken twisten, maar dit lukt maar goed tot 10 meter per keer. Om deze reden ben ik dan aan een machine begonnen om draad te twisten.
Ik had een motor met riem overbrenging uit een wasmachine. Deze was meteen mooi gelagerd en was daardoor een goed uitgangspunt om alles op te bouwen. Waar normaal de kuip vast zit heb ik een ronde plank geschroefd.
Hierop heb ik 2 houders voor klossen draad gemaakt. Die bestaan uit een stuk M12 draadstang met 2 tapse “moeren”. Eerst had ik dit op lagers gemonteerd zodat alles makkelijk zou kunnen bewegen, maar al snel bleek dat als de draad te makkelijk kan afrollen het twisten niet goed gaat. Daarom heb ik een paar blokken ge3Dprint met een 12mm gat om de draadstangen te monteren. Boven de rollen heb ik ook een kleine trechter gemaakt zodat de draad altijd op dezelfde plaats naar boven gaat.
De volgende stap is het oprollen van de draad. Daarvoor heb ik een spoelhouder gemaakt die door een motor met vertraging wordt aangedreven.
Om de draad te geleiden heb ik een arm gemaakt met een aantal pulleys op.
Om de 2 motoren aan te sturen heb ik 2 motor controllers in een kastje gebouwd. Voor de kleine motor is hier ook nog een 12V voeding aan toegevoegd.
Over hoe je een wasmachine motor kan aansturen met zo een controller heb ik hier wat uitleg geschreven: https://www.schematheek.net/artikel/artikel-wasmachinemotor-snelheid-regelen/
De machine in actie:
Please accept YouTube cookies to play this video. By accepting you will be accessing content from YouTube, a service provided by an external third party.
If you accept this notice, your choice will be saved and the page will refresh.
jun 16 2024
Vandaag ben ik naar de radiomarkt in Helchteren geweest.
Wat ik heb gekocht:
jul 07 2024
Na 5 jaar nog eens naar de radiomarkt in Bladel geweest, deze is tegenwoordig buiten, gelukkig was het goed weer. En het voelde nog eens als een radiomarkt zoals ze een aantal jaar geleden waren, veel spullen tegen redelijke/lage prijzen.
Wat ik heb gekocht:
sep 14 2024
Ik heb dit project van een paar jaar geleden weer opgepakt. Eerst heb ik 5V op de elco print gezet, maar onmiddellijk ging er veel te veel stroom lopen (die ook bleef lopen). Dit kwam doordat er 1 elco intern kortgesloten was. Met veel moeite heb ik kunnen vinden welke het was en deze vervangen. Hierna de print weer getest, maar er liep tijdens het puntlassen veel te weinig stroom. Zo weinig dat er niet eens een stevige vonk kwam bij het kortsluiten.
Na wat verder experimenteren zat er opeens weer een kortsluiting in de print. Na het vinden van de schuldige elco, weer verder gegaan. En opnieuw een elco kapot. Nu waren mijn reserve elco’s ook op en moest ik nieuwe bestellen. Maar voordat ik dat deed maar even narekenen of er dan wel genoeg energie in de elco’s zit. Dit bleek niet het geval te zijn. Tenzij ik elco’s met veel hogere capaciteit zou kopen, maar die zijn duur.
Toen dacht ik eraan dat ik nog een paar transformatoren uit microgolfovens had liggen. Als ik hier op de hoogspanningswikkelingen verwijder en deze vervang door een aantal wikkelingen met dikke draad (16mm² in dit geval) dan levert deze veel stroom bij een lage spanning.
De primaire kant van deze transformator kan ik schakelen met een solid state relays. Om de timing te doen en alles aan te sturen heb ik een PIC16F1788 microcontroller gebruikt. Hier heb ik een ULN2803 bordje bijgezet om de solid state relays aan te sturen. Voor de bediening heb ik nog een LCD en rotary encoder toegevoegd.
Nu kwam er wel een ander probleem naar boven. Bij het oude schema was het makkelijk te detecteren of de las elektroden kortgesloten werden door het te lassen object. Met de nieuwe setup is het wat lastiger omdat de 16mm² draad die met beide pennen in verbinding staat al zorgt voor een enorm lage weerstand. Dit heb ik opgelost door op de uitgang een 50Khz blokgolf te zetten en te meten hoe ver deze inzakt als de uitgang kortgesloten wordt. De draad door de transformator werkt op deze manier als spoel en is een hogere weerstand voor de 50Khz.
Om het signaal op de draad te zetten, had ik meer power nodig dan dat de pin van de microcontroller kan leveren. Daarom heb ik een RS485 IC (mis)gebruikt als versterker. Achter de RS485 IC heb ik een 1µF condensator gebruikt om het signaal in te koppelen.
Hier heb ik eerst een simulatie op gedaan met volgend resultaat: (Links op de plot is output open, rechts is gesloten.)
Het “out” signaal is verbonden met de AD converter van een microcontroller. Wanneer het signaal onder een bepaald niveau komt dan gaat het las programma starten. Het programma heb ik zo gemaakt dat het 2 pulsen na elkaar kan geven, dit zou een betere las moeten opleveren. De puls en pauze tijd is allemaal apart aanpasbaar.
Het hoofd deel van het programma:
while (1)
{
MenuDelay ++; //For debounce
if (MenuDelay > 4){
MenuDelay = 0;
if (WeldState){
LCD_Print_At(1, 1, "Stat:Weld|T1PaT2");
}else{
LCD_Print_At(1, 1, "Stat:Open|T1PaT2");
}
sprintf(GetString,"%4u", WeldTime1 * 20);
LCD_Print_At(2, 1, GetString);
sprintf(GetString,"%4u", WeldPause * 20);
LCD_Print_At(2, 6, GetString);
sprintf(GetString,"%4u", WeldTime2 * 20);
LCD_Print_At(2, 11, GetString);
LCD_Print_At(2, 5, "|");
LCD_Print_At(2, 10, "|");
LCD_Print_At(2, 15, "mS");
LCD_Cmd(0xFE);
LCD_Cmd(0x0E);
LCD_Cmd(0x0F);
switch (MenuItem){
case 0:
LCD_Goto(4, 2);
WeldTime1 = RotCountValue;
if (!RotaryBtn){
DATAEE_WriteByte(1, WeldTime1);
MenuItem ++;
}
break;
case 1:
if (RotaryBtn){
MenuItem ++;
RotCountValue = WeldPause;
RotMinValue = 1;
RotMaxValue = 100;
LCD_Cmd(LCD_CLEAR);
}
break;
case 2:
LCD_Goto(9, 2);
WeldPause = RotCountValue;
if (!RotaryBtn){
DATAEE_WriteByte(2, WeldPause);
MenuItem ++;
}
break;
case 3:
if (RotaryBtn){
MenuItem ++;
RotCountValue = WeldTime2;
RotMinValue = 1;
RotMaxValue = 100;
LCD_Cmd(LCD_CLEAR);
}
break;
case 4:
LCD_Goto(14, 2);
WeldTime2 = RotCountValue;
if (!RotaryBtn){
DATAEE_WriteByte(3, WeldTime2);
MenuItem ++;
}
break;
default:
if (RotaryBtn){
MenuItem = 0;
RotCountValue = WeldTime1;
RotMinValue = 1;
RotMaxValue = 100;
}
break;
}
}
SensVoltageBuffer = 0;
for (uint8_t Counter = 0; Counter < 6; Counter++){
SensVoltage = ADC_GetConversion(0); SensVoltage = SensVoltage >> 6;
SensVoltageBuffer = SensVoltageBuffer + SensVoltage;
__delay_ms(20/6);
}
SensVoltage = SensVoltageBuffer / 6;
WeldDetect = 200;
switch (WeldState){
case 0:
if (SensVoltage < WeldDetect){
WeldState ++;
}
break;
case 1:
WeldState ++;
WeldTimer = 0;
break;
case 2:
if (SensVoltage < WeldDetect){
WeldState ++;
}else{
WeldTimer ++;
if (WeldTimer == 250){
WeldState = 0;
}
}
break;
case 3:
LATBbits.LATB4 = 1; //Buzzer
WeldState ++;
break;
case 4:
LATBbits.LATB4 = 0;
WeldState ++;
break;
case 5:
WeldTimer = 0;
WeldState ++;
break;
case 6:
LATAbits.LATA3 = 1;
LATBbits.LATB5 = 1;
if (WeldTimer >= WeldTime1){
LATAbits.LATA3 = 0;
LATBbits.LATB5 =0;
WeldTimer = 0;
WeldState ++;
}else{
WeldTimer ++;
}
break;
case 7:
if (WeldPulses == 1){
WeldState = 10;
}
if (WeldTimer >= WeldPause){
WeldTimer = 0;
WeldState ++;
}else{
WeldTimer ++;
}
break;
case 8:
LATAbits.LATA3 = 1;
LATBbits.LATB5 = 1;
if (WeldTimer >= WeldTime2){
LATAbits.LATA3 = 0;
LATBbits.LATB5 = 0;
WeldTimer = 0;
WeldState ++;
}else{
WeldTimer ++;
}
break;
case 9:
WeldState ++;
break;
case 10:
WeldTimer ++;
if (WeldTimer >= (1000/20)){
WeldTimer = 0;
WeldState ++;
}
break;
case 11:
if (SensVoltage > WeldDetect){
LATAbits.LATA3 = 0;
WeldTimer = 0;
WeldState = 0;
}
break;
default:
WeldState = 0;
break;
}
}
apr 13 2025
Vandaag ben ik naar de radiomarkt in Diest geweest.
Wat ik heb gekocht:
apr 19 2025
Tijdens de renovatie van mijn huis heb ik al veel tijd verspeeld met het afmeten van water voor bijvoorbeeld beton, gips, … te mixen. Om dit wat makkelijker / sneller te maken heb ik een automatische water dispenser gebouwd. Hiermee kan ik een precieze hoeveelheid water dispenseren. Het apparaat is in te stellen tussen de 0.1L en 25L in 0.1L stapjes. De laatst ingestelde waarde blijft behouden als het apparaat uitgezet wordt.
Een paar foto’s van het afgewerkte project:
Please accept YouTube cookies to play this video. By accepting you will be accessing content from YouTube, a service provided by an external third party.
If you accept this notice, your choice will be saved and the page will refresh.
De elektronica draait op een oplaadbare lithium batterij. Deze wordt opgeladen door een kleine water generator die tijdens het dispensen draait. Normaal is dit meer dan genoeg om de batterij vol te houden, moest dit toch niet het geval zijn is er ook nog een kapje dat eruit gedraaid kan worden om bij een USB-C laadconnector te komen.
De solenoid klep die ik gebruikt heb wordt met pulsen geschakeld. Een puls met de stroom in 1 richting opent de klep, en een puls met de stroom in de andere richting sluit deze weer terug. Dit zorgt ervoor dat er veel minder stroom verbruikt wordt dan bij klassieke kleppen. Om deze aan te sturen in 2 richtingen heb ik een MX1508 motor driver printje gebruikt.
Tijdens het schakelen loopt er een vrij grote stroompiek, deze kan de microcontroller laten crashen. Om dit te voorkomen heb ik nog een buffer toegevoegd in de vorm van 3x 3300µF 6.3V condensatoren die via een 100Ω weerstand geladen worden uit de 5V.
Het afmeten van het water gebeurd met een flow sensor, deze genereert 660 pulsen voor elke liter water die erdoor gaat. Deze pulsen worden in de microcontroller ingelezen onder interrupt. Telkens als er een puls binnenkomt verminderd deze de resterend volume waarde, en als die 0 wordt dan wordt de klep terug gesloten.
Een schets van het aansluitschema:
De firmware staat op Codeberg: https://codeberg.org/Stynus/Water-Dispenser
English 