pwm_modulation.c

/* ATmega644 programmieren */

/* Testprogramm PWM-Modulation */

/* Timer0  8-Bit; Zaehler */

/* Timer1 16-Bit; PWM-Modus */

/* Timer2  8-Bit; Zaehler */

/* PID-Regler */

/** C P U _ Definieren und BAUDRATE berechnen **/

//*/

#ifndef F_CPU

#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 20000000"

#define F_CPU 20000000UL // Systemtakt in Hz - Definition als unsigned long beachten 

                         // Ohne ergeben sich unten Fehler in der Berechnung

#endif

#define BAUD 9600UL      // Baudrate

// Berechnungen

#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden

#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate

#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD)    // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))

  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 

#endif 

//*/

#include <avr/io.h> 

#include <stdint.h>      //standardisierte Datentypen z.b typedef signed char int8_t;

#include <stdlib.h>

#include <avr/interrupt.h>

#include <math.h>

volatile unsigned char m       = 0;

volatile unsigned char n       = 0;

volatile unsigned char OldPegel      = 0;

volatile unsigned char Pegel     = 0;

volatile unsigned char OldPuls     = 0;

volatile unsigned char Puls     = 0;

volatile unsigned short i       = 0;

volatile unsigned short j       = 0;

volatile unsigned short k       = 0;

int16_t l = 0;

volatile unsigned char zeichen    = 0;

volatile unsigned short counter    = 0;

volatile unsigned long pwm_Ein         = 0;

volatile unsigned long pwm_Gesamt       = 0;

volatile unsigned long  pwm_Verhaeltnis     = 0;

volatile unsigned short test         = 0;

volatile unsigned short start        = 0;

volatile unsigned short sensor_Verhaeltnis  = 0;

volatile unsigned short sen_v         = 0;

volatile unsigned short sen_rps        = 0;

volatile unsigned short soll_wert      = 0;

volatile unsigned short ist_wert       = 0;

/***PID-Reglerwerte ***/

volatile float q0            = 0;

volatile float q1            = 0;

volatile float q2           = 0;

volatile float Kp            = 0.1*0.5;

volatile float Ki            = 0;

volatile float Kd           = 0;

volatile float Ta           = 0.000012;

volatile float e            = 0;

volatile float ealt         = 0;

volatile float ealt2         = 0;

volatile float y             = 0;

volatile float yalt          = 0;

volatile float ausgang         = 0;

/***---------------------------------------port_set---------------------------------------------------------------***/

            /** Register, Directions, Ports und Pins setzten **/

void port_set(void){

  // PORTA

  DDRA  = (0<< DDA0) | (0<< DDA1) | (0<< DDA2) | (0<< DDA3) | (0<< DDA4) | (0<< DDA5) | (0<< DDA6) | (0<< DDA7);  // PORTA: PIN: 0-3 = LED [H5- H8] ; PIN: 5-6 = Gyro; PIN: 4,7 = Schalter

  PORTA = (0<< PA0) | (0<< PA1) | (0<< PA2) | (0<< PA3) | (0<< PA4) | (0<< PA5) | (0<< PA6) | (0<< PA7) ;           // PIN 1-4 = LED auf GND dann ON ! PU Widerstand bei Taster

   // PORTB

  DDRB = (0<< DDB0) | (0<< DDB1) | (0<< DDB2) | (1<< DDB3) | (1<< DDB4) | (1<< DDB5) | (0<< DDB6) | (0<< DDB7);      // PORTB: PIN: 0-3 = LED [H1- H4]; PIN: 3 = OC0A 

  PORTB = (0<< PB0) | (0<< PB1) | (0<< PB2) | (0<< PB3) | (0<< PB4) | (0<< PB5) | (0<< PB6) | (0<< PB7) ;

    // PORTD

  DDRD = (1<< DDD5);    // PORTA: PIN: 5 = PWM OC1A 16_Bit auf Ausgang

  //PORTD = 0x00;      //(1<<PD5);    

}

/***---------------------------------------timer0---------------------------------------------------------------***/

            /** TIMER0 Einstellungen und Register **/

void timer0_set(void){

  TCCR0A |= (0<<COM0A1) | (0<<COM0A0) | (0<<WGM01) | (0<<WGM00);  // T/C0 Control Register A: normaler Modus 

  TCCR0B |= (0<<WGM02) | (0<<CS02) | (0<<CS01) | (1<<CS00);       // Starte Timer0 mit clk/1

  TIMSK0 |= (1<<TOIE0);                        // Fuer Interrupt Routine

}

/***---------------------------------------timer1---------------------------------------------------------------***/

            /** TIMER1 Einstellungen und Register **/

void timer1_set(void){

  TCCR1A |= (1<<COM1A1) | (1<<WGM11) | (0<<WGM10);              // T/C1 Control Register A: Fast PWM, TOP=ICRn, Update=BOTTOM, TOV Flag=TOP  

  TCCR1B |= (1<<WGM13)  | (1<<WGM12) | (0<<CS12) | (1<<CS11) | (0<<CS10);  // T/C1 Control Register B: Prescaler = CLKcpu / 8

  //TIMSK1 |= (1<<OCIE1A);

  ICR1  = 0xc34f;    // Output Compare Register 16-Bit = 50Hz  = 49999dec bzw.0xc34f

              // Output Compare Register 16-Bit = 1 kHz = 0x09c3

  OCR1A  = 0x0dde;    // Output Compare Register 16-Bit = 3750 = 1.5ms = 0x0ea6    ;0x0f09 = 3850

            // Init bei 1.42ms = 3550 = 0x0dde

            //

}

/***---------------------------------------timer2---------------------------------------------------------------***/

            /** TIMER2 Einstellungen und Register **/

void timer2_set(void){

  TCCR2A |= (0<<COM2A1) | (0<<COM2A0) | (0<<WGM21) | (0<<WGM20);  // T/C0 Control Register A: normaler Modus 

  TCCR2B |= (0<<WGM22) | (1<<CS22) | (1<<CS21) | (0<<CS20);       // Starte Timer2 mit clk/256 = 78.125kH ;clk/1024 = 19.53125kHz

  TIMSK2 |= (1<<TOIE2);                        // Fuer Interrupt Routine

}

/*===================================== U A R T - INTERFACE =========================================================*/

//USART - Initialisierung

void usart_init(void){

UBRR0H = UBRR_VAL >> 8;

UBRR0L = UBRR_VAL & 0xFF;

//test = UBRR_VAL;

UCSR0A = (0<<RXC0) | (0<<UDRE0) | (0<<U2X0);  //Double Speed Mode U2X0 = 1;

UCSR0B = (1<<RXCIE0) | (1<<RXEN0) | (1<<TXEN0); //Aktiviert Reciever und Transmitter

UCSR0C = (0<<UMSEL01) | (0<<UMSEL00) | (0<<UPM01) | (0<<UPM00) | (1<<UCSZ01) | (1<<UCSZ00);  //Festlegung des Frames: 1 Startbit, 8 Datenbits, 0x26,

                                              // 1 Paritätsbit even, 1 Stoppbit

}

//USART - Transmitter

//*/

int uart_putc(unsigned char c)

{

    while (!(UCSR0A & (1<<UDRE0)))  // warten bis Senden moeglich 

    {

    }                             

    UDR0 = c;                      // sende Zeichen 

    return 0;

}

// puts ist unabhaengig vom Controllertyp

void uart_puts(char *s)

{

    while (*s)

    {   // so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)"

        uart_putc(*s);

        s++;

    }

}

/*/

// USART - Receiver

/*/

uint8_t uart_getc(void)

{

    while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar

        ;

    return UDR0;                   // Zeichen aus UDR an Aufrufer zurueckgeben

}

//*/

/*=================================== U A R T - INTERFACE - STOPP ==================================================*/

/***---------------------------------------Start-Algorithmus---------------------------------------------------------------***/

volatile unsigned short start_algo(void){

  while(n == 0){        // Endlosschleife bis der Motor Initialsiert wurde und

                // hochgefahren ist

  }

}

/***---------------------------------------PWM_Verhaeltnis---------------------------------------------------------------***/

volatile unsigned short pwm_verhaeltnis(void){

Pegel = PINB & 0x02;    // Pegel = welchen Zustand hat der Pin gerade    

  if(Pegel != OldPegel){  // hat sich was veraender ?

              // wenn ja, dann war eine Flanke an diesem Pin

    if(Pegel){      // was war das fuer eine Flanke ?

                            // nachdem der Pin jetzt auf 1 ist, muss er

                            // vorher auf 0 gewesen sein, und das ganze

                            // war eine Flanke  0-> 1

          if (m < 1){ TCNT0 = 0x00; i=0; start_algo(); }  // Setze Timer0 auf Anfangswert da erste Flanke nach Start von uC gemessen.

                                  // Starte den Motor über den Start Algorithmus

          m=m+1;        // m = Merker

                    // bevor erste "High"Flanke gemessen m=0;

                    // ab erste "High" Flanke m=1

                    // bei zweiter "High" Flanke m=2 -> Periode zu Ende          

          if (m == 2){

            pwm_Gesamt = ((i<<8)+TCNT0);  // Gesamtzeit                    

            TCNT0 = 0x00;          // Setze Timer0 auf Anfangswert

            i=0;

            pwm_Verhaeltnis = ((pwm_Ein*100) / pwm_Gesamt) -2; //(pwm_Ein * ICR1) / pwm_Gesamt;

            OCR1A = (3850) + ((1150/100) * pwm_Verhaeltnis);

            //test = OCR1A;

            m=1;

                }

          }

    else{               // No, der Pin ist jetzt 0.

                                // also muss das eine Flanke 1 -> 0 gewesen sein  

      pwm_Ein = ((i<<8)+TCNT0);  // Einzeit

      }

  OldPegel = Pegel;          // jetzigen Zustand merken, damit im naechsten

                                // Durchgang wieder eine Veränderung festgestellt

                                // werden kann

  }  

return pwm_Verhaeltnis;          // Rueckgabewert

}

/***---------------------------------------Sensor_Verhaeltnis---------------------------------------------------------------***/

volatile unsigned short sensor_verhaeltnis(void){

if (counter>=305){        // 1 Sekunde: 20*10^6/256(Prescaler)*256(Schritte) = 305,175.. OVFs/sec = 3 bei 10ms

    sen_v= (j*100) / 417;    // 25.000 rpm = ca.417rps

    sen_rps = j;        // Umdrehungen / Sekunde

    counter=0;

    j=0;

          }

Puls = PINB & 0x04;

  if(Puls != OldPuls){

    if(Puls){

        }

    else{            // Flanke 1 -> 0  

      j++;

      }

  OldPuls = Puls;

  sensor_Verhaeltnis = sen_v;

  }

return sensor_Verhaeltnis;

}

/***---------------------------------------PID-Regler---------------------------------------------------------------***/

volatile unsigned short pid_regler(volatile float s_wert, volatile float i_wert){

/*

q0=Kp+Ki*Ta+Kd/Ta;            // Reglerfaktor q0

q1=-Kp-2*Kd/Ta;              // Reglerfaktor q1

q2=Kd/Ta;                // Reglerfaktor q2

e = s_wert - i_wert;          // Regler Differenz        

y = yalt + q0*e + q1*ealt + q2*ealt2;   // Berechnung des PID- Ausgangs

ealt2 = ealt;

ealt = e;

yalt = y;

*/

ausgang = y;

return ausgang;

}

void usart_drehzahl(volatile unsigned short rps){

  char s[7];

     int16_t l = rps;

     utoa( l, s, 10 ); // 10 fuer radix -> Dezimalsystem itoa = +/- .. utoa = +

     uart_puts( s );  

}

/***----------------------------------------main--------------------------------------------------------------***/

int main (void) {

  cli();                // INTERRUPT Enabled Bit OFF

  port_set();              // Initalisierung der Ports

  timer0_set();            // Initalisierung des Timer0

  timer1_set();            // Initalisierung des Timer1

  timer2_set();            // Initalisierung des Timer2  

  usart_init();            //USART initialsieren

  sei();                // INTERRUPT Enabled Bit ON

  OldPegel = PINB & 0x02;        // OldPegel = steigende Flanke an PB1

  OldPuls = PINB & 0x04;        // OldPuls  = steigende Flanke an PB

  while(1){

  soll_wert  = pwm_verhaeltnis();

  ist_wert  = sensor_verhaeltnis();

  //usart_drehzahl(ist_wert);

  //ausgang  = pid_regler(soll_wert, ist_wert);

  //OCR1A    = 3850 + (1150 * ausgang);        //(1150 * ausgang)+3850;// Anfangswert fuer Brushlessregler bei 1,54ms = 3850dec bzw. 0x0f0a  

                            // Der Bereich in dem das Tastverhaeltnis umgestellt werden kann,

  //PORTB ^= (1<<PB3);                 //TA analysieren fuer PID-Regler                          // liegt zwischen 1.54ms = 3850 und 2ms = 5000 also delta = 1150 = 100%    

      }              

}

/*** INTERRUPT TIMER0 ***/

ISR(TIMER0_OVF_vect){  

            i++;      // i zaehlt die OVFs    

          }

/*** INTERRUPT TIMER2 ***/

ISR(TIMER2_OVF_vect){  

  counter++;      // counter zaehlt die OVFs

  test++;

/* Startalgorythmus des BL Motors */

  if(test >= 4){

    test = 0;

    if( n!=1 ){  

    OCR1A = OCR1A+1;

    start = OCR1A;

    PORTB |= (1<<PB3);    

    }

  }

    if (start >= 0x0f6e){  

      //PORTB |= (1<<PB4);

      //PORTB ~= (1<<PB3);

      OCR1A  = 0x0f6e;

      n=1;

    }

}

//ISR-Recieve Complete

ISR( USART0_RX_vect ){

zeichen = uart_getc();

switch (zeichen){

  case'1':

      uart_putc(ist_wert);      //if(n<=>m){...}

  break;

  case'2':

        uart_putc(soll_wert);

  break;

  case'sprung':

  break;

        }

}

/*

// Zeiten fuer den Motor // 

   1.55ms = 3850 = f0a

   1.63ms = 4050 = fd2

   1.66ms = 4150 = 1036  

*/