AVR "ret" springt zu 0x00

[Hugo P. (portisch)]

Hallo,

ich habe ein Problem mit der MCP2515 CAN lib vom kreatives-chaos.

Und zwar mache ich das CAN Init:

InitCANBus(BITRATE_10_KBPS, can_filter);

void InitCANBus(uint8_t bitrate, const prog_uint8_t *filter)
{
  
  // init can buffer
  memset(&can_buffer, 0x00, sizeof(CAN_BUFFER));
    
  can_init(bitrate);                      // Initialize MCP2515
  can_static_filter(filter);                  // Load filters and masks  
}

Nun habe ich mir das in Assembler angesehen (mit MKII per DebugWIRE):

  sei();                                // global interrupt enable  
0000008F  SEI     Global Interrupt Enable 
  InitCANBus(BITRATE_10_KBPS, can_filter);
00000090  LDI R22,0x00    Load immediate 
00000091  LDI R23,0x01    Load immediate 
00000092  LDI R24,0x00    Load immediate 
00000093  CALL 0x000004CC    Call subroutine

Die Funktion selbst:

--- H:\Data\AVR\AVR_7.0_09022016\AVR_CAN\Debug/../global/can_transfer.c --------
{
000004CC  PUSH R28    Push register on stack 
000004CD  PUSH R29    Push register on stack 
000004CE  MOVW R28,R22    Copy register pair 
  memset(&can_buffer, 0x00, sizeof(CAN_BUFFER));
000004CF  LDI R25,0xB5    Load immediate 
000004D0  LDI R30,0xCC    Load immediate 
000004D1  LDI R31,0x03    Load immediate 
000004D2  MOVW R26,R30    Copy register pair 
000004D3  ST X+,R1    Store indirect and postincrement 
000004D4  DEC R25    Decrement 
000004D5  BRNE PC-0x02    Branch if not equal 
  can_init(bitrate);                      // Initialize MCP2515
000004D6  CALL 0x000001BD    Call subroutine 
  can_static_filter(filter);                  // Load filters and masks  
000004D8  MOVW R24,R28    Copy register pair 
000004D9  CALL 0x00000334    Call subroutine 
}
000004DB  POP R29    Pop register from stack 
000004DC  POP R28    Pop register from stack 
000004DD  RET     Subroutine return

Nach 0x4DD wenn ich mit F10 ein Step Over mache springt der AVR auf 
0x00:

--- No source file -------------------------------------------------------------
00000000  JMP 0x0000003A    Jump

Somit gibt das eine Endlosschleife. Wie komme ich nun dem Problem auf 
die Spur? In welchen Register steht die Adresse wo der "RET" hinspringen 
soll?

Ich habe ein uart Init vor dem CAN Init und wenn ich da das CALL & RET 
durchsteppe komme ich schön wieder mit dem RET nach dem CALL raus.

Nur beim CAN Init gibt es ein Problem was ich nicht finde.

[Rufus Τ. F. (rufus)]

Hugo P. schrieb:
> In welchen Register steht die Adresse wo der "RET" hinspringen soll?

In keinem. Das steht auf dem Stack.

>   memset(&can_buffer, 0x00, sizeof(CAN_BUFFER));

Wo ist diese Variable definiert? Vielleicht hast Du nicht mehr 
ausreichend Platz im RAM, so daß der Stack in diese Variable hineinläuft 
und durch Dein memset dann hübsch "genullt" wird.

[Hugo P. (portisch)]

Ich habe jetzt noch folgendes entdeckt.
Es gab Probleme von AVR Studio 5 zu 7 mit der Program Memory.

prog_uint8_t can_filter[] = {
  // Group 0
  MCP2515_FILTER(0x000),        // Filter 0
  MCP2515_FILTER(0x000),        // Filter 1
    
  // Group 1
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 2
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 3
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 4
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 5
    
  MCP2515_FILTER(0x0FF),        // Mask 0 (for group 0)
  MCP2515_FILTER(0x7FF),        // Mask 1 (for group 1)
};

Das habe ich nun so umgearbeitet:

static const uint8_t can_filter[] PROGMEM = {
  // Group 0
  MCP2515_FILTER(0x000),        // Filter 0
  MCP2515_FILTER(0x000),        // Filter 1
    
  // Group 1
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 2
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 3
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 4
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 5
    
  MCP2515_FILTER(0x0FF),        // Mask 0 (for group 0)
  MCP2515_FILTER(0x7FF),        // Mask 1 (for group 1)
};

Nun ist der Pointer von can_filter im Program Memory und das Init des 
CAN Busses läuft nun durch.

Aber die Watchlist zeigt mir, dass die Werte nicht drinnen sind. Wie 
bekomme ich diese in die ProgMem?

Das sind noch die Macros:

  #define  MCP2515_FILTER(id) \
      (uint8_t)((uint32_t) id >> 3), \
      (uint8_t)((uint32_t) id << 5), \
      0, \
      0

[Hugo P. (portisch)]

Jetzt kenne ich mich gar nicht mehr aus!

Ich habe zum Testen einemal das Array so definiert:

static const uint8_t can_filter[] PROGMEM = {
  0,0,0,0,    //MCP2515_FILTER(0x000),        // Filter 0
  0,0,0,0,    //MCP2515_FILTER(0x000),        // Filter 1
  
  // Group 1
  32,0,0,0,    //MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 2
  32,0,0,0,    //MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 3
  32,0,0,0,    //MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 4
  32,0,0,0,    //MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 5
  
  31,224,0,0,    //MCP2515_FILTER(0x0FF),        // Mask 0 (for group 0)
  255,224,0,0    //MCP2515_FILTER(0x7FF)        // Mask 1 (for group 1)  
};

Im Watchfenster wird mir aber das angezeigt:

-    can_filter  0x0068  prog_uint8_t[32]{prog}@0x0068
    [0]  0  prog_uint8_t{prog}@0x0068
    [1]  0  prog_uint8_t{prog}@0x0069
    [2]  0  prog_uint8_t{prog}@0x006a
    [3]  0  prog_uint8_t{prog}@0x006b
    [4]  0  prog_uint8_t{prog}@0x006c
    [5]  0  prog_uint8_t{prog}@0x006d
    [6]  0  prog_uint8_t{prog}@0x006e
    [7]  0  prog_uint8_t{prog}@0x006f
    [8]  0  prog_uint8_t{prog}@0x0070
    [9]  0  prog_uint8_t{prog}@0x0071
    [10]  0  prog_uint8_t{prog}@0x0072
    [11]  0  prog_uint8_t{prog}@0x0073
    [12]  0  prog_uint8_t{prog}@0x0074
    [13]  0  prog_uint8_t{prog}@0x0075
    [14]  0  prog_uint8_t{prog}@0x0076
    [15]  0  prog_uint8_t{prog}@0x0077
    [16]  0  prog_uint8_t{prog}@0x0078
    [17]  0  prog_uint8_t{prog}@0x0079
    [18]  0  prog_uint8_t{prog}@0x007a
    [19]  0  prog_uint8_t{prog}@0x007b
    [20]  0  prog_uint8_t{prog}@0x007c
    [21]  0  prog_uint8_t{prog}@0x007d
    [22]  0  prog_uint8_t{prog}@0x007e
    [23]  0  prog_uint8_t{prog}@0x007f
    [24]  0  prog_uint8_t{prog}@0x0080
    [25]  0  prog_uint8_t{prog}@0x0081
    [26]  0  prog_uint8_t{prog}@0x0082
    [27]  0  prog_uint8_t{prog}@0x0083
    [28]  0  prog_uint8_t{prog}@0x0084
    [29]  0  prog_uint8_t{prog}@0x0085
    [30]  0  prog_uint8_t{prog}@0x0086
    [31]  0  prog_uint8_t{prog}@0x0087

Warum ist das immer noch alles auf 0?

Edit:
Es scheint ein AVR Studio Bug zu sein!
Wenn ich mir die Memory dazu ansehe stimmen die Daten:

prog 0x0068  00 00 00 00 00 00 00  ..”s.......
prog 0x006E  00 00 20 00 00 00 20 00 00 00 20  .. ... ... 
prog 0x0079  00 00 00 20 00 00 00 1f e0 00 00  ... ....à..
prog 0x0084  ff e0 00 00

Jedoch löst das nicht das Problem wie ich das mit den Macros definieren 
kann! Hat jemand eine Idee?

[Rufus Τ. F. (rufus)]

Hugo P. schrieb:
> Jedoch löst das nicht das Problem wie ich das mit den Macros definieren
> kann!

Wieso? Da funktioniert halt das Watch-Fenster auch nicht, aber im 
Speicher wird's schon gelandet sein, wie bei Deinem macrolosen Beispiel 
auch.

[Hugo P. (portisch)]

Rufus Τ. F. schrieb:
> Hugo P. schrieb:
>> Jedoch löst das nicht das Problem wie ich das mit den Macros definieren
>> kann!
>
> Wieso? Da funktioniert halt das Watch-Fenster auch nicht, aber im
> Speicher wird's schon gelandet sein, wie bei Deinem macrolosen Beispiel
> auch.

Ja, beim durchlesen bin gerade selber darauf gekommen. Werde es morgen 
mal überprüfen!

[Jim M. (turboj)]

Hugo P. schrieb:
> memset(&can_buffer, 0x00, sizeof(CAN_BUFFER));

Das ist fast sicher falsch (Pointer auf Pointer statt Pointer auf 
Array). Entweder

memset(can_buffer, 0x00, sizeof(CAN_BUFFER));

oder

memset(&can_buffer[0], 0x00, sizeof(CAN_BUFFER));

[B. S. (bestucki)]

Jim M. schrieb:
> Hugo P. schrieb:
>> memset(&can_buffer, 0x00, sizeof(CAN_BUFFER));
>
> Das ist fast sicher falsch (Pointer auf Pointer statt Pointer auf
> Array). Entweder

Merkwürdig, warum man einen Buffer nullen muss. Da man in jedem Fall 
wissen muss, wo im Buffer das erste und letzte Element ist, reicht es, 
diese beiden Variablen entsprechen zu setzen. Der Inhalt des ungenutzten 
Buffers wird einfach ignoriert.