main.c

mega128平台下

/*簇头1
* main_frame:
*    init_device
*         init_port
*         init_led
*         init_timer
*         init_RF
*         init_uart
*    init_schedule
*    start_myprogram
*    main_schedule
*/
//ICC-AVR application builder : 2006-9-26 20:14:28
// Target : M128
// Crystal: 7.3728Mhz

#include <iom128v.h>
#include <macros.h>
#include <stdio.h>
#include "../api/schedule.h"
#include "../api/cc1100.h"
#include "../api/led.h"
#include "../api/timer.h"
#include "../api/comm.h"
#include "../api/cc1100_reg.h"

#define SYNC_INTVL 500    //同步间隙50ms
#define DATA_TRANS_INTVL 500  //重发数据间隙50ms
#define CHANGE_CHAN_INTVL 12000  
#define COMM_MSG_LENGTH 31
#define NODE_MSG_LENGTH 11  //node发送的包长度，ack长度
#define LOCAL_GID 2
#define LOCAL_ID 0    //簇头节点号为0
#define CLUSTER_QUANTITY 2   //簇头总数
#define NODE_QUANTITY 2   //一个簇内node总数


//char a[4]={3,1,2,3};
//unsigned char recvBuff[128]; 
COMM_MSG recv,pre_trans;   //存放簇内节点的信息
NODE_MSG ack;
unsigned char local_buff[8];  //本地存放所有节点的信息,节点号1byte+温度1byte+电压2byte
unsigned char flag[NODE_QUANTITY]={0};
unsigned char sync_Cflag;    //cluster同步是否完成的标志
unsigned char sync_Nflag;    //cluster是否对本簇内node完成同步的标志
unsigned char counter_sync;      //cluster向node发送同步的次数
unsigned char counter_data;     //cluster向sink发送数据的次数
unsigned char change_channel;

unsigned int sync_count =60;

unsigned char *ackack;

//unsigned char test;

void identifier_init()
{
   sync_Cflag=0;
   sync_Nflag=0;
   counter_sync=0;
   counter_data=0;
   change_channel=0x0A;
   pre_trans.len=COMM_MSG_LENGTH;
   pre_trans.ID=LOCAL_ID;
   pre_trans.GID=LOCAL_GID;
   pre_trans.DA=0;
   pre_trans.type=CLUSTER_DATA;
   
   //test=0;
   //pre_trans.SeqNO=1;
  }
  
void tras_ack()
{
   CC1100_send(ackack,COMM_MSG_LENGTH+1); 
   printf("done\n");
}

void eeprom_write(unsigned  int addr,unsigned int data)
{
	while(EECR&(1<<EEWE));
	EEAR=addr;
	EEDR=data;
	EECR|=(1<<EEMWE);
	EECR|=(1<<EEWE);
}

unsigned char eeprom_read(unsigned int addr)
{
	while(EECR&(1<<EEWE));
	EEAR=addr;
	EECR|=(1<<EERE);
	return EEDR;
}

  
unsigned char CC1100_sendDone()
{
   //led0Toggle();
   //printf("send ack\n");
  }
  
extern unsigned char rxBuffer[32]; //接收缓冲区的大小  
 void CC1100_receive()
{
   unsigned char nodeID;
   unsigned char *msg = &rxBuffer[0];
   NODE_MSG *m;
   
   m=(NODE_MSG*)msg;  //转化为COMM_MSG类型
   //printf("the received type is %d",m->type);
   switch(m->type)
   {
   	/*case(SINK_INIT_NODE):
	    LOCAL_ID = m->data[0];
	    eeprom_write(0,LOCAL_ID);
	    LOCAL_GID = m->data[1];
	    eeprom_write(0,LOCAL_GID);
	    T=m->data[2]; 
	    eeprom_write(0,T);
            node_num =m->data[3];
            eeprom_write(0,node_num);
            ALARM_TMP = m->data[4];
            eeprom_write(0,ALARM_TMP);
           // work_channel = m->data[5];//根据节点组号判断就可以
	  		// 存储配置信息
	 	    break;*/
	
   	case(SINK_CLUSTER_SYNC):
   		{
   			switch(m->data[0])
   			{
   				case 1:  //第一次同步消息，时间同步，设定定时器，并置标志位
   				   halSpiWriteReg(CCxxx0_CHANNR, 2*LOCAL_GID-1+0xa);
   				   start_T1(0,3*SYNC_INTVL+1000); //设定计时器，等待sink三次同步发送完毕,1s后发送同步
   				   sync_Cflag=1;
   				   break;
   				
   				case 2:  //如果第一次没有同步，进行处理，否则，不处理
   				   if(sync_Cflag==0)
   				   {
   				   	halSpiWriteReg(CCxxx0_CHANNR, 2*LOCAL_GID-1+0xa);
   				   	start_T1(0,2*SYNC_INTVL+1000);
   				        sync_Cflag=1;
   				        }
   				   break;
   				
   				case 3: 
   				   if(sync_Cflag==0)
   				        {
   				          halSpiWriteReg(CCxxx0_CHANNR, 2*LOCAL_GID-1+0xa);
   				          start_T1(0,SYNC_INTVL+1000);
   				          sync_Cflag=1;
   				          }
   				   break;
   				default:break;
   				}
   			}
   		break;
   	
   	case(CLUSTER_ACK):  //收到sink的ack，取消重发
   		stop_T2();
   		counter_data=0;
   		break;
   	
   	case(NODE_DATA):  //保存数据，并发送ACK
   		
   		//if(m->DA==0x0100)
   		{
   		  //printf("%d\n",m->ID);
   		  //printf("%d\n",m->data[1]);
   		  //printf("%d\n",m->data[2]);
   		  //printf("%d\n",m->data[3]);
   		  
   		  nodeID=m->ID;
   		  printf("%d\n",nodeID);
   		  local_buff[4*(nodeID-1)]=m->ID;
   		  local_buff[4*(nodeID-1)+1]=m->data[1];
   		  local_buff[4*(nodeID-1)+2]=m->data[2];
   		  local_buff[4*(nodeID-1)+3]=m->data[3];
   		
   		  flag[nodeID-1]=0;
   		  
   		  ack.len=NODE_MSG_LENGTH;
   		  ack.ID=LOCAL_ID;  
   		  ack.GID=LOCAL_GID;
   		  ack.DA=((LOCAL_GID <<8)&0xff00)+nodeID;
   		  ack.type=NODE_ACK;
   		  //ack.data[0]=recv.data[0];
   		  ackack=(unsigned char*)(&ack.len);  //强制转化
   		  CC1100_send(ackack,NODE_MSG_LENGTH+1);
   		}
   		break;
   	   		 	
   	case(CLUSTER_DATA):    //未收到同步，根据收到的其他簇头信息进行同步
   		if (!sync_Cflag)
   		{
   		   //if(LOCAL_GID > m->GID)  //下轮进行同步
   		      counter_sync =3; 
   		      start_T1(0,CHANGE_CHAN_INTVL-(m->GID*3000)-(m->data[0]*DATA_TRANS_INTVL));
   		      sync_Cflag=1;
   		      //start_T0(0,CHANGE_CHAN_INTVL-(LOCAL_GID+1-m->GID)*3000);
   		   //else   
   		      //start_T0(0,(CLUSTER_QUANTITY-m->GID+1)*3000+CHANGE_CHAN_INTVL);
   		}
   		break;
        default:break;
}
return ;
}


void port_init(void)
{
  //cc1100  
 /* IN     G1      o
	GD0O   D1      i
	CSN    C2      o
	SCLK   G0      o
	OUT    C1      i
 */
 //led
 /* led0   C4      o
    led1   C5      o
	led2   C6      o
 */
 
 PORTA = 0x00;
 DDRA  = 0x00;
 PORTB = 0x00;
 DDRB  = 0x00;
 PORTC = 0x00; //m103 output only
 DDRC  = 0x74;
 PORTD = 0x00;
 DDRD  = 0x00;
 PORTE = 0x00;
 DDRE  = 0x00;
 PORTF = 0x00;
 DDRF  = 0x00;
 PORTG = 0x00;
 DDRG  = 0x03;
}



//UART0 initialize
// desired baud rate: 57600
// actual: baud rate:57600 (0.0%)
// char size: 8 bit
// parity: Disabled
void uart0_init(void)
{
 UCSR0B = 0x00; //disable while setting baud rate
 UCSR0A = 0x00;
 UCSR0C = 0x06;
 UBRR0L = 0x07; //set baud rate lo
 UBRR0H = 0x00; //set baud rate hi
 UCSR0B = 0x18;
}

//call this routine to initialize all peripherals
void init_devices(void)
{
 //stop errant interrupts until set up
 CLI(); //disable all interrupts
 XDIV  = 0x00; //xtal divider
 XMCRA = 0x00; //external memory
 port_init();                //端口初始化
 led_init();                 //所有灯灭
 T0_init();
 T2_init();
 T1_init();
 T3_init();
 CC1100_init();              //RF初始化
 uart0_init();               //串口初始化
 
 MCUCR = 0x00;
 EICRA = 0x00; //extended ext ints
 EICRB = 0x00; //extended ext ints
 EIMSK = 0x00;
 TIMSK = 0x00; //timer interrupt sources
 ETIMSK = 0x00; //extended timer interrupt sources
 SEI(); //re-enable interrupts
 //all peripherals are now initialized
}

void T0_timeout()   
{
   unsigned char i;
   //切换通道定时  
   led1Toggle(); 
   if(change_channel==0x0A)    
   {
   	halSpiWriteReg(CCxxx0_CHANNR, 2*LOCAL_GID-1+0xa);   //切换到与node通信
   	change_channel=2*LOCAL_GID-1+0xa;
  // 	led1On();
   	for(i=0;i<NODE_QUANTITY;i++)
   	   flag[i]++;
   }
   else                  
   {
   	led0Toggle();
	halSpiWriteReg(CCxxx0_CHANNR, 0x0A);   //切换到与sink通信
   	change_channel=0x0A;
        //start_T3(0,3000*(LOCAL_GID-1)+3000);
        start_T3(0,LOCAL_GID*CHANGE_CHAN_INTVL/(CLUSTER_QUANTITY+2));
   }
   //led2Toggle();
}

void T1_timeout()     //负责同步
{
   COMM_MSG sync_cluster_node;
   COMM_MSG *m;
   unsigned char *p;
   
   //if(!sync_Nflag)
   //{
    if(counter_sync<3)
     {
       counter_sync++;
  
       sync_cluster_node.len=COMM_MSG_LENGTH;
     //sync_cluster_node.ID=LOCAL_ID;
       sync_cluster_node.GID=LOCAL_GID;
       sync_cluster_node.DA=0xFFFF;  //同步的目的地址
       sync_cluster_node.type=CLUSTER_NODE_SYNC;
       sync_cluster_node.data[0]=counter_sync;
       led0Toggle();
     
	 m = &sync_cluster_node;
	 p=(unsigned char*)m;
	 
	 CC1100_send(p,COMM_MSG_LENGTH+1);
       
       start_T1(0,SYNC_INTVL); //500ms重发一次同步消息
      }
      
      else    //簇内同步结束，启动timer1
      {
      //sync_Nflag=1;
	  counter_sync =0;
      change_channel=2*LOCAL_GID-1+0xa;
      start_T0(1,CHANGE_CHAN_INTVL);  //每CHANGE_CHAN_INTVL切换一次通道
      //led0Toggle();
   	  }
	  sync_count --;
	  if (sync_count ==0)
	  {
	    counter_sync =0;
		start_T1(0,SYNC_INTVL);
	  }
     //} 
}

void resend()
{
    unsigned char *recv;
    recv=(unsigned char*)(&pre_trans.len);
    counter_data++;
    pre_trans.data[0]=counter_data;
    CC1100_send(recv,COMM_MSG_LENGTH+1);
}

void T2_timeout()  //数据重发时钟
{
//   unsigned char *recv;
//   recv=(unsigned char*)(&pre_trans.len);
   if(counter_data<3)
   {
//        counter_data++;
//        pre_trans.SeqNO=counter_data;
//        CC1100_send(recv,COMM_MSG_LENGTH+1);	
        post(resend);
        start_T2(0,DATA_TRANS_INTVL);
   }
   else
     {counter_data=0; stop_T2();}
//   led0Toggle();
}

void T3_timeout()     //发送簇内数据
{
   unsigned char *recv;
   unsigned char i;
   for(i=0;i<NODE_QUANTITY;i++)
      {
      if(flag[i]==3)
       {
       	local_buff[4*i+1]=0;
        local_buff[4*i+2]=0;
        local_buff[4*i+3]=0;
        flag[i]=0;
        }
      }  
   for(i=1;i<9;i++)
      pre_trans.data[i]=local_buff[i-1];
   //pre_trans.data[1]=test;
   //test++;  
   
   counter_data++;
   pre_trans.data[0]=counter_data;
   
   recv=(unsigned char*)(&pre_trans.len);
   
   CC1100_send(recv,COMM_MSG_LENGTH+1);
   //printf("%d",pre_trans.data[1]);
   start_T2(0,DATA_TRANS_INTVL);//启动重发时钟，500ms未收到ack则重发
   led2Toggle();
}


void delay_1ms(unsigned int xtal)
{
 unsigned int i;
 for(i=1;i<(unsigned int)(xtal*143-2);i++)
 ;
 }

void delay_x(unsigned int n)
{
 unsigned int i=0;
 for(i=0;i<n;i++)
 delay_1ms(7);
 }


void main() 
  {

    init_devices();
    sched_init();
    identifier_init();
    CC1100_setInterrupt(0x01);  //RF接收状态
    //start_T3(1,2000);
	/*
	led0Toggle();
	delay(100);
	led1Toggle();
	delay(100);
	led2Toggle();
	*/
	//halSpiWriteReg(CCxxx0_CHANNR, 0x0A);//初始化通道置为A
	
    
    /*my program*/
	
	//CC1100_send(a,4);
	//puts("hello\n");
	
	/*my program end*/
	
	/*schedule*/
	while(1) 
    {
      run_task();
    }
	
  }