main.c

motorola jw32 usb 源码

 #include <hidef.h> /* for EnableInterrupts macro */
#include "MC68HC908JW32.h" /* include peripheral declarations */
#include "public.h" /* include peripheral declarations */
#include "mft.h"
#include "tick.h"
#include "mftPHY.h"
#include "mftMAC.h"
#include "network.h"	 				   
#include "app.h"				  			  
#include "string.h"			      
#include "keycode.h"
#include "JkMap.h"
#include "KeyMap.h"
#include "Tick.c"
#include "spi.c"
#include "usbQueue.c"
#include "mftPHY2500RF.c"
#include "mftPHY2500.c"
#include "usb.c"

#include "writeFlash.c"

#include "Jkdevice.c"
#include "JkeyOut.c"
#include "mftMAC.c"
#include "network.c"

extern BYTE APPGetUsbData(unsigned char *buffer,unsigned char *length);
#define 		    SM_APP_INIT                 0
//#define		    SM_APP_RESTART		    1
//#define		    SM_APP_RESTART_WAIT		2
#define				SM_APP_START_WAIT			3
#define				SM_APP_NORMAL_RUN			4
#define             SM_APP_NET_WAIT				5
#define				SM_APP_SLEEP				6
#define			    SM_APP_START		        7
#pragma DATA_SEG  MY_ZEROPAGE
//------------------------------------------------------------------------------
// Typedefs
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
// Application variables
//------------------------------------------------------------------------------


static BYTE    bAppFlag ;
//static BYTE    AppReceived;
static BYTE    UsbAppReceived;
//******************************************************************************

 BYTE *AppmapAddr;
 	BYTE times=0;
  BYTE bunitLength=0;
  BYTE AppDataSend=0;
  BYTE AppLooseFlag=0;
 BYTE  AppDataFlag=0;
static  BYTE 		Applen=0;
static  BYTE 		Getcount = 0;
static BYTE    APPbflag=EMPTY;
//static BYTE     AppUsbBuffer[USBRELENTH];
const BYTE LooseBuffer[KEYBOARDLENGTH]={0x01,0x00,0x00,0x00,0x00,0x00,0x00};//key bounce data
#pragma  DATA_SEG DEFAULT
static BYTE    AppSendBuffer[USBRELENTH];


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Function Prototypes
//------------------------------------------------------------------------------

static void Initialize( void );
static void AppTask( void );
//---------------------------------------------------------------------
void APPUsbReceived(void)
{
	UsbAppReceived = TRUE;

}
//---------------------------------------------
void IO_RP_Init()
{
     POCR2 = POCR2_PTD7PD_MASK|
            POCR2_PTD3PD_MASK|
            POCR2_PTD2PD_MASK;
// init MCU
    CONFIG1 =   CONFIG1_LVISTOP_MASK|
                CONFIG1_STOP_MASK;//| CONFIG1_COPD_MASK;cop reset enable,66ms external osc 4M
    CONFIG2 =   CONFIG2_STOPEN_MASK|
                CONFIG2_STOP_RCCLKEN_MASK|
                CONFIG2_CLKS_MASK|
                CONFIG2_URSTD_MASK;
// Init PORT (PCB specific)

    DDRA = 0x60; //0xe0-0x00 PortA Input	 1110$0000
    DDRB = 0xFF; // PortC Output
    DDRC = 0xFF; // PortC Output,PTC3:buzzer
    DDRD = 0xFF; // PortD Output
    DDRE = 0xBF; //  PortE Output   1011$1111
    PTA = 0xff ;
    PTC = 0 ;
    PTB = 0x03 ;
    PTD = 0x7f ;
    PTE = 0 ;
    WARN_BUZZER=BUZZ_CLOSE;



}
//-----------------------------------------------
void main(void) {

  /* include your code here */


    Initialize();
    MACInit();
    // Enable the stack.
    MACEnable();

    Queue_Init();

	// Initialize the time to request messages from the coordinator.  The first
    // value isn't too important, as long as it's reasonable.
   // messageRequestTime =0;
	 EnableInterrupts; /* enable interrupts */
    for(;;) {
        if(bAppFlag==SM_APP_INIT) {

            // This is our first time running.
            bAppFlag = SM_APP_START;

        }else if(bAppFlag==SM_APP_START){
            // Try to join a network.

            NWKInit();
            bAppFlag = SM_APP_START_WAIT;
          }
          else if(bAppFlag==SM_APP_START_WAIT){
            // See if the join is complete.
            if ( NWKInitIsComplete() )
            {

                if ( NWKIsDiscovered() )
                {
                    // We have joined a network, but we are not bound yet.

                    NWKFormStart();
                    bAppFlag = SM_APP_NET_WAIT;
                }
                else
                {
                    // We cannot do anything useful until we join a
                    // network, so keep trying.
                  // printf( "Join unsuccessful.  Trying again...\r\n" );
                    bAppFlag = SM_APP_START;
                }
            }
        }
        else if(bAppFlag==SM_APP_NET_WAIT){
       				if(NWKFormIsComplete())
       				{
       					if(MACIsNetworkEstablished())
       					{
       						 bAppFlag = SM_APP_NORMAL_RUN;
       					}
       		 			else
             		{
                    // We cannot do anything useful until we join a network
                    bAppFlag = SM_APP_START;
             		}
       				}
       }
       else if(bAppFlag==SM_APP_NORMAL_RUN){
            AppTask();
        }


        //----------------------------------------------------
        MACTask(); //main task
        //-----------------------------------------------------
       __RESET_WATCHDOG(); /* feeds the dog */


  } /* loop forever */
  /* please make sure that you never leave this function */
}


/**************************************************
      Name:    TimerInterrupt
      Descrip: 定时器1中断处理流程
      Input:   无
      Output:  无
***************************************************/

interrupt 8 void TimerInterrupt (void)
{
	//BYTE tsc;
     // Must call this so that stack can determine if a transmission is
    // in progress or not.

   // MACISR();
		//messageRequestTime++;
    // Must call this so that tick manager can update its tick count.
    // TMR0IF is also used by TickUpdate, so we will let it clear the flag.
    //PTD_PTD4^=1;

    TickUpdate();
    macBeaconTick++;
    if(macBeaconTick>=BI)
    {
    		macBeaconTick=0;
    		beaconflag=1;
    }
   // LED_PWRCHG^=1;
    //tsc = T1SC;
   // T1SC = tsc&0x7F; // reset TOF flag
   // beaconFlag =1;

}

void AppAutoSend(void)
{
	BYTE  sendflag;
	sendflag=0;

	 if(AppDataFlag==MAC_DEVICE_KEYBOARD)
	{
		 if(!UsbKbIsIdle())
		 {
		 		return;
		 }
	}
	else if(AppDataFlag==MAC_DEVICE_MOUSE)
	{
			if(!UsbMsIsIdle())
		 {
		 		return;
		 }
	}
	sendflag=0;
	if(AppLooseFlag)
	{
		     	if(PutUsbData((BYTE *)LooseBuffer,KEYBOARDLENGTH,MAC_DEVICE_KEYBOARD)) 
					{
								AppLooseFlag=0;
								if(times==0)
								{
									AppDataSend=0;
								}
					}
					return;
	}
	if(times)
	{
			if(times>5)
			{
				  AppDataSend=0;
				  AppLooseFlag=0;
					return;
			}
		  AppDataSend=1;
			if(PutUsbData(AppmapAddr,bunitLength,AppDataFlag))
			{
				AppmapAddr+=bunitLength	;
				times--;
				sendflag=1;
			}
	}
	else if(PutUsbData(AppmapAddr,bunitLength,AppDataFlag))
	{
			sendflag=1;
	}
	if(sendflag)
	{
			if(AppDataFlag==MAC_DEVICE_KEYBOARD)
			{
					AppLooseFlag=1;
			}
			else if(times==0)
			{
				  AppDataSend=0;
				  AppLooseFlag=0;
			}
	}
}


//******************************************************************************
// Stack Callback Functions
//******************************************************************************
 //divide app buffer data into different key data.then put into usb queue
void AppBreakData(BYTE bflag,byte *inbuffer,byte length)
{
  if(length==0)
  return;
	if(bflag==MAC_DEVICE_KEYBOARD)
	{
			bunitLength = KEYBOARDLENGTH;
		 times = length/KEYBOARDLENGTH;

	}
/*	else if(bflag==MAC_DEVICE_MOUSE)	 //mouse and joystick length is same
	{

		  bunitLength = MOUSELENGTH;
		  times = length/MOUSELENGTH;
	}*/
	else
	{

		  bunitLength = JOYSTICKLENGTH;
		  times = length/JOYSTICKLENGTH;
	}
	AppDataFlag=bflag;
	AppDataSend=1;
  AppmapAddr=inbuffer;
/*	if(times!=0)
	{
		if(times>=5)
			return;
			for(i=0;i<times;i++)
			{
				bstart = i*bunitLength;//one byte is head id

				if(!PutUsbData(&inbuffer[bstart],bunitLength,bflag))
				{
					break;
				}
				//put key
				if((times>1)&&(bflag==MAC_DEVICE_KEYBOARD))	//if key pressed
				{
					if(!PutUsbData((BYTE*)LooseBuffer,bunitLength,bflag))          //put bounce
					{
						break;
					}
				}
		}
	}
	else if(!PutUsbData(inbuffer,length,bflag))
	{
				;
	}*/
}
// Callback to application to notify of a frame reception
void AppMACFrameReceived(void)
{
	 if(MACGetData())
			 ;
	  //	 AppReceived = TRUE;
}
BYTE APPMACPutBuffer(BYTE *buffer,BYTE blength)
{
	BYTE    devid;
	if(blength==0)
	return FALSE;
    devid=buffer[0];

    	switch(devid)//dispath data send to pc,use usb commmunication
    	{
    		case MAC_DEVICE_MOUSE:
    			{
    					 AppBreakData(MAC_DEVICE_MOUSE,buffer+1,(blength-1));

    			}
    			break;
    		case MAC_DEVICE_KEYBOARD:
    			{
    						 AppBreakData(MAC_DEVICE_KEYBOARD,buffer+1,(blength-1));
    					/**	  if(looseFlag==AUTOBD)
    					 {
    					 		if(!PutUsbData((BYTE*)LooseBuffer,KEYBOARDLENGTH,MAC_DEVICE_KEYBOARD)) ;         //put bounce
    					 }*/
    			}

    			break;
    		case MAC_DEVICE_JOYSTICK0:
    				AppBreakData(MAC_DEVICE_JOYSTICK0,buffer+1,(blength-1));
    				break;
    			case MAC_DEVICE_JOYSTICK1:
    				AppBreakData(MAC_DEVICE_JOYSTICK1,buffer+1,(blength-1));
    				break;
    		default:

    			break;
    	}
    	return TRUE;
}
/*
BYTE APPGetBuffer(byte **outBuffer,byte *outLength)
{
		byte i,bdata;
		byte blength;
		 if (APPbflag == EMPTY)
		 {
			 return FALSE;
		}
	blength = AppSendBuffer[Getcount++];
	*outLength=blength;
	*outBuffer = AppSendBuffer+Getcount;
		for(i=0;i<blength;i++)
	{
			if(Getcount==MAC_KEYMAPLEN)
		{
			Getcount=0;
		}
		if(Getcount==Applen)
		{
			APPbflag = EMPTY;
			 return FALSE;
		}
		bdata=AppSendBuffer[Getcount++];
	}
	if(bdata!=KBDATAEND) //END
		return FALSE   ;
	if(Getcount==MAC_KEYMAPLEN)
	{
			Getcount=0;
	}
	if(Getcount==Applen)
	{
		APPbflag = EMPTY;
	}
	else
		APPbflag=NORMAL;
	return TRUE;
}*/
// Callback to application to notify of an ack timeout
/*void AppMACFrameTimeOutOccurred(void)
{
if(MACIsNetworkEstablished())//send data,dont ack,so need to join network again
		bAppFlag = SM_APP_START;
}*/
//------------------------------------------------------------------------------
// Initialize
//------------------------------------------------------------------------------

static void Initialize( void )
{

		bAppFlag = SM_APP_INIT;
	//	AppReceived=FALSE;
			UsbAppReceived =FALSE;

		IO_RP_Init();
		PLL_Start();
    USB_EN();
        // This is to initialize tick manager required for mft stack modules.
   	TickInit();
    SPI_Master_EN();
    LED_DATA=0;
    AppmapAddr=0;
    AppDataSend=0;
         //  WriteFlash(FLASH_ADDRESS,DATASIZE);
}

//------------------------------------------------------------------------------
// InitializeBoard
//------------------------------------------------------------------------------



//------------------------------------------------------------------------------
// AppTask
//------------------------------------------------------------------------------
//dispath keyboard and mouse data to usb.

static void AppTask( void )
{
    //
	BYTE    devid;
	BYTE    *pBufAddr=&devid;
	BYTE    blength=0;

    //---------------------------------------------------------------
    if(UsbAppReceived)
    {
    	UsbAppReceived = FALSE;
    	Applen = 	USBRELENTH;
    	if(APPGetUsbData(AppSendBuffer,&Applen))
    	{
    		if(MACSaveAppData(AppSendBuffer,Applen))
    		{
    			USBACK(SUCCESS) ;
    		}
    		else
    		{
    			USBACK(FAIL);
    			LED_DATA=1; //close led
    		}
    	}
    }
/*		else			
		{				
			Usb_KbQueueChk();	
		}*/
		if(AppDataSend)
		{
			AppAutoSend();
		}
		
}