Programm vom Atmega 16 auf Atmega 1284P

[Steffen H. (stef_fen)]

Hallo Zusammen,

ich möchte gerne mein Programm vom Atmega 16 auf dem Atmega 1284P 
verwenden da er 2 16Bit Timer und 2 8 Bit Timer hat. Der Timer 1 liest 
über den ICP Pin ein PWM Signal von einer RC-Fernsteuerung ein und der 
Timer 3 soll ein PWM Signal erzeugen und damit einen Mosfettreiber 
steuern.

//Bibliotheken einbinden
#define F_CPU 8000000
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include "lcd-routines.h"
#include <stdlib.h>
#include <util/delay.h>

//Pinbelegung
#define MosfetDriver1_PORT  PORTD  //OC2
#define MosfetDriver1_DDR  DDRD
#define MosfetDriver1_DB  PB6
#define MosfetDriver2_PORT  PORTC
#define MosfetDriver2_DDR  DDRC
#define MosfetDriver2_DB  PC0
#define Stick_PORT      PORTD  //ICP1
#define Stick_PIN      PIND
#define Stick_DDR      DDRD
#define Stick_DB      PD6
#define Taster1_PORT    PORTC  
#define Taster1_PIN      PINC  
#define Taster1_DDR      DDRC
#define Taster1_DB      PC0
#define Taster2_PORT    PORTC
#define Taster2_PIN      PINC
#define Taster2_DDR      DDRC
#define Taster2_DB      PC1
#define LEDRot_PORT      PORTB
#define LEDRot_DDR      DDRB
#define LEDRot_DB      PB0
#define LEDGruen_PORT    PORTB
#define LEDGruen_DDR    DDRB
#define LEDGruen_DB      PB1

//Variablendeklaration
uint16_t eeunten EEMEM;          //fuer EEPROM
uint16_t unten;              //fuer EEPROM
uint16_t eeoben EEMEM;          //fuer EEPROM
uint16_t oben;              //fuer EEPROM
uint16_t eebrake EEMEM;          //fuer EEPROM
uint16_t brake;              //fuer EEPROM
int flanke;                //fuer Stick
uint16_t flankeStart;          //fuer Stick
volatile uint16_t stick;        //fuer Stick (volatile = Global gueltig)
float deltaStick;            //fuer Stick
float rechenwert;            //fuer Stick
int sollwert;              //fuer Stick
volatile uint8_t currentOverload = 0;  //fuer currentOverload
uint16_t voltage;            //fuer voltage
uint16_t overTemperature;        //fuer overTemperature
int lcdpwm;                //fuer LCD
char Buffer[20];            //fuer LCD

ISR(TIMER1_CAPT_vect) {
  if (flanke==0) {
    flankeStart = ICR1;
    TCCR1B &= ~(1<<ICES1); // fallende Flanke zur Auswertung des ICP
    flanke = 1;
  }
  else {
    stick = ICR1 - flankeStart;
    flanke = 0;
    TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  }
  TIFR1 = ( 1 << ICF1 );  
}

ISR(ANA_COMP_vect) {
  if bit_is_clear(ACSR, ACO) {
    currentOverload = 1;
  }
  else {
    currentOverload = 0;
  }
}

void PWM_Mosfet(void) {
  /*Initialisierung fuer PWM ausgeben an Mosfet Treiber
  PWM = Prozessorgeschwindigkeit / (Prescaler * 256)
  PWM = 8000000 / (8 * 256) = 3906,25Hz = 3,9kHz*/
  MosfetDriver1_DDR |= (1 << MosfetDriver1_DB);  //Motor OC2 = Ausgang
  OCR3A = 0;                    //von 0 bis 256 einstellbar
  TCCR3A |= (1 << COM3A1);            //normaler Modus
  TCCR3A |= (1 << WGM31) | (1 << WGM30);      //fast PWM
  TCCR3B |= (1 << CS31);              //Prescaler Clock/8
}

void PWM_Empfaenger(void) {
  TCCR1B |= (1<<ICES1);        //steigende Flanke zur Auswertung des ICP
  TCCR1B |= (1<<CS11) | (1<<CS10);  //Quelle für Timer/Counter = CPU-Takt/64
  TIMSK1 |= (1<<ICIE1);        //Capture Interrupt Enable
  Stick_DDR &= ~(1<<Stick_DB);    //Impuls von Fernsteuerung ICP1 = Eingang
  Stick_PORT |= (1<<Stick_DB);    //Pullup aktiviert
}

void Strommessung(void) {
  ACSR |= (0 << ACD);            //Comparator ein
  ACSR |= (1 << ACBG);          //interne Referenzspannung (1,3 Volt)
  ACSR |= (1 << ACI);            //kann fuer Abfragen genutzt werden
  ACSR |= (1 << ACIE);          //löst Interrupt aus
  ACSR |= (0 << ACIC);          //verbindet Comparatorausgang mit Counter 1
  ACSR |= (0 << ACIS1) | (0 << ACIS0);  //Interrupt auslösen bei jedem Flankenwechsel
}

void StickWay(void) {
  if(!(Taster1_PIN & (1 << Taster1_DB))) {
    LEDGruen_PORT |= (1 << LEDGruen_DB);
    LEDRot_PORT |= (1 << LEDRot_DB);
    while(1) {
        _delay_ms(3000);
        unten = stick + 2;            //incl. Korrekturfaktor
        lcdpwm = unten;
        lcd_clear();
        itoa(lcdpwm, Buffer, 10);
        lcd_string(Buffer);
        eeprom_write_word (&eeunten, unten);
        _delay_ms(3000);
        LEDRot_PORT &= ~(1 << LEDRot_DB);
        _delay_ms(3000);
        oben = stick - 2;            //incl. Korrerkturfaktor
        eeprom_write_word (&eeoben, oben);
        _delay_ms(3000);
        LEDGruen_PORT &= ~(1 << LEDGruen_DB);
        break;
    }
  }  
}

void OptionalBrake (void) {
  if(!(Taster2_PIN & (1 << Taster2_DB))) {
    LEDGruen_PORT |= (1 << LEDGruen_DB);
    LEDRot_PORT |= (1 << LEDRot_DB);
    brake = eeprom_read_word (&eebrake);
    if (brake == 1) {
      brake = 0;
    }
    else {
      brake = 1;
    }
    eeprom_write_word (&eebrake, brake);
    _delay_ms(3000);
    LEDRot_PORT &= ~(1 << LEDRot_DB);
    LEDGruen_PORT &= ~(1 << LEDGruen_DB);
  }
}

void EepromRead(void) {
  unten = eeprom_read_word (&eeunten);
  oben = eeprom_read_word (&eeoben);
  brake = eeprom_read_word (&eebrake);
  unten = 1100;
  oben = 1900;
  deltaStick = oben - unten;
  if (deltaStick == 0) {
    while(1) {
      LEDRot_PORT |= (1 << LEDRot_DB);
      LEDGruen_PORT |= (1 << LEDGruen_DB);
    }
  }
  deltaStick = 512 / deltaStick;
}

void WaitForUserReady(void) {
  LEDGruen_PORT &= ~(1 << LEDGruen_DB);
  LEDRot_PORT |= (1 << LEDRot_DB);
  while(stick != unten);
  MosfetDriver2_PORT |= (1 << MosfetDriver2_DB);
  LEDRot_PORT &= ~(1 << LEDRot_DB);
  LEDGruen_PORT |= (1 << LEDGruen_DB);
}

void InputOutput(void) {
  MosfetDriver2_DDR |= (1 << MosfetDriver2_DB);  //SD Pin IR2184 Mosfet Treiber
  Taster1_DDR &= ~(1 << Taster1_DB);        //Taster 1
  Taster1_PORT |= (1 << Taster1_DB);        //Pullup fuer Taster 1
  Taster2_DDR &= ~(1 << Taster2_DB);        //Taster 2
  Taster2_PORT |= (1 << Taster2_DB);        //Pullup fuer Taster 2
  LEDRot_DDR |= (1 << LEDRot_DB);          //Rote LED
  LEDGruen_DDR |= (1 << LEDGruen_DB);        //Gruene LED
}  

void ADC_Init(void) {
  uint16_t result;
  ADMUX = (1<<REFS1) | (1<<REFS0);    //interne Referenzspannung (2,56V)
  ADCSRA = (1<<ADPS2) | (1<<ADPS1);     // Frequenzvorteiler, Dummyreadout
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC)) {      // auf Abschluss der Konvertierung warten
  }
  result = ADCW;
}
 
uint16_t ADC_Read(uint8_t channel) {
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F); //Kanal waehlen, ohne andere Bits zu beeinflußen
  ADCSRA |= (1<<ADSC);              //eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {          //auf Abschluss der Konvertierung warten
  }
  return ADCW;
}
 
int main (void) {
  sei();          //erlaubt globale Interrupts
  lcd_init();
  lcd_clear();
  lcd_string("Regler");
  PWM_Empfaenger();
  PWM_Mosfet();
  Strommessung();
  InputOutput();
  StickWay();
  //OptionalBrake();
  EepromRead();
  WaitForUserReady();
  ADC_Init();
  
  while(1) {  
    if(currentOverload == 1) {
      OCR3A = 0;
      MosfetDriver2_PORT &= ~(1 << MosfetDriver2_DB);
      WaitForUserReady();
    }
    overTemperature = ADC_Read(1);
    if (overTemperature >= 250) {
      OCR3A = 0;
      MosfetDriver2_PORT &= ~(1 << MosfetDriver2_DB);
      WaitForUserReady();  
    }
    else {
      voltage = ADC_Read(0);
      if (voltage <= 125)
      {
        break;
      }
      rechenwert = stick - unten;
      rechenwert = rechenwert * deltaStick;
      sollwert = rechenwert;
      if(stick >= oben) {
        sollwert = 512;  
      }
      if(stick <= unten) {
        sollwert = 0;
      }
      if (voltage <= 250) {
        if (sollwert >= 127) {
          sollwert = 127;
        }
      }
      OCR3A = sollwert;
    }
  }
  while(1) {
    OCR3A = 0;
    MosfetDriver2_PORT &= ~(1 << MosfetDriver2_DB);
    LEDGruen_PORT &= ~(1 << LEDGruen_DB);
    LEDRot_PORT |= (1 << LEDRot_DB);
  }
  return 0;
}

Vorher stand in der Funktion:

void PWM_Mosfet(void)
{
  /*Initialisierung fuer PWM ausgeben an Mosfet Treiber
  PWM = Prozessorgeschwindigkeit / (Prescaler * 256)
  PWM = 8000000 / (8 * 256) = 3906,25Hz = 3,9kHz*/
  DDRD |= (1 << PD7); // Motor (OC2 => PD7) = Ausgang
  OCR2 = 0; // von 0 bis 255 einstellbar
  TCCR2 |= (1 << COM21); // normaler Modus (für invertierenden Modus | (1 << COM20))
  TCCR2 |= (1 << WGM21) | (1 << WGM20); // fast PWM
  TCCR2 |= (1 << CS21); // Prescaler Clock/8
}

void PWM_Empfaenger(void)
{
  //Initialisierung fuer PWM einlesen vom Empfänger
  TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  TCCR1B |= (1<<CS11) | (1<<CS10); //Quelle für Timer/Counter = CPU-Takt/64
  TIMSK |= (1<<TICIE1); //Capture Interrupt Enable
  DDRD &= ~(1<<PD6); // Impuls von Fernsteuerung (ICP1 => PD6) = Eingang
  PORTD |= (1<<PD6); //Pullup aktiviert
}

In der ISR(ANA_COMP_vect) scheint auch irgendetwas nicht mehr zu 
stimmen. Muss das jetzt ISR(ANALOG_COMP_vect) heißen? Aber warum? Auch 
bei den Ports defines oben im Programm ist (#define MosfetDriver1_DB 
PB6) z.B. das PB6 nicht mehr lila hinterlegt im Atmel Studio 6.

[Knut B. (Firma: TravelRec.) (travelrec)]

Bitte lies die Datenblätter der beiden Controller und schau mal in die 
Device-Files. Dort haben sich sicher Namen und Positionen von Registern 
und Bits geändert. Das ist immer so, wenn man von einem (alten) 
kleineren Chip auf einen (neueren) großen portiert.

[Steffen H. (stef_fen)]

Aber warum wird bei den Ports defines oben im Programm (#define 
MosfetDriver1_DB PB6) z.B. das PB6 nicht mehr lila hinterlegt im Atmel 
Studio 6? Wenn ich den Device Atmega 16 auswähle ist es wieder so, 
ändere ich ihn wieder zurück ist er schwarz.

[Karl H. (kbuchegg)]

Entscheidend ist nicht, ob das Syntax-Highlighting deines Editors ein 
bestimmtes Wort, auf welches es konditioniert wurde, lila, grün blau 
oder rot einfärbt, entscheidend ist, ob der µC den Portpin hat und ob 
der Compiler ihn kennt.

[nix (Gast)]

Steffen Ha schrieb:
> das PB6 nicht mehr lila hinterlegt im Atmel
> Studio 6

Ich verwende den Atmega1284P nun schon ein halbes Jahr und bin ebenfalls 
vom 16er gewechselt...bei mir markiert er sie auch nicht mehr, ABER es 
funktioniert trotzdem:)

[Steffen H. (stef_fen)]

Jetzt habe ich mal nur den oberen Teil des Programmes, also das einlesen 
des PWM Signals von der Fernsteuerung getestet.

Beim Atmega 16 habe ich eine Taktfrequenz von 8MHz (externem 
Quarzoszillator) und einem Prescaler von 8:

((8*10^6 Hz) / 8)^-1 = 1us * 1900 (zeigt das Display an) = 1900us = 
1,9ms was der oberen Knüppelposition der Fernsteuerung entspricht.

Beim Atmega 1284P habe ich auch eine Taktfrequenz von 8MHz (externem 
Quarzoszillator) und einem Prescaler von 8):

Da zeigt mir das Display aber nur 238 * 1us wären ja nur 238us.

Auch die Zeit für das _delay_ms kommt mir viel länger vor und die 
Einstellungen für die Fuses die mir das Atmel Studio im Vergleich zum 
Atmega 16 bietet sind auch komisch. Beim internen Oszillator steht nur 
etwas von kHz aber nicht von MHz.

[Karl H. (kbuchegg)]

Schalte die CKDIV8 Fuse aus.


Es hilft nichts:
Du MUSST die jeweiligen Datenblätter STUDIEREN. Auch wenn dir das nicht 
gefällt.

[Electronics'nStuff (Gast)]

Und es gibt einen praktischen Knopf auf deiner Tastatur, der nennt sich 
"PrtScn" oder ähnlich.

Dann musst du deinen Bildschirm nicht mehr fotografieren.

[Steffen H. (stef_fen)]

Ich habe mir jetzt erst mal ein kleines Testprogramm gemacht. Die 
Funktion zum einlesen des PWM Signals vom Empfänger funktioniert aber 
nur wenn ich den Teil des PWM Signals für den Mosfet ausklammere. Nehme 
ich den Teil dazu zeigt er mir auf dem Display nur eine Null. Ich habe 
mir das Datenblatt mal angeschaut. Aber ich kann nichts finden.

//Bibliotheken einbinden
#define F_CPU 8000000
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include "lcd-routines.h"
#include <stdlib.h>
#include <util/delay.h>

//Pinbelegung
#define MosfetDriver1_PORT  PORTD  //OC2
#define MosfetDriver1_DDR  DDRD
#define MosfetDriver1_DB  PB6
#define MosfetDriver2_PORT  PORTC
#define MosfetDriver2_DDR  DDRC
#define MosfetDriver2_DB  PC0
#define Stick_PORT      PORTD  //ICP1
#define Stick_PIN      PIND
#define Stick_DDR      DDRD
#define Stick_DB      PD6

//Variablendeklaration
int flanke;                //fuer Stick
uint16_t flankeStart;          //fuer Stick
volatile uint16_t stick;        //fuer Stick (volatile = Global gueltig)
float deltaStick;            //fuer Stick
float rechenwert;            //fuer Stick
int sollwert;              //fuer Stick
volatile uint8_t currentOverload = 0;  //fuer currentOverload
uint16_t voltage;            //fuer voltage
uint16_t overTemperature;        //fuer overTemperature
int lcdpwm;                //fuer LCD
char Buffer[20];            //fuer LCD

ISR(TIMER1_CAPT_vect) {
  if (flanke==0) {
    flankeStart = ICR1;
    TCCR1B &= ~(1<<ICES1); // fallende Flanke zur Auswertung des ICP
    flanke = 1;
  }
  else {
    stick = ICR1 - flankeStart;
    flanke = 0;
    TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  }
  TIFR1 = ( 1 << ICF1 );  
}

void PWM_Empfaenger(void) {
  TCCR1B |= (1<<ICES1);        //steigende Flanke zur Auswertung des ICP
  TCCR1B |= (1<<CS11);        //Quelle für Timer/Counter = CPU-Takt/8
  TIMSK1 |= (1<<ICIE1);        //Capture Interrupt Enable
  Stick_DDR &= ~(1<<Stick_DB);    //Impuls von Fernsteuerung ICP1 = Eingang
  Stick_PORT |= (1<<Stick_DB);    //Pullup aktiviert
}

void PWM_Mosfet(void) {
  /*Initialisierung fuer PWM ausgeben an Mosfet Treiber
  PWM = Prozessorgeschwindigkeit / (Prescaler * 256)
  PWM = 8000000 / (8 * 1023) = 3906,25Hz = 3,9kHz*/
  MosfetDriver1_DDR |= (1 << MosfetDriver1_DB);  //Motor OC2 = Ausgang
  OCR3A = 0;                    //von 0 bis 256 einstellbar
  TCCR3A |= (1 << COM3A1) | (1 << WGM31) | (1 << WGM30);      //normaler Modus & fast PWM
  TCCR3B |= (1 << WGM32) | (1 << CS31);              //fast PWM & Prescaler Clock/8
}

void InputOutput(void) {
  MosfetDriver2_DDR |= (1 << MosfetDriver2_DB);  //SD Pin IR2184 Mosfet Treiber
  Taster1_DDR &= ~(1 << Taster1_DB);        //Taster 1
  Taster1_PORT |= (1 << Taster1_DB);        //Pullup fuer Taster 1
  Taster2_DDR &= ~(1 << Taster2_DB);        //Taster 2
  Taster2_PORT |= (1 << Taster2_DB);        //Pullup fuer Taster 2
  LEDRot_DDR |= (1 << LEDRot_DB);          //Rote LED
  LEDGruen_DDR |= (1 << LEDGruen_DB);        //Gruene LED
}

int main (void) {
  sei();          //erlaubt globale Interrupts
  InputOutput();
  PWM_Empfaenger();
  PWM_Mosfet();
  lcd_init();
  lcd_clear();
  lcd_string("Regler");
  MosfetDriver2_PORT |= (1 << MosfetDriver2_DB);
  _delay_ms(1000);
  
  while(1) {
  lcd_clear();
  lcd_string("PWM");
  lcd_setcursor(0, 2);
  lcdpwm = stick;
  itoa(lcdpwm, Buffer, 10);
  lcd_string(Buffer);  
  _delay_ms(50);
  OCR3A = 50;
    
  }
  return 0;
}

[Karl H. (kbuchegg)]

Da kann was nicht stimmen

> #define MosfetDriver1_PORT  PORTD  //OC2
> #define MosfetDriver1_DDR  DDRD
> #define MosfetDriver1_DB  PB6

> #define Stick_PORT      PORTD  //ICP1
> #define Stick_PIN      PIND
> #define Stick_DDR      DDRD
> #define Stick_DB      PD6

Der Eingang vom RC-Empfänger kann nicht am Port D / Pin 6 liegen, wenn 
da gleichzeitig der Ausgang vom Mosfet Driver liegt. (Oder umgekehrt)

Irgendeine der beiden Angaben muss falsch sein.