/*****************************************************
This program was produced by the
CodeWizardAVR V2.04.5b Evaluation
Automatic Program Generator
© Copyright 1998-2009 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : 
Version : 
Date    : 24.02.2010
Author  : Freeware, for evaluation and non-commercial use only
Company : 
Comments: 


Chip type               : AT90CAN128
Program type            : Application
AVR Core Clock frequency: 16,000000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 1024
*****************************************************/

#include <90can128.h>
#include <delay.h>
// Alphanumeric LCD Module functions
#asm
   .equ __lcd_port=0x08 ;PORTC
#endasm
#include <lcd.h>

/*******************************************************************
definitions
*******************************************************************/

// Declare your global variables here
typedef unsigned char uint8_t;
typedef unsigned long int uint32_t;
#define NO_MOBS 15		// number of message objects
#define NOMOB   0xff   // CAN2.0 B, extendef frame(29bit) message	//WAS  bzw woher nimmt er das?
#define ENB1 PD7							//WAS  bzw woher nimmt er das?
#define ENB2 PD4							//WAS  bzw woher nimmt er das?
typedef struct
	{	
		uint32_t id;			// message ID                  
		uint32_t msk;        	// ID Mask for message          
		uint8_t length;   		// length of data DLC
		uint8_t data[8];  		// data vector
	}CAN_messageType;         
    

/*******************************************************************
CAN initialization
*******************************************************************/
void can_init( void)
{
uint8_t mob;

  CANGCON = 0x01;        // reset the CAN controller
  
  CANGCON = 0x00;                // reset the general control register
  CANGIT  = 0x00;                // reset the general interrupt register
       
  CANSIT2 = 0x00;                // reset the status interrupt registers
  CANSIT1 = 0x00;

  //Enable CAN interrupts globally, set enable all interrupts except CANtimer overrun interrupt
  CANGIE = 0xFE;    //(1<<ENIT) | (1<<ENRX) | (1<<ENTX) |(1<<ENERR);
  
  //Set MObs for which interrupts are enabled
  CANIE2 = (1<<IEMOB0) |  (1<<IEMOB1) |  (1<<IEMOB2) |  (1<<IEMOB3);         
  CANIE1 = 0x00;
  
  //for all Message Objects: set the StatusRegister CANSTMOB to zero; Disable MOb CANCDMOB=0, (CONMOB1:0=00)
  for (mob = 0; mob < NO_MOBS; mob++)
  {
     CANPAGE  = (mob << 4);     
     
     CANIDT1 = 0x00;        //reset ID-Tag
     CANIDT2 = 0x00;
     CANIDT3 = 0x00;
     CANIDT4 = 0x00;

     CANIDM1 = 0x00;        //reset ID-Mask
     CANIDM2 = 0x00;
     CANIDM3 = 0x00;
     CANIDM4 = 0x00;

     CANSTMOB = 0x00;        //reset MOb status
     CANCDMOB = 0x00;         //disable MOb
  }

    
  //Baudrate:   250kBit/s
  CANBT1 = 0x06;    // set Baud Rate Prescaler for CAN controller bit timing (page236, table on page261)
  CANBT2 = 0x0C;    // set propagation time segment (page232, table on page261)              
  CANBT3 = 0x37;    // set PHaseSegment2 and PHaseSegment1 (page233, table on page261)
   
  CANTCON = 0xFF; 	// CAN timer prescaler 256. Can be used for time stamping
       
  CANGCON = 0x02;	// Set CAN-driver in enable mode (not standby-mode)
  
  // wait until module is ready EnableFlag is on.
  while (!(CANGSTA & (1<<ENFG))); 
  lcd_putsf("CAN Init");
    delay_ms(1000);	
  lcd_putsf("                             ");
//---------------- CAN CONTROLLER IS NOW INITIALISED/CONFIGURED 250kBits/s ---------------
  
  // this part must be adapted to your hardware!!
  // set enable CAN-channel 1 of amis42700 dual CAN-transceiver 
 DDRD |= (1<<ENB1) | (1<<ENB2);
 PORTD &= ~(1<<ENB1); 			// enable channel1.  (low-active type)		//WAS  bzw woher nimmt er das?
 PORTD |= (1<<ENB2);			// disable channel2. (low-active type)  	//WAS  bzw woher nimmt er das?
}//can_init


/*******************************************************************
CAN transmission 
*******************************************************************/
void can_tx (CAN_messageType msg)
{	
uint8_t i, mob;	
      
	//select MOb to be sent
	mob=1;
	//enable MOb number mob, auto increment index, start with index = 0
	CANPAGE = (mob<<4);
	 
	//set IDE bit, length = 8
	CANCDMOB = (0<<IDE) | (8);			
	 
	//write 29 Bit identifier to MOb-ID-Tag
	msg.id <<= 3;								
	CANIDT4 = (unsigned char) (msg.id&0xF8);
	CANIDT3 = (unsigned char) (msg.id>>8);
	CANIDT2 = (unsigned char) (msg.id>>16);
	CANIDT1 = (unsigned char) (msg.id>>24);
	
	//put data in mailbox
	for (i=0; i<8; i++)							
		CANMSG = msg.data [i];
	   
	//wait until transmit possible (TXBSY==0)
	//while (CANGSTA & (1<<TXBSY));
	lcd_putsf("CAN TX ");
	//enable transmission. After the tx is complete the TXOK bit is cleared in the ISR
	CANCDMOB |= (1<<CONMOB0);											
    
}//can_tx

void main(void)
{
// Declare your local variables here
CAN_messageType msg;//,msg0

// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTA=0x00;
DDRA=0xFF;

// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTB=0x00;
DDRB=0x00;

// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTD=0x00;
DDRD=0x00;

// Port E initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTE=0x00;
DDRE=0x00;

// Port F initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTF=0x00;
DDRF=0x00;

// Port G initialization
// Func4=In Func3=In Func2=In Func1=In Func0=In 
// State4=T State3=T State2=T State1=T State0=T 
PORTG=0x00;
DDRG=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0 output: Disconnected
TCCR0A=0x00;
TCNT0=0x00;
OCR0A=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// OC1C output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
// Compare C Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
OCR1CH=0x00;
OCR1CL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCNT2=0x00;
OCR2A=0x00;

// Timer/Counter 3 initialization
// Clock source: System Clock
// Clock value: Timer3 Stopped
// Mode: Normal top=FFFFh
// OC3A output: Discon.
// OC3B output: Discon.
// OC3C output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer3 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
// Compare C Match Interrupt: Off
TCCR3A=0x00;
TCCR3B=0x00;
TCNT3H=0x00;
TCNT3L=0x00;
ICR3H=0x00;
ICR3L=0x00;
OCR3AH=0x00;
OCR3AL=0x00;
OCR3BH=0x00;
OCR3BL=0x00;
OCR3CH=0x00;
OCR3CL=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: Off
// INT3: Off
// INT4: Off
// INT5: Off
// INT6: Off
// INT7: Off
EICRA=0x00;
EICRB=0x00;
EIMSK=0x00;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;
// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=0x00;
// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=0x00;
// Timer/Counter 3 Interrupt(s) initialization
TIMSK3=0x00;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;

// CAN Controller initialization
// CAN: Off
//CANGCON=0x00;

//init for switch Portpin. (active-low type) 
	DDRF &= !(1<<DDF2);	//(set input pin) see datasheet p62/63
	PORTF |= (1<<PORTF2);	//(activate pull-up)   
    
lcd_init(8);						//in lcd_init wird auch der Timer für delayms(xx) initialisiert.
can_init();						//initialize CAN driver
	SREG = 0x80;							//globally enable interrupts

// create CAN_package to be sent
	msg.id = 0x80;
	msg.length = 8;
	msg.data[0] = 0x01;
	msg.data[1] = 0x02;
	msg.data[2] = 0x01;
	msg.data[3] = 0x02;
	msg.data[4] = 0x01;
	msg.data[5] = 0x02;
	msg.data[6] = 0x01;
	msg.data[7] = 0x02;      
    
while (1)
      { 
      // Place your code here       
      can_tx(msg);
      };
}