13 เพลงหนทางมนุษย์
เผยแพร่แล้ว
• 11 ต.ค. 2021#define FN (50.0) //czestotliwosc znamionowa silnika
#define P (UN/FN) //wsp. okreslajacy proporcje napiecia do czestotliwoci znamionowej
#define T_PWM (0.000255) //okres sygnalu PWM - ustawiony przez preskaler w licznikach
#define T_MAX (4.0) //okreslenie maksymalnego okresu napiecia wyjsciowego
#define T_MIN (0.02) //minimalny okres napiecia wyjsciowego
#define K_MAX floor(T_MAX/T_PWM) //liczba wartosci okresu dla T_MAX
#define K_MIN ceil(T_MIN/T_PWM) //liczba wartosci okresu dla T_MIN
volatile static unsigned int dlugosc_tab_sin; //zmienna zawierajaca liczbe wartosci w pelnym
//okresie napiecia wyjsciowego
static unsigned int i = 0; //zmienna pomocniacza
volatile static unsigned int licznik_glowny = 0;//zmienna wystepujaca w przerwaniu czyklicznie
//^ co okres T_PWM zwiekszajaca swoja wartosc o 1
static unsigned int next_value_sin = 0; //zmienna ktora wartosc sin nalezy obliczyc
static double t_param=100; //parametr okreslajacy okres napiecia wyjsciowego
static float t = T_PWM; //T_PWM
static float omega_t; //pulsacja napiecia wyjsciowego pomnozona przez T_PWM
static float t_out; //okres wyjsciowy napiecia
static float U_o_param; //parametr okreslajacy wielkosc napiecie wyjsciowego
//^ obliczony na podstawie t_out i U_in
static unsigned int ocr0a, ocr0b, ocr1a;//zmienne pomocnicze do przechowywania obl. wypelnien
static unsigned int ocr1b, ocr2a, ocr2b;//^
static double sin_in; //zmienna zawierajaca parametr funkcji sin
static double blad = 1; //zmienna uzyta do zatrzymania generowania napiecia przy przeciazeniu
static unsigned int analog=0; //zmienna zawierajaca zmierzona wartosc
static double U_in = 0; //zmienna przechowujนca pomiar napiecia ukladu posredniczacego
static double U_rms_max; //maksymalna aktualnie mozliwa do generacji wartosc skuteczna napiecia
static bool a=0; //zmienna logiczna do realizacji dwoch naprzemiennych pomiarow
int main()
{
io_init(); //inicjalizacja wejsc i wyjsc
timers_init(); //inicjalizacja licznikow PWM
adc_init(); //inicjalizacja przetwornika ADC
while(1) //nieskonczona petla z programem glownym
{
if(i==185) //warunek okreslajacy wejscie do funkcji zmiany
{ //parametrow napiecia wysjciowego, wywolanie co okolo 100ms
zmien_predkosc(); //funkcja zmiany parametrow napiecia wyjsciowego
i=0;
}
next_value_sin = licznik_glowny%dlugosc_tab_sin; //kolejna wartoœๆ sinusa do obliczenia
sin_in=omega_t*next_value_sin;
/*obliczenie wartosci do rejestrow okreslajacych wypelnienie sygnalu wyjscioweg*/
ocr0a = round(blad*(U_o_param*(sin(sin_in)+1)*254/2)+1);//pin 6
ocr0b = ocr0a - 1;
ocr1a = round(blad*(U_o_param*(sin(sin_in-2.09)+1)*254/2)+1);//pin 9
ocr1b = ocr1a - 1;
ocr2a = round(blad*(U_o_param*(sin(sin_in+2.09)+1)*254/2)+1);//pin 11
ocr2b = ocr2a - 1;
/*uaktualnienie wartosci w rejestrach*/
cli(); //zabronienie na obsloge przerwan na wypadek gdyby
//podczas uaktualniania wystapilo przerwanie
OCR0A = ocr0a; //pin 6
OCR0B = ocr0b; //pin 5
OCR1AL = ocr1a; //pin 9
OCR1BL = ocr1b; //pin 10
OCR2A = ocr2a; //pin 11
OCR2B = ocr2b; //pin 3
sei(); //zezwolenie na obsloge przerwan
i++;
}
}
void adc_init()
{
ADCSRA |= _BV(ADEN);//uruchomienie przetwornika
ADCSRA |= _BV(ADPS2);//ustawienie preskalera
ADCSRA |= _BV(ADPS1);//^
ADCSRA |= _BV(ADPS0);//^
ADMUX |= _BV(REFS0);// napiecie odniesienia ustawione jako napiecie zasilania
ADMUX |= ADMUX &= 0b11110000; //wybranie wejscia ADC0 do pomiaru
}
void timers_init()
{
cli(); // obsloga przerwan zabroniona
//timer0 init
TCCR0A |= _BV(COM0A1) | _BV(COM0B0) | _BV(COM0B1) | _BV(WGM00);
TCCR0B |= _BV(CS01); //preskaler 8
TIMSK0 |= _BV(TOIE0); //flaga od wartosci 0 wlaczona
//timer1 init
TCCR1A |= _BV(COM1A1) | _BV(COM1B0) | _BV(COM1B1) | _BV(WGM10);
TCCR1B |= _BV(CS11); //preskaler 8
//timer2 init
TCCR2A |= _BV(COM2A1) | _BV(COM2B0) | _BV(COM2B1) | _BV(WGM20);
TCCR2B |= _BV(CS21); //preskaler 8
//zerowanie wartosci licznik๓w
TCNT0 = 0;
TCNT1L = 0;
TCNT2 = 0;
/* licznik zlicza w g๓re do 255, nastepnie w d๓ณ: /\/\/\
przy wartosci 255 jest przerwanie przy ktorym dokonuje sie
pomiarow napiec i pradow
*/
sei(); //zezwolenie na obsloge przerwan
}
void io_init()
{
pinMode(6, OUTPUT); //OC0A
pinMode(5, OUTPUT); //OC0B
pinMode(9, OUTPUT); //OC1A
pinMode(10, OUTPUT);//OC1B
pinMode(11, OUTPUT);//OC2A
pinMode(3, OUTPUT); //OC2B
pinMode(2, INPUT);
pinMode(4, INPUT);
pinMode(12, OUTPUT);
}
ISR(TIMER0_OVF_vect) //przerwanie przy wartosci 0 licznika0
{
analog = ADC;
if(a)
{
U_in = 0.0709*analog;
ADMUX |= _BV(MUX0); //wybranie wejscia ADC1 do pomiaru pradu
}
else
{
ADMUX |= ADMUX &= 0b11110000; //wybranie wejscia ADC0 do pomiaru napiecia
if(analog>579)
{
blad = 0; //jezeli przeciazenie wylaczenie generacji napiecia
digitalWrite(12, HIGH); //zapalenie diody
}
}
ADCSRA |= _BV(ADSC);//start odczytywania pomiaru
a=a^1; //bramka XOR neguje wartosc logiczna a
licznik_glowny++;
if(licznik_glowny>=dlugosc_tab_sin) licznik_glowny = 0;
}
void zmien_predkosc()
{
U_rms_max = U_in*0.62; //wartosc 0.62 wyzanczona eksperymentalnie
bool up; //zmienna logiczna, informuje o nacisnietym przycisku zwieksz czestotliwosc
bool down; //zmienna logiczna, informuje o nacisnietym przycisku zmiejsz czestotliwosc
up = digitalRead(4); //odczyt: czy nacisniety przycisk zwieksz czestotliwosc
down = digitalRead(2); //odczyt: czy nacisniety przycisk zmiejsz czestotliwosc
if(up==1) t_param--; //jezeli nacisniety przycisk zwieksz czestotliwosc to zmiejsz okres
if(down==1) t_param++; //jezeli nacisniety przycisk zmniejsz czestotliwosc to zwieksz okres
if(t_param<0) t_param=0; //zabezpieczenie przekroczenia wartosci skrajnych
if(t_param>100) t_param=100;//^
dlugosc_tab_sin = ceil((K_MAX-K_MIN)*t_param/500+K_MIN);//ilosc wartosci wypelnien w jednym okresie
t_out = T_PWM*dlugosc_tab_sin; //obliczenie okresu napiecia wyjsciowego
omega_t = t*2*PI/t_out; //obliczenie pulsacji napiecia wyjsciowego
U_o_param = (P/t_out)/U_rms_max; //obliczenie parametru okreslajacego wielkosc napiecia wyjsciowego
if(t_out>1) U_o_param = 0.5*(18.5/U_rms_max); //napi๊cie na wyjsciu przy niskiej czestotliwosci 10V
if(U_o_param>1) U_o_param=1; //zabezpieczenie przekroczenia wartosci skrajnych
}
typedef unsigned char PROGMEM prog_uchar;
// table of 256 sine values / one sine period / stored in flash memory
PROGMEM prog_uchar const sine256_u[] = {
87, 90, 93, 96, 99,102,105,108,111,115,118,121,124,127,130,133,136,139,143,146,149,152,155,158,161,164,167,170,173,176,178,181,184,187,190,
192,195,198,200,203,205,208,210,212,215,217,219,221,223,225,227,229,231,233,234,236,238,239,240,242,243,244,245,247,248,249,249,250,251,252,
252,253,253,253,254,254,254,254,254,254,254,253,253,253,252,252,251,250,249,249,248,247,245,244,243,242,240,239,
238,236,234,233,231,229,227,225,223,221,219,217,215,212,210,208,205,203,200,198,195,192,190,187,184,181,178,176,173,170,167,164,161,158,155,
152,149,146,143,139,136,133,130,127,124,121,118,115,111,108,105,102, 99, 96, 93, 90, 87, 84, 81, 78, 76, 73, 70, 67, 64, 62, 59, 56, 54, 51,
49, 46, 44, 42, 39, 37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5, 5, 4,
3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 23,
25, 27, 29, 31, 33, 35, 37, 39, 42, 44, 46, 49, 51, 54, 56, 59, 62, 64, 67, 70, 73, 76, 78, 81, 84
};
PROGMEM prog_uchar const sine256_v[] = {
250,249,249,248,247,245,244,243,242,240,239,238,236,234,233,231,229,227,225,223,221,219,217,215,212,210,208,205,203,200,198,195,192,190,187,
184,181,178,176,173,170,167,164,161,158,155,152,149,146,143,139,136,133,130,127,124,121,118,115,111,108,105,102, 99, 96, 93, 90, 87, 84, 81,
78, 76, 73, 70, 67, 64, 62, 59, 56, 54, 51, 49, 46, 44, 42, 39, 37, 35, 33, 31, 29, 27, 25, 23, 21, 20,
18, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5,
6, 7, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 42, 44, 46, 49, 51, 54, 56, 59, 62, 64, 67, 70, 73, 76,
78, 81, 84, 87, 90, 93, 96, 99,102,105,108,111,115,118,121,124,127,130,133,136,139,143,146,149,152,155,
158,161,164,167,170,173,176,178,181,184,187,190,192,195,198,200,203,205,208,210,212,215,217,219,221,223,225,227,229,231,233,234,236,238,239,
240,242,243,244,245,247,248,249,249,250,251,252,252,253,253,253,254,254,254,254,254,254,254,253,253,253,252,252,251
};
PROGMEM prog_uchar const sine256_w[] = {
49, 46, 44, 42, 39, 37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35, 37,
39, 42, 44, 46, 49, 51, 54, 56, 59, 62, 64, 67, 70, 73, 76, 78, 81, 84, 87, 90, 93, 96, 99,102,105,108,
111,115,118,121,124,127,130,133,136,139,143,146,149,152,155,158,161,164,167,170,173,176,178,181,184,187,190,192,195,198,200,203,205,208,210,
212,215,217,219,221,223,225,227,229,231,233,234,236,238,239,240,242,243,244,245,247,248,249,249,250,251,252,252,253,253,253,254,254,254,254,
254,254,254,253,253,253,252,252,251,250,249,249,248,247,245,244,243,242,240,239,238,236,234,233,231,229,
227,225,223,221,219,217,215,212,210,208,205,203,200,198,195,192,190,187,184,181,178,176,173,170,167,164,161,158,155,152,149,146,143,139,136,
133,130,127,124,121,118,115,111,108,105,102, 99, 96, 93, 90, 87, 84, 81, 78, 76, 73, 70, 67, 64, 62, 59, 56, 54, 51
};
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
double dfreq;
//const double refclk=31372.549; // =16MHz / 510
const double refclk=31130.0 ; // measured
// variables used inside interrupt service declared as voilatile
volatile byte icnt; // var inside interrupt
volatile byte icnt1; // var inside interrupt
volatile byte c4ms; // counter incremented all 4ms
volatile unsigned long phaccu; // phase accumulator
volatile unsigned long tword_m; // dds tuning word m
void setup()
{
Serial.begin(115200); // connect to the serial port
Serial.println("DDS Test");
Setup_timer3();
// disable interrupts to avoid timing distortion
cbi (TIMSK0,TOIE0); // disable Timer0 !!! delay() is now not available
sbi (TIMSK3,TOIE3); // enable Timer3 Interrupt
dfreq=100.0; // initial output frequency = 100.0 Hz
tword_m=pow(2,32)*dfreq/refclk; // calulate DDS new tuning word
}
void loop()
{
while(1) {
if (c4ms > 250) { // timer / wait fou a full second
c4ms=0;
dfreq=map(analogRead(0),0,1023,0,12); // read Poti on analog pin 0 to adjust output frequency from 0..1023 Hz
//dfreq=analogRead(0);
cbi (TIMSK3,TOIE3); // disble Timer2 Interrupt
tword_m=pow(2,32)*dfreq/refclk; // calulate DDS new tuning word
sbi (TIMSK3,TOIE3); // enable Timer2 Interrupt
Serial.print(dfreq);
Serial.print(" ");
Serial.println(tword_m);
}
}
}
//******************************************************************
// timer3 setup
// set prscaler to 1, PWM mode to phase correct PWM, 16000000/510 = 31372.55 Hz clock
void Setup_timer3() {
// Timer3 activate PWM Pin 5,2,3
DDRE |= _BV(PORTE3); TCCR3A |= _BV(COM3A1);
DDRE |= _BV(PORTE4); TCCR3A |= _BV(COM3B1);
DDRE |= _BV(PORTE5); TCCR3A |= _BV(COM3C1);
// Timer3 Clock Prescaler to : 1
sbi (TCCR3B, CS30);
cbi (TCCR3B, CS31);
cbi (TCCR3B, CS32);
// Timer3 PWM Mode set to Phase Correct PWM
cbi (TCCR3A, COM3A0); // clear Compare Match
sbi (TCCR3A, COM3A1);
sbi (TCCR3A, WGM30); // Mode 1 / Phase Correct PWM
cbi (TCCR3A, WGM31);
cbi (TCCR3B, WGM32);
}
//******************************************************************
// Timer3 Interrupt Service at 31372,550 KHz = 32uSec
// this is the timebase REFCLOCK for the DDS generator
// FOUT = (M (REFCLK)) / (2 exp 32)
// runtime : 8 uSec ( inclusive push and pop)
ISR(TIMER3_OVF_vect) {
phaccu=phaccu+tword_m; // soft DDS, phase accu with 32 bits
icnt=phaccu >> 24; // use upper 8 bits for phase accu as frequency information
// read value fron ROM sine table and send to PWM DAC
OCR3A=pgm_read_byte_near(sine256_u + icnt);
OCR3B=pgm_read_byte_near(sine256_v + icnt);
OCR3C=pgm_read_byte_near(sine256_w + icnt);
if(icnt1++ == 125) { // increment variable c4ms all 4 milliseconds
c4ms++;
icnt1=0;
}
}
/*
Arduino - ATmega328 - PWM signal
Arduino is open-source electronics platform with flexibility and developing
the easy-to-use software and hardware.
The ATmega328 can be buy within an arduino development kit.
To work with this kit, a development software is available in the internet
pages of arduino.
It enables to write code in programming language C and you can use some
internal functions of arduino,
which makes work even more easy.
But there is no possibility how to generate invertion PWM signal for 6
channels.
In other words, if you need to work with your generated signal in one outup
and with
its inverse signal in another one output (shown in image),there is no
predefined function for this.
You have to look into datasheet, how to make it work, to write into
register the appropriate values.
I worked on this issue in previous days and I attach my code here. The code
was designed to work fast,
therefore there are sinetables with values for 0ยฐto 180ยฐ for every phase.
It is possible to calculate
a lot of values using one table with values for 0ยฐto 60ย, but there have
to be algorithms to calculate
appropriate values and that is time consuming and in the other hand, the
processor has 32kBytes memory,
so it is no problem to declare tables for 180ยฐ. I generated these tables
using Matlab.
This code generated in the result sine wave for three phases with frequency
50Hz.
*/
// 22.11.2009 - EPP, Group1, Michala Srnova
// Generating of PWM signals for three phase inverter circuit
// generating of sine signals with freq of 50Hz
// the amplitude of these signals will be calculated to desired value
(using input signal)
// input signal: voltage on analog input
// output values: PWM signals on all 6 PWM outputs:
// 1. signal to 1.phase (+ switch)
// 2. signal to 1.phase (- switch) opposite to signal for 1.phase
// 3.,4. signals to 2.phase
// 5.,6. signals to 3.phase
#include "WProgram.h"
void setup();
void loop();
int i; //for cycle
int analogPin = 0; //No. of input pin
int Input=1023; //this value is from ADC: it can be in range:0 - 1023
(0-5V)
float K; // Constant : is equal Input/1023
float ph0; // For calculating value of phase 1
float ph1; // phase 2
float ph2; // phase 3
//setting of sin table for half-period, 78 samples
//this realization is uneffective due to used memory - because it is
possible to keep only values of first 60 degrees and
//+only for first phase. Others can be calculated.
//But this microchip hase a lot of memory and his only one role is to
generate PWM. We need to have values up time, and calculations
//which would be necessary (for calculating samples for phase 2 and 3, and
for angles of whole sine wave) are time-consuming
int
sinus0[]={0,10,20,31,41,51,61,71,81,91,101,110,119,128,137,146,154,163,
170,178,185,192,199,205,211,217,222,227,231,236,239,243,246,248,250,252,
253,254,254,254,254,253,252,250,248,246,243,239,236,231,227,222,217,211,
205,199,192,185,178,170,163,154,146,137,128,119,110,101,91,81,71,61,
51,41,31,20,10,0};
int
sinus1[]={220,225,230,234,238,242,245,247,250,251,253,254,254,254,254,254,252,251,
249,246,244,240,237,233,228,224,219,213,207,201,194,188,180,173,165,157,
149,140,131,122,113,104,94,85,75,65,55,44,34,24,13,3,6,17,
27,38,48,58,68,78,88,98,107,116,126,134,143,152,160,168,175,183,
190,197,203,209,215,220};
int
sinus2[]={220,215,209,203,197,190,183,175,168,160,151,143,134,125,116,107,97,88,
78,68,58,48,37,27,17,6,3,14,24,34,45,55,65,75,85,94,
104,113,123,132,140,149,157,165,173,181,188,195,201,207,213,219,224,229,
233,237,241,244,247,249,251,252,254,254,255,254,254,253,251,250,247,245,
242,238,234,230,225,220};
void setup()
{
//for default settings
//=====setting of timer for fast PWM method====
//frequency PWM is fosc/(8*256) (by 16MHz oscil. = 7812,5)
//timer 0, 8-bit timer, pins 5,6(+) 128us
TCCR0A=0b10110011; // generate inverted PWM signals in output
TCCR0B=0b00000010; // set of source of clock signal + prescaller
//timer 2, 8-bit timer, pins 9,10(+) = same settings as timer0 -
128us
TCCR2A=0b10110011; // generate inverted PWM signals in output
TCCR2B=0b00000010;
//timer 1, 16-bit timer, pins 3, 11(+)
TCCR1A=0b11100001; // set for generate negative values first
TCCR1B=0b00001010;
//setting of PWM ports to output
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(3,OUTPUT);
}
void loop()
{
//whole our code processed in infinity cycle
delay(64);
//change of polarity of phase 1
TCCR0A = TCCR0A ^ 0b01010000;
//cycle for half period
for(i=0; i<78;i++)
{
//reading the value of input voltage
Input=analogRead(analogPin); //Input=1023;
K = Input / 1023.00; //now Input value is in range: 0-1
//generating of value OCR0x,OCR1x,OCR2x , where for same counter are
values the same
ph0=sinus0[i]*K; //this value should be float
//setting of OCR0x
OCR0A=byte(ph0);
OCR0B=byte(ph0);
//for 2. phase:
if(i==52){
//passed 52 samples, it means, that values of phase two will be
negative => the setting of generating signals must be changed
//TCCR2A=0b1011 0011; => 0b1110 0011 => for XOR =mask: 0101
0000
TCCR1A = TCCR1A ^ 0b01010000;
}
ph1=sinus1[i]*K;
OCR1A=byte(ph1);
OCR1B=byte(ph1);
//for 3.phase
if(i==26){
//26 samples - change positive to negative and vice versa
TCCR2A = TCCR2A ^ 0b01010000;
}
ph2=sinus2[i]*K;
OCR2A=byte(ph2);
OCR2B=byte(ph2);
//wait for end of now processing cycle - than generate new samples for
next cycle
// flag TOV1=1 when PWM period ends
while(TOV1 != 1){
//check it every 16 micro seconds - with changes in timer, it is 64
times bigger value
delayMicroseconds(1024);
delay(64);
}
}
}
int main(void)
{
init();
setup();
for (;;)
loop();
return 0;
}
#include <avr/pgmspace.h>
#include <avr/io.h>
PROGMEM const uint16_t sine512[] =
{250,256,262,269,275,281,288,294,301,308,314,319,326,332,339,344,350,356,362,367,374,379,384,389,395,400,404,410,414,419,423,428,433,436,440,445,449,452,455,458,463,466,468,471,474,476,478,481,483,485,487,488,490,491,493,494,495,496,496,498,499,499,499,500,500,499,499,499,498,498,496,496,495,494,493,493,492,491,489,488,487,486,484,483,481,480,478,476,474,473,471,470,468,466,465,463,460,459,457,455,453,452,450,449,447,446,445,443,442,440,439,438,436,435,434,433,432,432,431,430,430,429,428,428,428,428,427,427,427,427,427,428,428,428,428,429,430,430,431,432,432,433,434,435,436,438,439,440,442,443,445,446,447,449,450,452,453,455,457,459,460,463,465,466,468,470,471,473,474,476,478,480,481,483,484,486,487,488,489,491,492,493,493,494,495,496,496,498,498,499,499,499,500,500,499,499,499,498,496,496,495,494,493,491,490,488,487,485,483,481,478,476,474,471,468,466,463,458,455,452,449,445,440,436,433,428,423,419,414,410,404,400,395,389,384,379,374,367,362,356,350,344,339,332,326,319,314,308,301,294,288,281,275,269,262,256,250,244,238,231,225,219,212,206,199,192,186,181,174,168,161,156,150,144,138,133,126,121,116,111,105,100,96,90,86,81,77,72,67,64,60,55,51,48,45,42,37,34,32,29,26,24,22,19,17,15,13,12,10,9,7,6,5,4,4,2,1,1,1,0,0,1,1,1,2,2,4,4,5,6,7,7,8,9,11,12,13,14,16,17,19,20,22,24,26,27,29,30,32,34,35,37,40,41,43,45,47,48,50,51,53,54,55,57,58,60,61,62,64,65,66,67,68,68,69,70,70,71,72,72,72,72,73,73,73,73,73,72,72,72,72,71,70,70,69,68,68,67,66,65,64,62,61,60,58,57,55,54,53,51,50,48,47,45,43,41,40,37,35,34,32,30,29,27,26,24,22,20,19,17,16,14,13,12,11,9,8,7,7,6,5,4,4,2,2,1,1,1,0,0,1,1,1,2,4,4,5,6,7,9,10,12,13,15,17,19,22,24,26,29,32,34,37,42,45,48,51,55,60,64,67,72,77,81,86,90,96,100,105,111,116,121,126,133,138,144,150,156,161,168,174,181,186,192,199,206,212,219,225,231,238,244};
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
//vyssi refclk == vyssi frekout const unsigned long
refclk=1562960;
const unsigned long refclk=781480;
volatile int current_count;
volatile unsigned long phase_accumulator;
volatile unsigned long tword_m;
volatile unsigned long stepm;
volatile word count = 0;
volatile byte DT = 10;
volatile byte ampl = 13;
volatile word offset_1 = 171;
volatile word offset_2 = 341;
word fnom = 5000;
word fzad = 0;
word boost = 600;
word readpot;
word calc;
boolean ISR_exec_time = 1;
boolean RUN = 0;
byte bufclr = 0;
void setup()
{
pinMode(6, OUTPUT); //OC4A
pinMode(7, OUTPUT); //OC4B
pinMode(8, OUTPUT); //OC4C
pinMode(11, OUTPUT); //OC1A
pinMode(12, OUTPUT); //OC1B
pinMode(13, OUTPUT); //OC1C
//pinMode(5, OUTPUT); //OC3A
//pinMode(2, OUTPUT); //OC3B
//pinMode(3, OUTPUT); //OC3C
pinMode(52, OUTPUT);
pinMode(53, OUTPUT);
pinMode(22, INPUT_PULLUP);
pinMode(23, INPUT_PULLUP);
sbi (GTCCR, TSM);
sbi (GTCCR, PSRASY);
sbi (GTCCR, PSRSYNC);
Setup_timer1();
Setup_timer2();
Setup_timer4();
//Setup_timer3();
//Setup_timer5();
TCNT1 = 0;
//TCNT3 = 0;
TCNT4 = 0;
//TCNT5 = 0;
GTCCR = 0;
//Disable Timer 0
cbi (TIMSK0,TOIE0);
tword_m=pow(2,32)*fzad/refclk;
sbi (TIMSK4,TOIE4);
Serial.begin(9600);
}
void loop()
{
while(1)
{
readpot = 0;
for (int i=0; i <= 9; i++)
{
readpot = readpot + analogRead(0);
}
if (digitalRead(22)==0 && fzad==0)
{
offset_1 = 341;
offset_2 = 171;
}
if (digitalRead(22)==1 && fzad==0 )
{
offset_1 = 171;
offset_2 = 341;
}
//===============================================
if (digitalRead(23)==1 && fzad!=readpot)
{
//================================================
if (fzad>readpot && TCNT2 > 10)
{
fzad = fzad-1;
TCNT2=0;
}
if (fzad<readpot && TCNT2 > 10)
{
fzad = fzad+1;
TCNT2=0;
}
//================================================
stepm = pow(2,32)*fzad/refclk;
calc = ((1280/(fnom/100))*(fzad/100))/10;
if (fzad > fnom) //*500
{
calc = 128;
}
if (fzad < boost)
{
calc = 14;
}
cbi (TIMSK4,TOIE4);
ampl = calc; //*5
tword_m = stepm;
sbi (TIMSK4,TOIE4);
}
//===============================================
/* */
if (count > 7000)
{
bufclr = bufclr+1;
count = 0;
Serial.println(bufclr);
Serial.println(fzad);
Serial.println(ampl);
}
}
}
ISR(TIMER4_OVF_vect)
{
sbi(PORTB,ISR_exec_time);
phase_accumulator=phase_accumulator+tword_m;
current_count=phase_accumulator >> 23;
word offs;
word offs1;
word offs2;
offs= current_count + offset_1;
offs2 = current_count + offset_2;
if (offs > 511)
{
offs = offs - 512;
}
if (offs2 > 511)
{
offs2 = offs2 - 512;
}
offs = (pgm_read_word_near(sine512 + offs)*ampl) >> 6;
offs1 = (pgm_read_word_near(sine512 + current_count)*ampl) >>
6;
offs2 = (pgm_read_word_near(sine512 + offs2)*ampl) >> 6;
if (tword_m > 0)
{
OCR4B = offs + DT;
OCR1B = offs;
OCR4A = offs1 + DT;
OCR1A = offs1;
OCR4C = offs2 + DT;
OCR1C = offs2;
}
else
{
OCR4B = 1023;
OCR1B = 0;
OCR4A = 1023;
OCR1A = 0;
OCR4C = 1023;
OCR1C = 0;
}
cbi(PORTB,ISR_exec_time);
count = count+1;
/* */
}
void Setup_timer1(void)
{
//Clock Prescaler : 1
sbi (TCCR1B, CS10);
cbi (TCCR1B, CS11);
cbi (TCCR1B, CS12);
// Timer1 Phase Correct PWM
sbi (TCCR1A, COM1A0);
sbi (TCCR1A, COM1A1);
sbi (TCCR1A, COM1B0);
sbi (TCCR1A, COM1B1);
sbi (TCCR1A, COM1C0); //tretireg
sbi (TCCR1A, COM1C1); //tretireg
// Mode 1 / Phase Correct PWM
sbi (TCCR1A, WGM10);
sbi (TCCR1A, WGM11);
cbi (TCCR1B, WGM12);
cbi (TCCR1B, WGM13);
}
void Setup_timer4(void)
{
sbi (TCCR4B, CS40);
cbi (TCCR4B, CS41);
cbi (TCCR4B, CS42);
cbi (TCCR4A, COM4A0);
sbi (TCCR4A, COM4A1);
cbi (TCCR4A, COM4B0);
sbi (TCCR4A, COM4B1);
cbi (TCCR4A, COM4C0);
sbi (TCCR4A, COM4C1);
sbi (TCCR4A, WGM40);
sbi (TCCR4A, WGM41);
cbi (TCCR4B, WGM42);
cbi (TCCR4B, WGM43);
}
void Setup_timer2(void)
{
//Prescaler : 1
cbi (TCCR2B, CS20);
cbi (TCCR2B, CS21);
sbi (TCCR2B, CS22);
// Phase Correct PWM
cbi (TCCR2A, COM2A0); // clear Compare Match
cbi (TCCR2A, COM2A1);
cbi (TCCR2A, COM2B0);
cbi (TCCR2A, COM2B1);
//Phase Correct PWM
cbi (TCCR2A, WGM20);
cbi (TCCR2A, WGM21);
cbi (TCCR2B, WGM22);
}
/*
void Setup_timer3(void)
{
sbi (TCCR3B, CS30);
cbi (TCCR3B, CS31);
cbi (TCCR3B, CS32);
cbi (TCCR3A, COM3A0);
sbi (TCCR3A, COM3A1);
cbi (TCCR3A, COM3B0);
sbi (TCCR3A, COM3B1);
cbi (TCCR3A, COM3C0);
sbi (TCCR3A, COM3C1);
sbi (TCCR3A, WGM30);
sbi (TCCR3A, WGM31);
cbi (TCCR3B, WGM32);
cbi (TCCR3B, WGM33);
}
void Setup_timer5(void)
{
sbi (TCCR5B, CS50);
cbi (TCCR5B, CS51);
cbi (TCCR5B, CS52);
cbi (TCCR5A, COM5A0);
sbi (TCCR5A, COM5A1);
cbi (TCCR5A, COM5B0);
sbi (TCCR5A, COM5B1);
cbi (TCCR5A, COM5C0);
sbi (TCCR5A, COM5C1);
sbi (TCCR5A, WGM50);
sbi (TCCR5A, WGM51);
cbi (TCCR5B, WGM52);
cbi (TCCR5B, WGM53);
}
Setup_timer2();
void Setup_timer2()
{
//Prescaler : 1
sbi (TCCR2B, CS20);
cbi (TCCR2B, CS21);
cbi (TCCR2B, CS22);
// Phase Correct PWM
cbi (TCCR2A, COM2A0); // clear Compare Match
cbi (TCCR2A, COM2A1);
cbi (TCCR2A, COM2B0);
cbi (TCCR2A, COM2B1);
//Phase Correct PWM
sbi (TCCR2A, WGM20);
cbi (TCCR2A, WGM21);
cbi (TCCR2B, WGM22);
}
volatile byte ms4_delay;
volatile byte c4ms;
if (c4ms > 25)
{
c4ms=0;
offset_3=analogRead(0)/4;
dfreq=50.0;
cbi (TIMSK2,TOIE2);
tword_m=pow(2,32)*dfreq/refclk;
sbi (TIMSK2,TOIE2);
}
*/
/*
if(ms4_delay++ == 125)
{
c4ms++;
ms4_delay=0; //reset count
}
coffs = pgm_read_word_near(sine512 + coffs2 - 1);
OCR1B = ((word)coffs*99)/100; // +1 korekce
*/
/*
*/
#ifndef __PGMSPACE_H_
#define __PGMSPACE_H_ 1
#include <inttypes.h>
#define PROGMEM
#define PGM_P const char *
#define PSTR(str) (str)
typedef void prog_void;
typedef char prog_char;
typedef unsigned char prog_uchar;
typedef int8_t prog_int8_t;
typedef uint8_t prog_uint8_t;
typedef int16_t prog_int16_t;
typedef uint16_t prog_uint16_t;
typedef int32_t prog_int32_t;
typedef uint32_t prog_uint32_t;
#define strcpy_P(dest, src) strcpy((dest), (src))
#define strcat_P(dest, src) strcat((dest), (src))
#define strcmp_P(a, b) strcmp((a), (b))
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#define pgm_read_float(addr) (*(const float *)(addr))
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
#define pgm_read_word_near(addr) pgm_read_word(addr)
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
#define pgm_read_float_near(addr) pgm_read_float(addr)
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
#define pgm_read_word_far(addr) pgm_read_word(addr)
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
#define pgm_read_float_far(addr) pgm_read_float(addr)
#endif
// Look Up table of a single sine period divied up into 256 values. Refer
to PWM to sine.xls on how the values was calculated
PROGMEM prog_uchar sine256[] = {
127,130,133,136,139,143,146,149,152,155,158,161,164,167,170,173,176,178,181,184,187,190,192,195,198,200,203,205,208,210,212,215,217,219,221,223,225,227,229,231,233,234,236,238,239,240,
242,243,244,245,247,248,249,249,250,251,252,252,253,253,253,254,254,254,254,254,254,254,253,253,253,252,252,251,250,249,249,248,247,245,244,243,242,240,239,238,236,234,233,231,229,227,225,223,
221,219,217,215,212,210,208,205,203,200,198,195,192,190,187,184,181,178,176,173,170,167,164,161,158,155,152,149,146,143,139,136,133,130,127,124,121,118,115,111,108,105,102,99,96,93,90,87,84,81,78,
76,73,70,67,64,62,59,56,54,51,49,46,44,42,39,37,35,33,31,29,27,25,23,21,20,18,16,15,14,12,11,10,9,7,6,5,5,4,3,2,2,1,1,1,0,0,0,0,0,0,0,1,1,1,2,2,3,4,5,5,6,7,9,10,11,12,14,15,16,18,20,21,23,25,27,29,31,
33,35,37,39,42,44,46,49,51,54,56,59,62,64,67,70,73,76,78,81,84,87,90,93,96,99,102,105,108,111,115,118,121,124
};
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) //define a bit to
have the properties of a clear bit operator
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))//define a bit to have
the properties of a set bit operator
int PWM1= 11;// PWM1 output, phase 1
int PWM2 = 3; //[WM2 ouput, phase 2
int PWM3 = 10; //PWM3 output, phase 3
int offset_1 = 85; //offset 1 is 120 degrees out of phase with previous
phase, Refer to PWM to sine.xls
int offset_2 = 170; //offset 2 is 120 degrees out of phase with offset 1.
Refer to PWM to sine.xls
int program_exec_time = 6; //monitor how quickly the interrupt
trigger
int ISR_exec_time = 7; //monitor how long the interrupt takes
double dfreq;
const double refclk=31376.6; // measured output frequency
// variables used inside interrupt service declared as voilatile
volatile byte current_count; // Keep track of where the
current count is in sine 256 array
volatile byte ms4_delay; //variable used to generate a 4ms
delay
volatile byte c4ms; // after every 4ms this variable is
incremented, its used to create a delay of 1 second
volatile unsigned long phase_accumulator; // pahse accumulator
volatile unsigned long tword_m; // dds tuning word m, refer to
DDS_calculator (from Martin Nawrath) for explination.
void setup()
{
pinMode(PWM1, OUTPUT); //sets the digital pin as output
pinMode(PWM2, OUTPUT); //sets the digital pin as output
pinMode(PWM3, OUTPUT); //sets the digital pin as output
pinMode(program_exec_time, OUTPUT); //sets the digital pin as
output
pinMode(9, OUTPUT); //sets the digital pin as output
sbi(PORTD,program_exec_time); //Sets the pin
Setup_timer1();
Setup_timer2();
//Disable Timer 1 interrupt to avoid any timing delays
cbi (TIMSK0,TOIE0); //disable Timer0 !!! delay() is now not
available
sbi (TIMSK2,TOIE2); //enable Timer2 Interrupt
dfreq=1000.0; //initial output frequency = 1000.o
Hz
tword_m=pow(2,32)*dfreq/refclk; //calulate DDS new tuning word
}
void loop()
{
while(1)
{
sbi(PORTD,program_exec_time); //Sets the pin
if (c4ms > 250) // c4ms = 4ms, thus 4ms *250 = 1 second
delay
{
c4ms=0; //Reset c4ms
dfreq=analogRead(0); //Read voltage on analog 1 to see
desired output frequency, 0V = 0Hz, 5V = 1.023kHz
cbi (TIMSK2,TOIE2); //Disable Timer2 Interrupt
tword_m=pow(2,32)*dfreq/refclk; //Calulate DDS new tuning
word
sbi (TIMSK2,TOIE2); //Enable Timer2 Interrupt
}
}
}
//Timer 1 setup
//Set prscaler to 1, PWM mode to phase correct PWM, 16000000/510 =
31372.55 Hz clock
void Setup_timer1(void)
{
// Timer1 Clock Prescaler to : 1
sbi (TCCR1B, CS10);
cbi (TCCR1B, CS11);
cbi (TCCR1B, CS12);
// Timer1 PWM Mode set to Phase Correct PWM
cbi (TCCR1A, COM1A0);
sbi (TCCR1A, COM1A1);
cbi (TCCR1A, COM1B0);
sbi (TCCR1A, COM1B1);
// Mode 1 / Phase Correct PWM
sbi (TCCR1A, WGM10);
cbi (TCCR1A, WGM11);
cbi (TCCR1B, WGM12);
cbi (TCCR1B, WGM13);
}
//Timer 1 setup
//Set prscaler to 1, PWM mode to phase correct PWM, 16000000/510 =
31372.55 Hz clock
void Setup_timer2()
{
// Timer2 Clock Prescaler to : 1
sbi (TCCR2B, CS20);
cbi (TCCR2B, CS21);
cbi (TCCR2B, CS22);
// Timer2 PWM Mode set to Phase Correct PWM
cbi (TCCR2A, COM2A0); // clear Compare Match
sbi (TCCR2A, COM2A1);
cbi (TCCR2A, COM2B0);
sbi (TCCR2A, COM2B1);
// Mode 1 / Phase Correct PWM
sbi (TCCR2A, WGM20);
cbi (TCCR2A, WGM21);
cbi (TCCR2B, WGM22);
}
//Timer2 Interrupt Service at 31372,550 KHz = 32uSec
//This is the timebase REFCLOCK for the DDS generator
//FOUT = (M (REFCLK)) / (2 exp 32)
//Runtime : 8 microseconds
ISR(TIMER2_OVF_vect)
{
cbi(PORTD,program_exec_time); //Clear the pin
sbi(PORTD,ISR_exec_time); // Sets the pin
phase_accumulator=phase_accumulator+tword_m; //Adds tuning M word to
previoud phase accumulator. refer to DDS_calculator (from Martin Nawrath) for
explination.
current_count=phase_accumulator >> 24; // use upper 8 bits of
phase_accumulator as frequency information
OCR2A=pgm_read_byte_near(sine256 + current_count); // read value fron ROM
sine table and send to PWM
OCR2B=pgm_read_byte_near(sine256 + (uint8_t)(current_count + offset_1));
// read value fron ROM sine table and send to PWM, 120 Degree out of phase of
PWM1
OCR1A = pgm_read_byte_near(sine256 + (uint8_t)(current_count +
offset_2));// read value fron ROM sine table and send to PWM, 120 Degree out of
phase of PWM2
OCR1B = pgm_read_byte_near(sine256 + (uint8_t)(current_count +
offset_2));// read value fron ROM sine table and send to PWM, 120 Degree out of
phase of PWM2
//increment variable ms4_delay every 4mS/125 = milliseconds 32uS
if(ms4_delay++ == 125)
{
c4ms++;
ms4_delay=0; //reset count
}
cbi(PORTD,ISR_exec_time); //Clear the pin
}
##############################################################
atmega328bb.name=ATmega328 on a breadboard (8 MHz internal clock)
atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=30720
atmega328bb.upload.speed=57600
atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F
atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.core=arduino:arduino
atmega328bb.build.variant=arduino:standard
#ifndef __PGMSPACE_H_
#define __PGMSPACE_H_ 1
#include <inttypes.h>
#define PROGMEM
#define PGM_P const char *
#define PSTR(str) (str)
typedef void prog_void;
typedef char prog_char;
typedef unsigned char prog_uchar;
typedef int8_t prog_int8_t;
typedef uint8_t prog_uint8_t;
typedef int16_t prog_int16_t;
typedef uint16_t prog_uint16_t;
typedef int32_t prog_int32_t;
typedef uint32_t prog_uint32_t;
#define strcpy_P(dest, src) strcpy((dest), (src))
#define strcat_P(dest, src) strcat((dest), (src))
#define strcmp_P(a, b) strcmp((a), (b))
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#define pgm_read_float(addr) (*(const float *)(addr))
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
#define pgm_read_word_near(addr) pgm_read_word(addr)
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
#define pgm_read_float_near(addr) pgm_read_float(addr)
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
#define pgm_read_word_far(addr) pgm_read_word(addr)
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
#define pgm_read_float_far(addr) pgm_read_float(addr)
#endif
// Look Up table of a single sine period divied up into 256 values. Refer
to PWM to sine.xls on how the values was calculated
PROGMEM prog_uchar sine256[] = {
127,130,133,136,139,143,146,149,152,155,158,161,164,167,170,173,176,178,181,184,187,190,192,195,198,200,203,205,208,210,212,215,217,219,221,223,225,227,229,231,233,234,236,238,239,240,
242,243,244,245,247,248,249,249,250,251,252,252,253,253,253,254,254,254,254,254,254,254,253,253,253,252,252,251,250,249,249,248,247,245,244,243,242,240,239,238,236,234,233,231,229,227,225,223,
221,219,217,215,212,210,208,205,203,200,198,195,192,190,187,184,181,178,176,173,170,167,164,161,158,155,152,149,146,143,139,136,133,130,127,124,121,118,115,111,108,105,102,99,96,93,90,87,84,81,78,
76,73,70,67,64,62,59,56,54,51,49,46,44,42,39,37,35,33,31,29,27,25,23,21,20,18,16,15,14,12,11,10,9,7,6,5,5,4,3,2,2,1,1,1,0,0,0,0,0,0,0,1,1,1,2,2,3,4,5,5,6,7,9,10,11,12,14,15,16,18,20,21,23,25,27,29,31,
33,35,37,39,42,44,46,49,51,54,56,59,62,64,67,70,73,76,78,81,84,87,90,93,96,99,102,105,108,111,115,118,121,124
};
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) //define a bit to
have the properties of a clear bit operator
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))//define a bit to have
the properties of a set bit operator
int PWM1= 11;// PWM1 output, phase 1
int PWM2 = 3; //[WM2 ouput, phase 2
int PWM3 = 10; //PWM3 output, phase 3
int offset_1 = 85; //offset 1 is 120 degrees out of phase with previous
phase, Refer to PWM to sine.xls
int offset_2 = 170; //offset 2 is 120 degrees out of phase with offset 1.
Refer to PWM to sine.xls
int program_exec_time = 6; //monitor how quickly the interrupt
trigger
int ISR_exec_time = 7; //monitor how long the interrupt takes
double dfreq;
const double refclk=31376.6; // measured output frequency
// variables used inside interrupt service declared as voilatile
volatile byte current_count; // Keep track of where the
current count is in sine 256 array
volatile byte ms4_delay; //variable used to generate a 4ms
delay
volatile byte c4ms; // after every 4ms this variable is
incremented, its used to create a delay of 1 second
volatile unsigned long phase_accumulator; // pahse accumulator
volatile unsigned long tword_m; // dds tuning word m, refer to
DDS_calculator (from Martin Nawrath) for explination.
void setup()
{
pinMode(PWM1, OUTPUT); //sets the digital pin as output
pinMode(PWM2, OUTPUT); //sets the digital pin as output
pinMode(PWM3, OUTPUT); //sets the digital pin as output
pinMode(program_exec_time, OUTPUT); //sets the digital pin as
output
pinMode(9, OUTPUT); //sets the digital pin as output
sbi(PORTD,program_exec_time); //Sets the pin
Setup_timer1();
Setup_timer2();
//Disable Timer 1 interrupt to avoid any timing delays
cbi (TIMSK0,TOIE0); //disable Timer0 !!! delay() is now not
available
sbi (TIMSK2,TOIE2); //enable Timer2 Interrupt
dfreq=1000.0; //initial output frequency = 1000.o
Hz
tword_m=pow(2,32)*dfreq/refclk; //calulate DDS new tuning word
}
void loop()
{
while(1)
{
sbi(PORTD,program_exec_time); //Sets the pin
if (c4ms > 250) // c4ms = 4ms, thus 4ms *250 = 1 second
delay
{
c4ms=0; //Reset c4ms
dfreq=analogRead(0); //Read voltage on analog 1 to see
desired output frequency, 0V = 0Hz, 5V = 1.023kHz
cbi (TIMSK2,TOIE2); //Disable Timer2 Interrupt
tword_m=pow(2,32)*dfreq/refclk; //Calulate DDS new tuning
word
sbi (TIMSK2,TOIE2); //Enable Timer2 Interrupt
}
}
}
//Timer 1 setup
//Set prscaler to 1, PWM mode to phase correct PWM, 16000000/510 =
31372.55 Hz clock
void Setup_timer1(void)
{
// Timer1 Clock Prescaler to : 1
sbi (TCCR1B, CS10);
cbi (TCCR1B, CS11);
cbi (TCCR1B, CS12);
// Timer1 PWM Mode set to Phase Correct PWM
cbi (TCCR1A, COM1A0);
sbi (TCCR1A, COM1A1);
cbi (TCCR1A, COM1B0);
sbi (TCCR1A, COM1B1);
// Mode 1 / Phase Correct PWM
sbi (TCCR1A, WGM10);
cbi (TCCR1A, WGM11);
cbi (TCCR1B, WGM12);
cbi (TCCR1B, WGM13);
}
//Timer 1 setup
//Set prscaler to 1, PWM mode to phase correct PWM, 16000000/510 =
31372.55 Hz clock
void Setup_timer2()
{
// Timer2 Clock Prescaler to : 1
sbi (TCCR2B, CS20);
cbi (TCCR2B, CS21);
cbi (TCCR2B, CS22);
// Timer2 PWM Mode set to Phase Correct PWM
cbi (TCCR2A, COM2A0); // clear Compare Match
sbi (TCCR2A, COM2A1);
cbi (TCCR2A, COM2B0);
sbi (TCCR2A, COM2B1);
// Mode 1 / Phase Correct PWM
sbi (TCCR2A, WGM20);
cbi (TCCR2A, WGM21);
cbi (TCCR2B, WGM22);
}
//Timer2 Interrupt Service at 31372,550 KHz = 32uSec
//This is the timebase REFCLOCK for the DDS generator
//FOUT = (M (REFCLK)) / (2 exp 32)
//Runtime : 8 microseconds
ISR(TIMER2_OVF_vect)
{
cbi(PORTD,program_exec_time); //Clear the pin
sbi(PORTD,ISR_exec_time); // Sets the pin
phase_accumulator=phase_accumulator+tword_m; //Adds tuning M word to
previoud phase accumulator. refer to DDS_calculator (from Martin Nawrath) for
explination.
current_count=phase_accumulator >> 24; // use upper 8 bits of
phase_accumulator as frequency information
OCR2A=pgm_read_byte_near(sine256 + current_count); // read value fron ROM
sine table and send to PWM
OCR2B=pgm_read_byte_near(sine256 + (uint8_t)(current_count + offset_1));
// read value fron ROM sine table and send to PWM, 120 Degree out of phase of
PWM1
OCR1A = pgm_read_byte_near(sine256 + (uint8_t)(current_count +
offset_2));// read value fron ROM sine table and send to PWM, 120 Degree out of
phase of PWM2
OCR1B = pgm_read_byte_near(sine256 + (uint8_t)(current_count +
offset_2));// read value fron ROM sine table and send to PWM, 120 Degree out of
phase of PWM2
//increment variable ms4_delay every 4mS/125 = milliseconds 32uS
if(ms4_delay++ == 125)
{
c4ms++;
ms4_delay=0; //reset count
}
cbi(PORTD,ISR_exec_time); //Clear the pin
}
#define UN (400.0) // motor rated voltage
#define FN (50.0) // motor nominal frequency
#define P (UN/FN) // associate Determining the ratio of voltage to nominal frequency
#define T_PWM (0.000255) // PWM signal period - set by the prescaler in the counters
#define T_MAX (4.0) // Specify the maximum output voltage period
#define T_MIN (0.02) // minimum output voltage
#define K_MAX floor (T_MAX/T_PWM) // number of period values for T_MAX
#define K_MIN ceil (T_MIN/T_PWM) // number of period values for T_MIN
volatile static unsigned int length_tab_sin; // variable containing the number of values in the full // period of the output voltage
static unsigned int i = 0; // auxiliary variable
volatile static unsigned int main_counter = 0; // variable in the interrupt
// ^ every T_PWM period increasing its value by 1
static unsigned int next_value_sin = 0; // variable which value sin should be calculated
static double t_param = 50; // parameter specifying the period of the output voltage
static float t = T_PWM; // T_PWM
static float omega_t; // pulsation of the output voltage multiplied by T_PWM
static float t_out; // output voltage period
static float U_o_param; // parameter specifying the size of the output voltage
// ^ calculated on the basis of t_out and U_in
static unsigned int ocr0a, ocr0b, ocr1a; // auxiliary variables to store obl. fillings
static unsigned int ocr1b, ocr2a, ocr2b; // ^
static double sin_in; // variable containing the parameter of the function sin
static double error = 1; // variable used to stop generating voltage when overloaded
static unsigned int analog = 0; // variable containing the measured value
static double U_in = 0; // variable holding the voltage measurement of the intermediate system
static double U_rms_max; // maximum currently possible to generate the effective voltage value
static bool a = 0; // logical variable for the implementation of two alternating measurements
//void setup()
//{
// Serial.begin(57600);
//}
int main()
{
io_init(); // initiate entry and exit
timers_init(); // initialization of PWM meters
adc_init(); // initialization of the ADC transducer
while (1) // infinite loop with the main program
{
if (i == 185) // condition specifying the entry to the change function
{ // parameter of the discharge voltage, calling approx. 100ms
chang_para(); // function to change the parameters of the output voltage
i = 0;
}
next_value_sin = main_counter % length_tab_sin; // the next sine value to be calculated
sin_in = omega_t*next_value_sin;
// calculating the value to registers specifying the completion of the output signal /
ocr0a = round(error * (U_o_param * (sin(sin_in) + 1) * 254 / 2) + 1); // pin
ocr0b = ocr0a - 1;
ocr1a = round (error * (U_o_param * (sin(sin_in - 2.09) + 1) * 254 / 2) + 1); // pin
ocr1b = ocr1a - 1;
ocr2a = round(error * (U_o_param * (sin(sin_in + 2.09) + 1) * 254 / 2) + 1); // pin
ocr2b = ocr2a - 1;
// updating values in registers /
cli(); // prohibition on obsloge interruptions in case if
// an interrupt occurred during the upgrade
OCR0A = ocr0a; // pin
OCR0B = ocr0b; // pin
OCR1AL = ocr1a; // pin
OCR1BL = ocr1b; // pin
OCR2A = ocr2a; // pin
OCR2B = ocr2b; // pin
sei(); // allow for interruption obsloge
i++;
}
}
void adc_init()
{
ADCSRA |= _BV(ADEN); // start the transmitter
ADCSRA |= _BV(ADPS2); // setting the prescaler
ADCSRA |= _BV(ADPS1); // ^
ADCSRA |= _BV(ADPS0); // ^
ADMUX |= _BV(REFS0); // reference voltage set as power supply
ADMUX |= ADMUX &= 0b11110000; // choose the ADC0 input for measurement
}
void timers_init()
{
cli(); // interrupt handler is forbidden
// timer0 init
TCCR0A |= _BV(COM0A1) | _BV(COM0B0) | _BV(COM0B1) | _BV(WGM00);
TCCR0B |= _BV(CS01); // preskaler 8 | _BV(WGM02)
TIMSK0 |= _BV (TOIE0); // flag from value 0 enabled //
// timer1 init
TCCR1A |= _BV(COM1A1) | _BV(COM1B0) | _BV(COM1B1) | _BV(WGM10);
TCCR1B |= _BV (CS11); // preskaler 8 // | _BV(WGM02)
// timer2 init
TCCR2A |= _BV(COM2A1) | _BV(COM2B0) | _BV(COM2B1) | _BV(WGM20);
TCCR2B |= _BV(CS21); // preskaler 8 | _BV(WGM02)
// resetting counter values
TCNT0 = 0;
TCNT1L = 0;
TCNT2 = 0; /* the counter counts in g3re to 255, then in d3 ?: / \ / \ / \
at the value of 255 there is an interruption at which it occurs
voltage and current measurements
*/
sei(); // allow for interruption obsloge
}
void io_init()
{
pinMode(13, OUTPUT); // OC0A Arduino Mega2560 pin 13
pinMode(4, OUTPUT); // OC0B Arduino Mega2560 pin 4
pinMode(11, OUTPUT); // OC1A Arduino Mega2560 pin 11
pinMode(12, OUTPUT); // OC1B Arduino Mega2560 pin 12
pinMode(10, OUTPUT); // OC2A Arduino Mega2560 pin 10
pinMode(9, OUTPUT); // OC2B Arduino Mega2560 pin 9
pinMode(14, INPUT_PULLUP); // up Arduino Mega2560 14
pinMode(15, INPUT_PULLUP); // dn Arduino Mega2560 15
pinMode(16, OUTPUT); // Arduino Mega2560 16
}
ISR(TIMER0_OVF_vect) // interrupt at 0 counter 0
{
analog = ADC;
if (a)
{
U_in = 0.0709 * analog;
ADMUX |= _BV(MUX0); // choose the ADC1 input to measure the current
}
else
{
ADMUX |= ADMUX &= 0b11110000; // select the ADC0 input to measure the voltage
if (analog > 579)
{
error = 0; // if the overload turn off the voltage generation
digitalWrite(16, HIGH); // lighting the diode
}
}
ADCSRA |= _BV(ADSC); // start reading the measurement
a = a ^ 1; // the XOR gate negates the logical value a
main_counter++;
if (main_counter >= length_tab_sin) main_counter = 0;
}
void chang_para()
{
t_param = map(analogRead(3), 0, 102, 0, 100);
U_rms_max = U_in * 0.62; // value 0.62 experimentally limited
bool up; // logical variable, informs you that the button has been pressed to increase the frequency
bool down; // logical variable, informs you that the button has been pressed to decrease the frequency
up = digitalRead(14); // read: if you press the button, increase the frequency
down = digitalRead(15); // read: if you press the button you will decrease the frequency
if (!up) t_param--; // if you press the button to increase the frequency then you will decrease the period
if (!down) t_param ++; // if the button you press decreases the frequency, it will increase the period
if (t_param < 0) t_param = 0; // protection of exceeding the extreme values
if (t_param > 100) t_param = 100; // ^
length_tab_sin = ceil((K_MAX - K_MIN) * t_param / 500 + K_MIN); // amount of values filled in one period
t_out = T_PWM * length_tab_sin; // calculate the period of the output voltage
omega_t = t * 2 * PI / t_out; // calculate the output voltage pulsation
U_o_param = (P / t_out) / U_rms_max; // calculate the parameter determining the value of the output voltage
if (t_out > 1) U_o_param = 0.5 * (18.5 / U_rms_max); // voltage at the output at low frequencies of 10v
if (U_o_param > 1) U_o_param = 1; //protection of exceeding the extreme values
error = 1; //if the overload turn off the voltage generation
//digitalWrite(13, HIGH); //diode lighting
//if the overload turn off the voltage generation
digitalWrite(16, LOW); //diode lighting
// Serial.println(t_param);
}
ความคิดเห็น
แสดงความคิดเห็น