AVR Simulator: Invalid opcode 0xffff at address 0x000c00

In het verleden heb ik eens een mooi UART programma geschreven voor de Atmega32 en dacht deze ook in de Atmega8 te schieten. Het gekke is dat hij nu enkel de eerste regel in de main loop uitvoerd. Bij het debuggen geeft hij een foutmelding aan het begin van de main loop en zegt: AVR Simulator: Invalid opcode 0xffff at address 0x000c00

Na enig zoeken op internet, heb ik nog steeds niet de oplossing gevonden. Weet iemand wat er hier fout gaat?

Header file:


#ifndef UART_H
#define UART_H
#include <avr/pgmspace.h>

/* set baud rate here */
#define Uart_CpuF			8000000
#define Uart_BaudRate		4800
#define Uart_BaudSelect		Uart_CpuF/16/Uart_BaudRate-1

/* set buffersizes here */
#define Uart_RxBufSize 128

/* RxEvent bitmasks/Uart_send errorcodes */
#define Uart_Rx				0x01
#define Uart_SwOverflow		0x02
#define Uart_HwOverflow		0x04
#define Uart_BufOverflow	0x08
#define Uart_FramingError	0x10

/* attributes */
extern char Uart_RxBuf[Uart_RxBufSize];
extern volatile unsigned char Uart_RxEvent;

/* methods */
void Uart_initialise( unsigned int ubrr );

unsigned char Uart_send_p(const char * __attribute__ ((__progmem__)) data);
#define Uart_send(data) Uart_send_p(PSTR(data));

void Uart_serviceTick(void);

#endif 

C file:


#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
#include <avr/pgmspace.h>
#include "prototypeprint.h"
#include <util/delay.h>



volatile unsigned char Uart_RxEvent;
char Uart_RxBuf[Uart_RxBufSize];

static unsigned char Uart_RxCount;
static unsigned char Uart_RxTimeout;
static unsigned char Uart_RxStatus;

static const prog_char *Uart_TxBuf;



void Uart_initialise( unsigned int ubrr )
{
	// Set baud rate
	UBRRH = (unsigned char)(ubrr>>8);
	UBRRL = (unsigned char)ubrr;
	// Enable receiver and transmitter
	UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
	//Set frame format: 8data, 1stop, no parity 
	UCSRC = (1<<UCSZ0)|(1<<UCSZ1)|(1<<URSEL);	


	Uart_RxCount      = 0;
	Uart_RxEvent      = 0;
	Uart_RxTimeout    = 0;
	Uart_RxStatus     = 0;
	Uart_TxBuf        = 0;


}


ISR(SIG_UART_RECV)
/* signal handler for receive complete interrupt */
{
   volatile unsigned char temp_data;
	
	
	Uart_RxTimeout = 75 / 1; /* 37 dus */
	Uart_RxStatus |= Uart_Rx;

	if(UCSRA & (1<<FE))
		Uart_RxStatus |= Uart_FramingError;
	
	temp_data = UDR;
	
	/*if(USR & (1<OR))
		Uart_RxStatus |= Uart_HwOverflow;
	*/
	
	/* Event not handled??? */
	if(Uart_RxEvent != 0){
		Uart_RxStatus |= Uart_SwOverflow;
		return;
	}
	if(Uart_RxCount < (Uart_RxBufSize-1)){
      Uart_RxBuf[Uart_RxCount] = temp_data;
      Uart_RxCount++;
	  
    }else
      Uart_RxStatus |= Uart_BufOverflow;
	  
	
	
}

ISR(SIG_UART_DATA){
	/* hieronder stond: prg_rdb(Uart_TxBuf)*/
	if(pgm_read_byte(Uart_TxBuf) != 0){
		/*  UDR = PRG_RDB(Uart_TxBuf); */
		UDR = pgm_read_byte(Uart_TxBuf);
		Uart_TxBuf++;
		
		
	}else{
		
		UCSRB &= ~(1<<UDRIE); 
		Uart_TxBuf = 0;
		
		
	}
	
}

unsigned char Uart_send_p(const char * __attribute__ ((__progmem__)) data){
	
	
	if(Uart_TxBuf)
		return Uart_SwOverflow;
	Uart_TxBuf = data;
	
	UCSRB |= (1<<UDRIE); /* Enable UDRE interrupt */
	
	return 0;
}

void Uart_serviceTick(void){
	if(Uart_RxTimeout){
		Uart_RxTimeout--;
		if(Uart_RxTimeout == 0){
			Uart_RxBuf[Uart_RxCount] = 0;
			Uart_RxEvent = Uart_RxStatus | Uart_Rx;
			Uart_RxCount = 0;
			Uart_RxStatus = 0;
		}
	}
}


void wacht1sec(void){
	int i = 0;
	for(i=0; i<300; i++){
		_delay_ms(10);
	}
}


int main(void)
{


	Uart_initialise( Uart_BaudSelect );
	
	
	sei(); 	//enable interrupts

	Uart_send("Kinderpindakaas\r\n");
		
	Uart_send("AT+IPR=4800\r\n");
		
	Uart_send("AT&K0\r\n");
		
	Uart_send("ATCMEE=2\r\n");
		
	Uart_send("AT+CPIN?\r\n");
		
	Uart_send("AT+CPIN=0000\r\n");
		
	Uart_send("AT+CGMR\r\n");
	
	Uart_send("AT#SELINT=1\r\n");
		
	Uart_send("AT+FCLASS=8\r\n");
		
	Uart_send("ATD +31645598706\r\n");
		

	

				
	while(1);
}

De regel Uart_send("Kinderpindakaas\r\n"); doet hij enkel uitvoeren, die erna zie ik niet binnekomen op de terminal

Heb je wel aangegeven dat je een mega8 ipv een atmega32 gebruikt? De atmega8 heeft geen absolute jump of call instructie, alleen relatieve. De opcode voor een abolute jump/call is dus ongeldig voor de atmega8.

Wat is precies een absolute of relative call?

[Bericht gewijzigd door Henry S. op (77%)]

Een relative jump/call telt een bepaalde waarde op bij het huidige adres, terwijl bij een absolute jump de bestemming als volledig adres in de opcode is gegeven. In de atmega8 is elk geheugen adres te bereiken met een relatieve jump, dus de absolute jump is uit de instructieset gehaald. Zoek eens in de asm code naar instructies als JMP en CALL.

Bovenstaande code is geen asm code, dus dan zou de compiler dat toch netjes moeten vertalen?

[Bericht gewijzigd door Henry S. op (70%)]

Als je die vertelt dat voor welk device er gebouwd moet worden wel ja...

In AVRStudio heb ik idd een Atmega8 project gestart, dus dan zou hij het goed moeten vertalen.
Weet iemand wat precies opcode is en hoe ik adrescodes kan gebruiken bij debuggen?

[Bericht gewijzigd door Henry S. op (32%)]

Google stuk? Eerste hit.
Je debugger zal niet zoveel helpen. Om de een of andere reden genereert je compiler code die op 0x0c00 uit komt. Daar staat niks (0xffff staat doorgaans in lege flash). Ofwel: die compiler doet wat raars of je stack gaat ergens volkomen de mist in.