Atmega162 im Simulator geht es, in der Hardware nicht

[Wolfgang (Gast)]

Hallo,

ich habe hier ein kleines Problem, bei dem ich nicht weiterkomme - 
vielleicht hat ja einer einen Denkanstoß für mich.

Also, ich will eine RGB-Led so richtig schön mit Übergängen ansteuern 
und habe mir dafür an Timer2 und Timer3 je an die OCRs einen FET mit 
jeweiligen Farbe drangebaut. Die Timer betreibe ich mit 8 Bit (der 
Timer2 kann eh nicht mehr), normaler FastPWM, die OCR sind auch gemappt. 
Wenn ich einen Wert in das OCR-Register schreibe, kommt aus der Hardware 
auch sauber die PWM raus.

Dann habe ich mir eine Interpolatorroutine gebaut, die zwischen zwei 
RGB-Werten linear interpoliert und die ich alle 20ms aufrufe. Den 
Interpolationswert schreibe ich dann in die OCR-Register. Das kann ich 
am Simulator wunderbar nachvollziehen - es fällt der richtige Wert aus 
der Routine raus, die OCR2 bzw. OCR3AL und OCR3BL stehen richtig und 
wandern auch brav bei jedem Durchlauf mit.

Lade ich aber das in die Hardware, kommt immer Fullscale raus. Zum 
Gegencheck habe ich mal das Rechenergebnis einfach mit 7F maskiert - ja, 
dann kommt halt 7F raus, maskiere ich anders, ja es kommt so raus. Auch 
die 20ms habe ich überprüft - alles okay - es ist einfach das 
Rechenergebnis nicht mit dem Simulator konform. Ach ja, Data Space 
(Stack) ist noch genug da.  (AVR GCC, 37% Data usage)

 Irgendwie begreife ich das nicht. Im Simulator ist alles paletti, die 
Hardware funktioniert (ich kann 'zu Fuß' PWM-Werte ausgeben), aber das 
Interpolationsergebnis scheint immer 0xFF zu sein. Gibt es da ev. 
Errata, die man kennen sollte?

Den Code poste ich mal noch nicht, ist etwas umfangreicher.

Frustriert ... Wolfgang

[holger (Gast)]

>Den Code poste ich mal noch nicht, ist etwas umfangreicher.

Dann lass es halt bleiben und such selber den Fehler.

[Wolfgang (Gast)]

Okay, dann beginnen wir mal, hier init und Hardwarezugriff:

void init_rgb_timer(void)
  {
    // Init Timer2 as Fast PWM with a CLKDIV (prescaler) of 64

    #define T2_PRESCALER   64    // may be 1, 8, 32, 64, 128, 256, 1024
    #if   (T2_PRESCALER==1)
        #define T2_PRESCALER_BITS   ((0<<CS22)|(0<<CS21)|(1<<CS20))
    #elif (T2_PRESCALER==8)
        #define T2_PRESCALER_BITS   ((0<<CS22)|(1<<CS21)|(0<<CS20))
    #elif (T2_PRESCALER==32)
        #define T2_PRESCALER_BITS   ((0<<CS22)|(1<<CS21)|(1<<CS20))
    #elif (T2_PRESCALER==64)
        #define T2_PRESCALER_BITS   ((1<<CS22)|(0<<CS21)|(0<<CS20))
    #elif (T2_PRESCALER==128)
        #define T2_PRESCALER_BITS   ((1<<CS22)|(0<<CS21)|(1<<CS20))
    #elif (T2_PRESCALER==256)
        #define T2_PRESCALER_BITS   ((1<<CS22)|(1<<CS21)|(0<<CS20))
    #elif (T2_PRESCALER==1024)
        #define T2_PRESCALER_BITS   ((1<<CS22)|(1<<CS21)|(1<<CS20))
    #else
        #error void value T2_PRESCALER
    #endif

    TCCR2 = (0 << FOC2)        // Timer2: fastpwm
          | (1 << WGM20)       // wgm = 00: normal mode, top=0xff
          | (1 << COM21)       // COMx1,COMx0 = 00: normal mode, pin operates as usual
          | (0 << COM20)       // COMx1,COMx0 = 10: compare match: set OC2 at TOP. clear at OCR
                               // COMx1,COMx0 = 11: compare match: clear OC2 at TOP. set at OCR
                               // 
          | (1 << WGM21)       // 
          | T2_PRESCALER_BITS; 

    TCNT2 = 0;

    // Init Timer3 as Fast PWM with a CLKDIV (prescaler) of 64

    #define T3_PRESCALER   64   // may be 1, 8, 16, 32, 64, 256, 1024
    #if   (T3_PRESCALER==1)
        #define T3_PRESCALER_BITS   ((0<<CS32)|(0<<CS31)|(1<<CS30))
    #elif (T3_PRESCALER==8)
        #define T3_PRESCALER_BITS   ((0<<CS32)|(1<<CS31)|(0<<CS30))
    #elif (T3_PRESCALER==16)
        #define T3_PRESCALER_BITS   ((1<<CS32)|(1<<CS31)|(0<<CS30))
    #elif (T3_PRESCALER==32)
        #define T3_PRESCALER_BITS   ((1<<CS32)|(1<<CS31)|(1<<CS30))
    #elif (T3_PRESCALER==64)
        #define T3_PRESCALER_BITS   ((0<<CS32)|(1<<CS31)|(1<<CS30))
    #elif (T3_PRESCALER==256)
        #define T3_PRESCALER_BITS   ((1<<CS32)|(0<<CS31)|(0<<CS30))
    #elif (T3_PRESCALER==1024)
        #define T3_PRESCALER_BITS   ((1<<CS32)|(0<<CS31)|(1<<CS30))
    #else
        #error void value T3_PRESCALER
    #endif

    // FastPWM, 8 Bit = Mode 5: WGM3 = 0101

    TCCR3A = (1 << COM3A1)          // compare match A
           | (0 << COM3A0)          // 
           | (1 << COM3B1)          // compare match B
           | (0 << COM3B0) 
           | (0 << FOC3A)
           | (0 << FOC3B)
           | (0 << WGM31)  
           | (1 << WGM30);  
    TCCR3B = (0 << ICNC3) 
           | (0 << ICES3) 
           | (0 << WGM33) 
           | (1 << WGM32) 
           | (T3_PRESCALER_BITS);   // clkdiv

    TCNT3 = 0;
  }

unsigned char RED;     // mirror, fuer den Simulator
unsigned char GREEN;
unsigned char BLUE;

// hardware access, values given from 0..255

void set_R(unsigned char red_value)
  {
    OCR3AL = red_value;
    RED = red_value;
  }

void set_G(unsigned char green_value)
  {
    OCR2 = green_value;
    GREEN = green_value;
  }

void set_B(unsigned char blue_value)
  {
    OCR3BL = blue_value;
    BLUE = blue_value;
  }

[Wolfgang (Gast)]

Und dann die Routine, welche die Interpolation macht:

#define SIZE_RGB_FADE      24         // number of entries (triples) in one control

typedef struct    // fade values, normalized [0..255]
      {
        unsigned char time;       
        unsigned char red;            
        unsigned char green;            
        unsigned char blue;            
      } t_rgb_point;

t_rgb_point farbkreis[] PROGMEM = 
  {
   // time, r, g, b
    {   0 , 255 ,   0 ,   0 },
    {   1 , 255 , 255 ,   0 },
    {   2 ,   0 , 255 ,   0 },
    {   3 ,   0 , 255 , 255 },
    {   4 ,   0 ,   0 , 255 },
    {   5 , 255 ,   0 , 255 },
    {   6 , 255 ,   0 ,   0 },
    {   0 ,   0 ,   0 ,   0 },              // end of list: time = 0
  };

t_rgb_point *pre_def_fades[] =
  {
    farbkreis,                              //  0: farbkreis
  };

t_rgb_point rgb_fade[SIZE_RGB_FADE]; 

typedef struct
  { 
    unsigned char redmax;               // upper  limit [0..255]
    
    unsigned char greenmax;               // upper  limit [0..255]
    
    unsigned char bluemax;               // upper  limit [0..255]
    
    unsigned char control;      

    unsigned char repeat;           // if REPEAT: this is the number of repeats to do

    unsigned char fade_index;      // points to actual target in curve

    t_rgb_point *fade;           // fading curve, normalized [0..255]
      
    unsigned int active_time;       // runtime: relative time to start point
                                    // 0        = restart Servos
                                    // 0xffff   = finished

    unsigned char time_ratio;       // ratio between runtime and curve time
  } t_rgb_ctrl;

t_rgb_ctrl rgb_ctrl =
  {     255,            // unsigned char redmax; 
        255,            // unsigned char greenmax; 
        255,            // unsigned char bluemax; 
          0,            // unsigned char control;
          0,            // unsigned char repeat;
          1,            // unsigned char fade_index;
      rgb_fade,     // pointer to curve
          0,            // active time
          1,            // ratio of curve
  };


//------------------------------------------------------------------------------
//
#define CALC_GAIN  128L            // 2 bis 128; 128 ist obere Grenze wegen möglichen Überlauf

void calc_rgb_next_val(void)
  {
    unsigned char myindex;        // index in curve
    int16_t posi;
    int16_t dt, delta_t;          // time delta always > 0
    int32_t posl;
    int16_t delta_pos;
    unsigned char end_of_list_reached = 0;

    if (rgb_ctrl.active_time == 0xFFFF) return;    // inactive - do nothing

    rgb_ctrl.active_time++;
    
    // check, if next curve point is reached
    myindex = rgb_ctrl.fade_index;
    
    if ((rgb_ctrl.fade[myindex].time * rgb_ctrl.time_ratio) == rgb_ctrl.active_time)
      {
        myindex++;
        // new curve point reached, how to proceed?
        if (rgb_ctrl.fade[myindex].time == 0)
          {
            // end of list
            end_of_list_reached = 1;
            myindex--;                    // stay on last curve point             
          }
        else
          {
            rgb_ctrl.fade_index = myindex;        // save index
          } 
      }

    // now calc linear interpolation
    // val = val_prev + (dt / delta_t) * (val - val_prev)

    dt = rgb_ctrl.active_time - (int)rgb_ctrl.fade[myindex-1].time * rgb_ctrl.time_ratio;   // int

    delta_t = (int)(rgb_ctrl.fade[myindex].time - rgb_ctrl.fade[myindex-1].time)            // int
              *  rgb_ctrl.time_ratio;

    if (delta_t == 0) delta_t = 1;  // avoid div0 (this is dirty)

    //---->  make red

    delta_pos = ((int)rgb_ctrl.fade[myindex].red
                 - (int)rgb_ctrl.fade[myindex-1].red)   
                * CALC_GAIN;    
    posl = (int32_t)delta_pos * dt;
        
    posl = posl / delta_t;                                        
    posl = posl + (int)rgb_ctrl.fade[myindex-1].red * CALC_GAIN; 
                                                                  
    // scale this fade value according to max volume
    // scaled = interpolated * max

    posl = posl * rgb_ctrl.redmax;      

    // now scale to timer

    posl = posl / 256;
    posi = posl / CALC_GAIN;
                                          // range 0 ... 256
    set_R(posi);
    // die anderen Farben schenke ich mir hier
  }

Und der Aufruf ist dann:

void do_rgb_fade(void)
  {
    rgb_ctrl.redmax = my_eeprom_read_byte(&CV.REDmax);
    rgb_ctrl.greenmax = my_eeprom_read_byte(&CV.GREENmax);
    rgb_ctrl.bluemax = my_eeprom_read_byte(&CV.BLUEmax);
    
    rgb_copy_fade(my_eeprom_read_byte(&CV.RGB_profile));
    rgb_ctrl.time_ratio = my_eeprom_read_byte(&CV.RGB_time);
    rgb_ctrl.fade_index = 1;
    rgb_ctrl.active_time = 0;
    rgb_ctrl.repeat = my_eeprom_read_byte(&CV.RGB_repeat);
    rgb_ctrl.control = 0;    
    set_R(0);   //   red_value
    set_G(0);  //   green_value;
    set_B(0);  //   blue_value;
  }

Und dann wird alle 20ms calc_rgb_next_val(); aufgerufen.

Servus Wolfgang

[soundso (Gast)]

libm eingebunden?

du machst hier Rechnungen mit Multiplikationen und Divisionen ...

und falls jetzt kommt da sind keine floats drin:

#define CALC_GAIN 128L ist ein float ...

gruss

[Karl H. (kbuchegg)]

soundso schrieb:
> libm eingebunden?
>
> du machst hier Rechnungen mit Multiplikationen und Divisionen ...
>
> und falls jetzt kommt da sind keine floats drin:
>
> #define CALC_GAIN 128L ist ein float ...

Seit wann?

@Wolfgang

EEPROM hast du gebrannt?

Ansonsten: Konzentrier dich auf die 20ms. Die Berechnungen laufen auf 
dem µC auch nicht anders als auf dem Simulator. Du hast doch in beiden 
Fällen identische Optimizer-Einstellungen?
Dem Simulator sind deine Berechnungen wurscht, der arbeitet nur 
Assembler Instruktionen ab, genauso wie der µC. Da kommt im Simulator 
dasselbe raus, wie auf dem µC. Timing ist aber eine andere Sache, das 
kann abweichen, zb wenn im Simulator falsche Takteinstellungen gemacht 
sind.

[Wolfgang K. (opendcc)]

Hallo,

ich ziehe

#include <stdlib.h>
#include <stdbool.h>
#include <inttypes.h>

 rein.

128L ist doch ein Long, oder?

Servus Wolfgang

[Wolfgang K. (opendcc)]

Hallo,

> Ansonsten: Konzentrier dich auf die 20ms.

Hatte ich auch schon in Verdacht, habe daher einfach mal 
set_R(my_static_i++) reingehängt - und die LED dimmt in 5sec einmal rum; 
5 sec = 256/20ms, paßt.

> Du hast doch in beiden Fällen identische Optimizer-Einstellungen?

Ja, und EEPROM ist auch geladen. Das werde ich aber nochmal zur Probe 
rücklesen und das eep file genau ansehen.

Servus Wolfgang

[spess53 (Gast)]

Hi

>Ja, und EEPROM ist auch geladen. Das werde ich aber nochmal zur Probe
>rücklesen und das eep file genau ansehen.

Und EESAVE-Fuse setzen.

MfG Spess

[Karl H. (kbuchegg)]

Hast du irgendeine Möglichkeit für die Ausgabe?
LCD, UART?

[Wolfgang K. (opendcc)]

Hallo,

LCD und UART ist keiner dran, die Zielplatine ist recht minimalistisch 
und klein. UART könnte ich mal nachverdrahten und über ein FTDI-Kabel 
mal ein bischen printf machen - Danke für den Hinweis.

Servus Wolfgang

[Karl H. (kbuchegg)]

Ansonsten fällt mir nur noch ein;

Abspecken. Du hast einen Fehler gemacht: Zuviel Code geschrieben ohne 
ihn auf der realen Hardware zwischendurch immer wieder zu testen.

[Wolfgang (Gast)]

Hallo,

und heute des Rästels Lösung: der ISP war einen Tick zu schnell - ich 
habe den AVRmkII auf langsamere Speed gestellt, et voila, es dimmt. 
Danke nochmals für die Denkanstöße.

Übrigens, obige Rumrechnerei habe ich bereits bei der Servoansteuerung 
drin - um mit Integer etwas Auflösung hinzuzaubern, muß man das einfach 
ein bischen hochskalieren.

Servus Wolfgang, www.opendcc.de