Published July 8, 2020 © GPL3+

Tiny Isolated Dimmer with Linearly Corrected Output

Unlike many simple dimmers, this dimmer dims a resistive load based on the delievered power, not just a simple fraction of delay.

IntermediateFull instructions provided4 hours762

Tiny Isolated Dimmer with Linearly Corrected Output

Things used in this project

Hardware components

microchip - ATtiny13

Triac thyristor

Software apps and online services

Microchip Studio

Proteus suite

Hand tools and fabrication machines

Soldering iron (generic)

Story

I had a damaged heater laying around, so I decided to make a simple isolated dimmer to control the heat.

We've seen many simple MCU-based dimmers work as follow:

a zero-cross detection circuit, makes an interrupt on MCU pin
MCU pulses a triac with a delay which corresponds to desired power delievery

so if we are using a 230V 50Hz line, a zero delay makes triac on as soon as crossing the half-cycle. a 10ms delay makes the triac off all the time. (1s/50Hz = 20ms, 10ms each half-cycle).

any delay between 0ms and 10ms reduces the power delievered and in case of a light bulb, dims the light.

here comes the drawback:

the power delievered to the resistive load, is nonlinear with the simple delaying. so a 3ms delay, doesn't mean we have 7/10 of power delieverd to the load. that's why other dimmers change the light a lot when the light is low, but changes at higher light levels are not observable. a non-linear nature I didn't want on my dimmer.

nonlinear power delievery. the blue hashes indicate delievered power

that's because the power is sinosuidal, not linear!

workaround:

the deliever linear power to load, we have to make our delay timings the way so the partial intergral of the sinewave remains same between dimming steps.

let's say we need 10 steps of dimming, so we need 10 timings so the partial integrals remain unchanged in value. the total intgral of sine from zero to pi is :

integral of a sine wave

we need 10 portions of it. so :

when n is 0, the intgral is 2, when n is 1, the integral becomes zero. the cos(npi) is from -1 to +1

according to the description of the above formula, we have to divide the range of -1 to +1 into some sections, and calculate the n for each section :

sections should be values from -1 to +1. if you need 10 timings, divide this range in 0.2 sectors. see next image

here is some values I calculated for 10 timings :

the delays are the coefficients we should multiply by 10ms half-cycle to achieve desired power.

in the table above, delays should be multiplied by 10ms of a half-cycle lenght. e.g. if we want to deliever 0.3 of power to the load, we have to delay 0.63*10ms = 630 microseconds. without this equations we would delay 0.7 which was not accurate.

OK, now the circuit :

it's as simple as it seems. two LEDs change intensity when going from 0 to 10 dimming levels.

1 / 3 • just a powerful blue light means about 4/10 of power

Code

Main.c

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

void init_priphs(void);
void readADC();
void sup_delay(uint16_t del);
uint8_t adc_val;

//LED brightness to compare with counter values
const uint8_t LED1_B[4] = {20,80,150,255};
//the 8 level of dimmer values
const uint16_t Dimmers[8] = {0,253,369,468,531,631,760,900};

int main()
{
	//check the function below
	init_priphs();
	//enable interrupts
	sei();

	while(1)
	{
		//read the pot value
		readADC();

		//==============================
		//change light according to pot value
		if (adc_val < 128)
		{
			if (TCNT0 < (LED1_B[adc_val / 40]))
			{
				PORTB &= ~(1 << PORTB3);
			}
			else	PORTB |= (1 << PORTB3);
			PORTB |= (1 << PORTB4);
		}
		else
		{
			if (TCNT0 < (LED1_B[adc_val / 80]))
			{
				PORTB &= ~(1 << PORTB4);
			}
			else	PORTB |= (1 << PORTB4);
		}
		//==============================
	}
}


void init_priphs(void)
{
	//SETUP GPIO
	DDRB	|= (1 << DDB3) | (1 << DDB4);//LED outputs
	DDRB	|= (1 << DDB0);//triac fire outputs
	PORTB	|= (1 << PB1);//pullup for ZCD,interrupt
	MCUCR	= 3;//RisingEdge interrupted
	GIMSK	= (1 << INT0);
	
	//SETUP ADC
	DDRB	&= ~(1 << DDB2);//ADC1 channel
	ADMUX	= (1 << ADLAR) | 1;//left adjust, set AIN3
	ADCSRA	= (1 << ADSC) | (1 << ADEN) | 5;//start in free running with 32 prescaler
	ADCSRA	|= (1 << ADSC);
	DIDR0	= (1 << ADC1D);//disable the schmitt trigger
	
	
	//SETUP TIMER TIME_BASE
	TCCR0B	= 1; //prescale of 1
}



ISR(INT0_vect)
{
	//wait according to the Dimming table
	sup_delay(Dimmers[adc_val / 34]);
	//fire triac
	PORTB |= (1 << PORTB0);
	_delay_us(30);
	PORTB &=~(1 << PORTB0);
}

//simple function to read the ADC, some oversampling done to smooth it out
void readADC()
{
	uint16_t ad_temp=0;
	for (uint8_t i = 0; i <20; i++)
	{
		ADCSRA |= (1 << ADSC);
		while(!(ADCSRA & (1<<ADIF)));
		ad_temp += ADCH;
	}
	adc_val = (uint8_t)(ad_temp / 20);
}
//delay function. you can't use inbuilt macro as it needs a constant value
//but we have to feed it a variable
void sup_delay(uint16_t del)
{
	while (del--)
	{
		_delay_us(10);
	}
}

Credits

Tirdad Sadri Nejad

6 projects • 19 followers

AI masters degree student. a guitar player and an electronic hobbyist.

Amir Kazemi

4 projects • 3 followers

Material science engineering MSc nano material researcher

Tiny Isolated Dimmer with Linearly Corrected Output