int main() {
log_init();
log_printf("***** Hello from app-layer! *******");
ConnectionInit();
SoftReset();
while (1) {
BOOL connected = ConnectionTasks();
if (!connected
&& state > STATE_OPEN_CHANNEL) {
// just got disconnected
log_printf("Disconnected");
SoftReset();
state = STATE_INIT;
}
switch (state) {
case STATE_INIT:
handle = INVALID_CHANNEL_HANDLE;
state = STATE_OPEN_CHANNEL;
break;
case STATE_OPEN_CHANNEL:
if ((handle = OpenAvailableChannel()) != INVALID_CHANNEL_HANDLE) {
log_printf("Connected");
state = STATE_WAIT_CHANNEL_OPEN;
}
break;
case STATE_WAIT_CHANNEL_OPEN:
if (ConnectionCanSend(handle)) {
log_printf("Channel open");
AppProtocolInit(handle);
state = STATE_CONNECTED;
}
break;
case STATE_CONNECTED:
AppProtocolTasks(handle);
break;
case STATE_ERROR:
ConnectionCloseChannel(handle);
SoftReset();
state = STATE_INIT;
break;
}
}
return 0;
}
/* This function will invoke the CPU power save sleep mode.
*
* Bus traffic will wake the CPU and cause execution to vector to the CAN
* module's ISR. The ISR will detect the event as a wakeup and call the wake-up
* handler, which simply performs a software reset.
*
* TODO: This function could be a centralized location for putting peripherals
* in low power or OFF states. Right now that is done by the caller
* (vi-firmware.cpp). This is easy to do via direct manipulation of the
* peripheral control registers (SFRs), but skips over the peripheral libraries.
* Using the existing C++ libraries here isn't always possible, however, since
* they can use overloaded functions, which gcc won't allow.
*/
void openxc::power::suspend() {
debug("Going to low power mode");
PowerSaveSleep();
// The only peripheral configured with wake-up events should be the CAN1
// module. That event will trigger the CAN1 ISR, which will lead directly to
// a software reset. Code execution should therefore never reach this point.
// Nevertheless, a software reset would be prudent here.
SoftReset();
}
int main(void){
initLed();
initButton();
while(!isPressed()){
setLed(1,0,0);
delayLoop();
setLed(0,0,0);
delayLoop();
}
setLed(1,1,1);
DelayMs(1000);
SoftReset();
}
OMAP3InterruptController::OMAP3InterruptController(fdt_module_info *fdt, fdt_device_node node)
: InterruptController(fdt, node),
fNumPending(3)
{
fRegArea = fFDT->map_reg_range(node, 0, (void**)&fRegBase);
if (fRegArea < 0)
panic("OMAP3InterruptController: cannot map registers!");
SoftReset();
// Enable protection (MPU registers only available in privileged mode)
fRegBase[INTCPS_PROTECTION] |= 1;
}
/*******************************************************************************
* TASK: taskMonitorUsb
*
* DESCRIPTIONS:
* Check if the USB is connected/disconnected.
*
*******************************************************************************/
void taskMonitorUsb (void *pvParameters)
{
while (1) {
// USB is plugged in.
if(USB_BUS_SENSE == 1) {
if (xSystemState.bUsbMode == 0) {
SoftReset();
}
}
// USB is unpluged.
else {
if (xSystemState.bUsbMode == 1) {
SoftReset();
}
}
// Loop again after 500ms.
vTaskDelay(500 / portTICK_RATE_MS);
// Read the stack watermark and record it if it's below threshold.
unsigned portBASE_TYPE uxHighWaterMark = uxTaskGetStackHighWaterMark(NULL);
if (uxHighWaterMark < MIN_STACK_WATERMARK) {
xSystemError.bStackLowError = 1;
// Only log it when the watermark value changed.
static portBASE_TYPE uxPreviousWatermark = 0;
if (uxHighWaterMark != uxPreviousWatermark) {
vLogStackWatermark("USB Monitor Task", (unsigned short)uxHighWaterMark);
}
uxPreviousWatermark = uxHighWaterMark;
}
}
}
BOOL initFlashLocal(){
if(bytesOfRaw > 0x1000-FLASHSTORE){
println_E("Too much data to store");
SoftReset();
}
println_W("Size of Flash data = ");p_int_W(bytesOfRaw);
SetFlashData( localData.data ,bytesOfRaw/4);
FlashLoad();
int i=0,j=0, index;
BOOL rawFlashDetect=FALSE;
for(i=0;i<numPidTotal;i++){
index = i*sizeof(AbsPID_Config);
for(j=0;j<sizeof(AbsPID_Config)/4;j++){
getPidGroupDataTable()[i].raw[j]=localData.data[index+j];
}
if( (getPidGroupDataTable()[i].config.Enabled != 1 &&
getPidGroupDataTable()[i].config.Enabled != 0) ){
rawFlashDetect = TRUE;
println_E("Detected raw flash, setting defaults : ");p_int_E(i);
printPIDvals(i);
getPidGroupDataTable()[i].config.Enabled = FALSE;
getPidGroupDataTable()[i].config.Async=0;
getPidGroupDataTable()[i].config.IndexLatchValue=0;
getPidGroupDataTable()[i].config.stopOnIndex=0;
getPidGroupDataTable()[i].config.useIndexLatch=0;
getPidGroupDataTable()[i].config.K.P=.1;
getPidGroupDataTable()[i].config.K.I=0;
getPidGroupDataTable()[i].config.K.D=0;
getPidGroupDataTable()[i].config.V.P=.1;
getPidGroupDataTable()[i].config.V.D=0;
getPidGroupDataTable()[i].config.Polarity=1;
getPidGroupDataTable()[i].config.stop=0;
getPidGroupDataTable()[i].config.upperHistoresis=0;
getPidGroupDataTable()[i].config.lowerHistoresis=0;
}
}
if(rawFlashDetect )
writeFlashLocal();
return !rawFlashDetect;
}
/**
* Read tand retutns the specified joypad buttons.
* Function also monitors for the reset condition:
* Select+Start+A+B
*/
unsigned int ReadJoypad(unsigned char joypadNo){
static unsigned int joy;
if(joypadNo==0){
joy=joypad1_status_lo;
}else{
joy=joypad2_status_lo;
}
//process reset (check if joystick is unplugged first)
if((joy!=0xff) && (joy&BTN_START) && (joy&BTN_SELECT) && (joy&BTN_A) && (joy&BTN_B)){
while(joypad1_status_lo!=0 && joypad2_status_lo!=0);
SoftReset();
}
return joy;
}
void AppCallback(CHANNEL_HANDLE h, const void* data, UINT32 data_len) {
if (data) {
if (!AppProtocolHandleIncoming(data, data_len)) {
// got corrupt input. need to close the connection and soft reset.
log_printf("Protocol error");
state = STATE_ERROR;
}
} else {
// connection closed, soft reset and re-establish
if (state == STATE_CONNECTED) {
log_printf("Channel closed");
SoftReset();
} else {
log_printf("Channel failed to open");
}
state = STATE_OPEN_CHANNEL;
}
}
void TIM2_IRQHandler()
{
if(TIM2->SR&0X0001)//溢出中断
{
USB_IncTimeoutCnt();
ComIncTimeoutCnt(COM1);
ComIncTimeoutCnt(COM2);
ComIncTimeoutCnt(COM3);
if(HeartBeat_Enable )
{
HeartBeatCount--;
if(HeartBeatCount == 0)
SoftReset();
}
}
TIM2->SR&=~(1<<0);//清除中断标志位
}
void writeFlashLocal(){
if(bytesOfRaw > 0x1000-FLASHSTORE){
println_E("Too much data to store");
SoftReset();
}
println_W("Writing values to Flash");
int i=0,j=0, index;
for(i=0;i<numPidTotal;i++){
index = i*sizeof(AbsPID_Config);
for(j=0;j<sizeof(AbsPID_Config)/4;j++){
localData.data[index+j]=getPidGroupDataTable()[i].raw[j];
}
}
FlashSync();
FlashLoad();
for(i=0;i<numPidTotal;i++){
printPIDvals(i);
}
}
/*
* UEFI Shutdown () function
*
*/
EFI_STATUS
EFIAPI
SnpShutdown (
IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp
)
{
EFI_STATUS Status;
// Check Snp Instance
if (Snp == NULL) {
return EFI_INVALID_PARAMETER;
}
// First check that driver has not already been initialized
if (Snp->Mode->State == EfiSimpleNetworkStarted) {
DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not yet initialized\n"));
return EFI_DEVICE_ERROR;
} else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not started\n"));
return EFI_NOT_STARTED;
}
// Initiate a PHY reset
Status = PhySoftReset (PHY_RESET_PMT, Snp);
if (EFI_ERROR (Status)) {
return Status;
}
// Initiate a software reset
Status = SoftReset (0, Snp);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_WARN, "Warning: Soft Reset Failed: Hardware Error\n"));
return Status;
}
// Back to the started and thus not initialized state
Snp->Mode->State = EfiSimpleNetworkStarted;
return EFI_SUCCESS;
}
/*
* UEFI Initialize() function
*
*/
EFI_STATUS
EFIAPI
SnpInitialize (
IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
IN UINTN RxBufferSize OPTIONAL,
IN UINTN TxBufferSize OPTIONAL
)
{
EFI_STATUS Status;
UINT32 PmConf;
INT32 AllocResult;
UINT32 RxStatusSize;
UINT32 TxStatusSize;
// Initialize variables
// Global variables to hold tx and rx FIFO allocation
gTxBuffer = 0;
// Check Snp Instance
if (Snp == NULL) {
return EFI_INVALID_PARAMETER;
}
// First check that driver has not already been initialized
if (Snp->Mode->State == EfiSimpleNetworkInitialized) {
DEBUG ((EFI_D_WARN, "LAN9118 Driver already initialized\n"));
return EFI_SUCCESS;
} else
if (Snp->Mode->State == EfiSimpleNetworkStopped) {
DEBUG ((EFI_D_WARN, "LAN9118 Driver not started\n"));
return EFI_NOT_STARTED;
}
// Initiate a PHY reset
Status = PhySoftReset (PHY_RESET_PMT, Snp);
if (EFI_ERROR (Status)) {
Snp->Mode->State = EfiSimpleNetworkStopped;
DEBUG ((EFI_D_WARN, "Warning: Link not ready after TimeOut. Check ethernet cable\n"));
return EFI_NOT_STARTED;
}
// Initiate a software reset
Status = SoftReset (0, Snp);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_WARN, "Soft Reset Failed: Hardware Error\n"));
return EFI_DEVICE_ERROR;
}
// Read the PM register
PmConf = MmioRead32 (LAN9118_PMT_CTRL);
// MPTCTRL_WOL_EN: Allow Wake-On-Lan to detect wake up frames or magic packets
// MPTCTRL_ED_EN: Allow energy detection to allow lowest power consumption mode
// MPTCTRL_PME_EN: Allow Power Management Events
PmConf = 0;
PmConf |= (MPTCTRL_WOL_EN | MPTCTRL_ED_EN | MPTCTRL_PME_EN);
// Write the current configuration to the register
MmioWrite32 (LAN9118_PMT_CTRL, PmConf);
gBS->Stall (LAN9118_STALL);
gBS->Stall (LAN9118_STALL);
// Configure GPIO and HW
Status = ConfigureHardware (HW_CONF_USE_LEDS, Snp);
if (EFI_ERROR(Status)) {
return Status;
}
// Assign the transmitter buffer size (default values)
TxStatusSize = LAN9118_TX_STATUS_SIZE;
RxStatusSize = LAN9118_RX_STATUS_SIZE;
// Check that a buff size was specified
if (TxBufferSize > 0) {
if (RxBufferSize == 0) {
RxBufferSize = LAN9118_RX_DATA_SIZE;
}
AllocResult = ChangeFifoAllocation (
ALLOC_USE_FIFOS,
&TxBufferSize,
&RxBufferSize,
&TxStatusSize,
&RxStatusSize,
Snp
);
if (AllocResult < 0) {
return EFI_OUT_OF_RESOURCES;
}
}
// Do auto-negotiation if supported
Status = AutoNegotiate (AUTO_NEGOTIATE_ADVERTISE_ALL, Snp);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_WARN, "Lan9118: Auto Negociation not supported.\n"));
}
// Configure flow control depending on speed capabilities
Status = ConfigureFlow (0, 0, 0, 0, Snp);
if (EFI_ERROR(Status)) {
return Status;
}
// Enable the transmitter
Status = StartTx (START_TX_MAC | START_TX_CFG, Snp);
if (EFI_ERROR(Status)) {
return Status;
}
// Now acknowledge all interrupts
MmioWrite32 (LAN9118_INT_STS, ~0);
// Declare the driver as initialized
Snp->Mode->State = EfiSimpleNetworkInitialized;
return Status;
}
/**********************************************************************
* Function: resetAtlas
* @return None.
* @remark Resets the boat and reinitalizes.
* @author David Goodman
* @date 2013.05.04
**********************************************************************/
static void resetAtlas() {
SoftReset();
}
void openxc::power::handleWake() {
SoftReset();
}
void Terminal(void)
{
const char str1[] = {'k',0x00,'e',0x00,'y',0x00,'.',0x00,'b',0x00,'m',0x00,'p',0x00,'\0',0x00};
const char str2[] = {'\\',0x00,'s',0x00,'y',0x00,'s',0x00,'\0',0x00};
char KeyBuffer[31]={'Q','W','E','R','T','Y','U','I','O','P','A','S','D','F','G','H','J','K','L','Z','X','C','V','B','N','M',',',' ',' ',' ','.'};
char SpecialKeyBuffer[31]={'1','2','3','4','5','6','7','8','9','0','!','@','#','$','%','&','*','?','/','Z','"',' ','(',')','-','+',';',' ',' ',' ',':'};
const unsigned short int LetterPosX[4]={93,62,32,1};
const unsigned short int SpecialCharPosY[6]={1,284,1,39,245,284};
const unsigned short int LetterPosY[31]={1,33,65,97,129,161,193,225,257,289,
17,49,81,113,145,177,209,241,273,
49,81,113,145,177,209,241,
81,113,145,177,209};
_Bool NumSp=0,UppLow=0,ReadCmd=0,ErrorSyntax=0,HighApp=0,LowApp=0,SyntaxError=0,ExitApp=0,InitRfApp=0,SendApp=0,StatusRfApp=0,ReadApp=0,SetTime=0,SetDate=0;
char c[2]={'A',0x00};
char TextBuffer[10],i=0,b=0,Parametri=0,StringBuffer[50],Nchar=0,Param3[10],Param2[10],Param1[10],Param4[10],Param5[10];
unsigned short int clu=0, dat=0,DelCount=0,a=0x0000;
TRFData rfData;
char Minuti[3]={0x30,0x30,0x00};///minuti
char Ore[3]={0x30,0x31,0x00};///Ore
SSD1289_writeResgiter( 0x0049, 0x000A );///fine della finestra a 10 px
LCD_CLS(AZZURRO);
sprintf(TextBuffer,"Loading..");
LCD_Text57(2,1,TextBuffer,1,BLACK,NONE);
Xcursor=238;
Ycursor=2;
wFSchdir ((unsigned short int *)&str2[0]);
DrawBmp(0,319,(unsigned short int * )&str1[0],0);
SSD1289_writeResgiter( 0x0049, 0x013F );
while(TRUE)
{
if(PORTDbits.RD14==0)
{
read();
clu=getX();
dat=getY();
clu=(unsigned short int)((((float)6.01/(float)233.01)*(float)clu)+(float)clu);
dat=(unsigned short int)((((float)10.01/(float)313.01)*(float)dat)+(float)dat);
b=0;
for(i=0; i<31; i++)
{
///lettere
if((LetterPosX[b]<=clu)&&(clu<=(LetterPosX[b]+29))&&((LetterPosY[i]<=dat)&&(dat<=(LetterPosY[i]+29))))//la Q
{
///se attivo caratteri speciali
if(NumSp) c[0]=SpecialKeyBuffer[i];
else c[0]=KeyBuffer[i];
if((UppLow==1)&&(NumSp==0))
{
switch(c[0])
{
case ',':
break;
case' ':
break;
case'.':
break;
default:
c[0]+=0x20;
break;
}
}
LCD_FastRect(Xcursor-6,Ycursor,Xcursor,Ycursor+5,WHITE);
strcpy(TextBuffer,c);
StringBuffer[Nchar]=c[0];
LCD_Text57Land(Xcursor,Ycursor,TextBuffer,1,BLACK,NONE);
Nchar++;
//Ycursor+=6;
if(Ycursor>=319)
{
Ycursor=2;
Xcursor-=8;
Nchar=0;
}
DelayMs(50);
}
if(i==9) b++;
if(i==18) b++;
if(i==25) b++;
}
///comandi speciali
b=2;
for(i=0; i<6; i++)
{
if((LetterPosX[b]<=clu)&&(clu<=(LetterPosX[b]+29))&&((SpecialCharPosY[i]<=dat)&&(dat<=(SpecialCharPosY[i]+34))))//la Q
{
switch(i)
{
case 0:
///da implementare Upper/lower letter
if(UppLow==0)
{
UppLow=1;
LCD_Cercle(53,29,3,1,GRAY);
}
else
{
UppLow=0;
LCD_Cercle(53,29,3,1,BLUE);
}
break;
case 1:
LCD_FastRect(Xcursor-6,Ycursor,Xcursor,Ycursor+5,AZZURRO);
Ycursor-=6;
Nchar--;
if(Ycursor>350)
{
Ycursor=314;
Xcursor+=8;
Nchar=0;
if(Xcursor>241) Xcursor=238;
}
break;
case 2:
///da implementare
break;
case 3:
///da implementare
break;
case 4:
///da implementare attiva/disattiva numeri+caratteri speciali
if(NumSp==0)
{
NumSp=1;
LCD_Cercle(22,274,3,1,BLUE);
}
else
{
NumSp=0;
LCD_Cercle(22,274,3,1,GRAY);
}
break;
case 5:
///torna a capo riga (invio)
LCD_FastRect(Xcursor-6,Ycursor,Xcursor,Ycursor+5,AZZURRO);
NumSp=0;
LCD_Cercle(22,274,3,1,GRAY);
UppLow=0;
LCD_Cercle(53,29,3,1,BLUE);
Ycursor=2;
Xcursor-=8;
if(Xcursor<=136)
{
LCD_FastRect(121,0,239,319,AZZURRO);
Xcursor=238;
}
ReadCmd=1;
StringBuffer[Nchar]=0x00;
Nchar=0;
break;
}
DelayMs(50);
}
if(i==1) b=3;
}
}
///Lampeggio cursore
DelayMs(1);
DelCount++;
if(DelCount==200)
{
DelCount=0;
if(a==0x00000) a=0xffff;
else a=0x0000;
LCD_FastRect(Xcursor-6,Ycursor,Xcursor,Ycursor+5,a);
}
///Se premuto invio..
if(ReadCmd==1)
{
ReadCmd=0;
ErrorSyntax=0;
Parametri=0;
b=0;
///Ciclo per verificare la stringa passata
///carica in Param1, Param2, Param3, ogni parola separata da uno spazio
for(i=0; i<20; i++)
{
if(StringBuffer[i]==0x20) {Parametri=1; Param1[i]=0x00; break;}
if(StringBuffer[i]==0x00) {Parametri=1; Param1[i]=0x00; break;}
Param1[i]=StringBuffer[i];
}
if(StringBuffer[i]!=0x00)
{
b=0;
for(i<20; i++;)
{
if(StringBuffer[i]==0x20) {Parametri=2; Param2[b]=0x00; break;}
if(StringBuffer[i]==0x00) {Parametri=2; Param2[b]=0x00; break;}
Param2[b]=StringBuffer[i];
b++;
}
}
if(StringBuffer[i]!=0x00)
{
b=0;
for(i<20; i++;)
{
if(StringBuffer[i]==0x20) {Parametri=3; Param3[b]=0x00; break;}
if(StringBuffer[i]==0x00) {Parametri=3; Param3[b]=0x00; break;}
Param3[b]=StringBuffer[i];
b++;
}
}
if(StringBuffer[i]!=0x00)
{
b=0;
for(i<20; i++;)
{
if(StringBuffer[i]==0x20) {Parametri=4; Param4[b]=0x00; break;}
if(StringBuffer[i]==0x00) {Parametri=4; Param4[b]=0x00; break;}
Param4[b]=StringBuffer[i];
b++;
}
}
if(StringBuffer[i]!=0x00)
{
b=0;
for(i<20; i++;)
{
if(StringBuffer[i]==0x20) {Parametri=5; Param5[b]=0x00; break;}
if(StringBuffer[i]==0x00) {Parametri=5; Param5[b]=0x00; break;}
Param5[b]=StringBuffer[i];
b++;
}
}
///Fine ciclo
//Verifica le stringhe
//da completare salta al programma...
if(strcmp(Param1,"HIGH")==FALSE) HighApp=1;
if(strcmp(Param1,"LOW")==FALSE) LowApp=1;
if(strcmp(Param1,"EXIT")==FALSE) ExitApp=1;
if(strcmp(Param1,"REBOOT")==FALSE) SoftReset();
if(strcmp(Param1,"SEND")==FALSE) SendApp=1;
if(strcmp(Param1,"INITRF")==FALSE) InitRfApp=1;
if(strcmp(Param1,"STATUSRF")==FALSE) StatusRfApp=1;
if(strcmp(Param1,"READRF")==FALSE) ReadApp=1;
if(strcmp(Param1,"SETTIME")==FALSE) SetTime=1;
if(strcmp(Param1,"SETDATE")==FALSE) SetDate=1;
if((HighApp==0)&&(LowApp==0)&&(ExitApp==0)&&(SendApp==0)&&(InitRfApp==0)&&(StatusRfApp==0)&&(ReadApp==0)&&(SetTime==0)&&(SetDate==0)) SyntaxError=1;
if(SetTime)
{
SetTime=0;
Ore[0]=Param2[0];
Ore[1]=Param2[1];
Minuti[0]=Param3[0];
Minuti[1]=Param3[1];
if((Ore[0]>=0x32)&&(Ore[1]>=0x34))
{
sprintf(StringBuffer,"Ore invalide!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,RED,NONE);
}
else if(Minuti[0]>=0x36)
{
sprintf(StringBuffer,"Minuti invalidi!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,RED,NONE);
}
else{
lastTime.hour=atobcd(&Ore[0]);
lastTime.min=atobcd(&Minuti[0]);
RtccSetTimeDate(lastTime.l, lastDate.l);
sprintf(StringBuffer,"Time updated!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
}
}
if(StatusRfApp)
{
StatusRfApp=0;
StatusRead();
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.RG_FF_IT);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.POR);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.RGUR_FFOV);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.WKUP);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.EXT);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.LBD);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.FFEM);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.RSSI_ATS);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.DQD);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.CRL);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=16;
sprintf(StringBuffer,"%02x ",TransceiverStatus.bits.ATGL);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor=2;
}
if(InitRfApp)
{
InitRfApp=0;
if(strcmp(Param2,"OFF")==FALSE)
{
MRF49XA_Power_Down();
sprintf(StringBuffer,"RF Stopped!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,RED,NONE);
}
else{
initRFPorts();
MRF49XA_Init();
InitRFData(&rfData);
sprintf(StringBuffer,"RF Initialized! %x",RF_IRQ);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
}
}
if(ReadApp)///Test sniff pacchetti
{
WORD GENCREG2 = (0x8000|XTAL_LD_CAP_125);
WORD CFSREG2 ;
WORD DRVSREG2 ;
WORD RXCREG2 ;
WORD PMCREG2 = 0x8201;
WORD TXCREG2 = 0x9850;
volatile BOOL RxPacketValid[BANK_SIZE];
BYTE RxPacket[BANK_SIZE][80];
volatile BYTE RxPacketLen[BANK_SIZE];
WORD totalReceived = 0;
unsigned char FreqBand=0,DataRate=0,Nop=0;
ReadApp=0;
sprintf(StringBuffer,"Reading..");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,AZZURRO);
//Setta le porte
mPORTFSetPinsDigitalOut(BIT_5);//SDO
mPORTFSetPinsDigitalOut(BIT_13);//SCK
mPORTBSetPinsDigitalOut(BIT_14);//CS
mPORTBSetPinsDigitalOut(BIT_13);//FSEL
mPORTESetPinsDigitalIn(BIT_9);//FINT
mPORTESetPinsDigitalIn(BIT_8);//IRQ
mPORTFSetPinsDigitalIn(BIT_4);//SDI
mPORTFSetPinsDigitalIn(BIT_12);//INT
SPI4CON = 0x0120;
//SPI1BRG = 0x001F; // 64:1 prescale (slow display update)
SPI4BRG = 0x0001; // 4:1 prescale (fast display update) 16Mhz spi clock at 72Mhz sys clock
SPI4CONSET = 0x8000; // enables the spi
RF_RSCLR;
DelayUs(10);
RF_RSSET;
DelayMs(125);
RF_CSSET;
RF_FSELSET;
//RF_SCKCLR;
//RF_SDOCLR;
///Fine init porte
i=Param2[0];
//i=1;
switch(i)
{
case '1':
FreqBand = 1;
break;
case '2':
FreqBand = 2;
break;
case '3':
FreqBand = 3;
break;
}
GENCREG2 |= ((WORD)FreqBand << 4);
i=Param3[0];
//i=1;
switch(i)
{
case '1':
DataRate = 1;
DRVSREG2 = 0xC623;
break;
case '2':
DataRate = 2;
DRVSREG2 = 0xC611;
break;
case '3':
DataRate = 3;
DRVSREG2 = 0xC608;
break;
case '4':
DataRate = 4;
DRVSREG2 = 0xC605;
break;
case '5':
DataRate = 5;
DRVSREG2 = 0xC602;
break;
}
i=Param4[0];
//i=4;
switch(i)
{
case '1':
RXCREG2 = 0x9421;
break;
case '2':
RXCREG2 = 0x9441;
break;
case '3':
RXCREG2 = 0x9461;
break;
case '4':
RXCREG2 = 0x9481;
break;
case '5':
RXCREG2 = 0x94A1;
break;
case '6':
RXCREG2 = 0x94C1;
break;
}
switch(FreqBand)
{
case 1:
CFSREG2 = 0xA640;
break;
case 2:
CFSREG2 = 0xA640;
break;
case 3:
CFSREG2 = 0xA7D0;
break;
default:
break;
}
//Init RF
SPI_Command(FIFORSTREG);
SPI_Command( FIFORSTREG | 0x0002);
SPI_Command(GENCREG2);
SPI_Command(0xC4F7);
SPI_Command(CFSREG2);
SPI_Command(DRVSREG2);
SPI_Command(PMCREG2);
SPI_Command(RXCREG2);
SPI_Command(TXCREG2);
SPI_Command(PMCREG2 | 0x0020);
DelayMs(5);
SPI_Command(PMCREG2 | 0x0080);
SPI_Command(GENCREG2 | 0x0040);
SPI_Command(FIFORSTREG);
SPI_Command( FIFORSTREG | 0x0002);
SPI_Command(0x0000);
//InitRFData(&rfData);
sprintf(StringBuffer,"%x, %x, %x",Param2[0],Param3[0],Param4[0]);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,AZZURRO);
sprintf(StringBuffer,"%x,%x",RF_IRQ,RF_INT);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,AZZURRO);
while(TRUE)
{
if((RF_IRQ==0)||(RF_INT==1))
{
//nCS = 0;
RF_CSCLR;
Nop++;
if( SPI_SDI == 1 )
{
BYTE RxPacketPtr;
BYTE tmpPacketLen;
BYTE bIndex;
WORD counter;
// There is data in RX FIFO
//nCS = 1;
//nFSEL = 0; // FIFO selected
RF_CSSET;
RF_FSELCLR;
tmpPacketLen = SPI_Read();
for(bIndex = 0; bIndex < BANK_SIZE; bIndex++)
{
if( RxPacketValid[bIndex] == FALSE )
{
break;
}
}
if( tmpPacketLen >= 80 || tmpPacketLen == 0 || bIndex >= BANK_SIZE )
{
IGNORE_HERE:
//nFSEL = 1; // bad packet len received
RF_FSELSET;
SPI_Command(PMCREG2); // turn off the transmitter and receiver
SPI_Command(FIFORSTREG); // reset FIFO
SPI_Command(GENCREG2); // disable FIFO, TX_latch
SPI_Command(GENCREG2 | 0x0040); // enable FIFO
SPI_Command(PMCREG2 | 0x0080); // turn on receiver
SPI_Command(FIFORSTREG | 0x0002); // FIFO synchron latch re-enabled
goto RETURN_HERE;
}
RxPacketLen[bIndex] = tmpPacketLen;
//RLED = 1;
//nFSEL = 1;
mPORTDSetBits(BIT_2);
RF_FSELSET;
RxPacketPtr = 0;
counter = 0;
while(1)
{
if( counter++ == 0xFFFF )
{
goto IGNORE_HERE;
}
else if( RF_FINT == 1)
{
//nFSEL = 0;
RF_FSELCLR;
counter = 0;
RxPacket[bIndex][RxPacketPtr++] = SPI_Read();
if( RxPacketPtr >= RxPacketLen[bIndex] )
{
BYTE i;
//nFSEL = 1;
//nCS = 0;
RF_FSELSET;
RF_CSCLR;
//SPI_SDO = 0;
RF_SDOCLR;
Nop++;
for(i = 0; i < 8; i++)
{
//SPI_SCK = 1;
//SPI_SCK = 0;
RF_SCKSET;
Nop++;
RF_SCKCLR;
Nop++;
}
if( SPI_SDI == 0 )
{
goto IGNORE_HERE;
}
//nCS = 1;
RF_CSSET;
SPI_Command(FIFORSTREG);
//RLED = 0;
mPORTDClearBits(BIT_2);
RxPacketValid[bIndex] = TRUE;
SPI_Command(FIFORSTREG | 0x0002); // FIFO synchron latch re-enable
goto RETURN_HERE;
}
//nFSEL = 1;
RF_FSELSET;
}
}
}
else // read the rest of the interrupts
{
SPI_Read();
//nCS = 1;
RF_CSSET;
}
RETURN_HERE:
Nop++;
}
for(i = 0; i < BANK_SIZE; i++)
{
if( RxPacketValid[i] == TRUE )
{
BYTE j;
WORD received_crc;
WORD calculated_crc;
totalReceived++;
//Printf("\r\n");
Xcursor-=8;
Ycursor=2;
sprintf(StringBuffer,"%04x | %04x |",totalReceived,RxPacketLen[i]);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
//PrintChar(totalReceived>>8);
//PrintChar(totalReceived);
//Printf(" | ");
//PrintChar(RxPacketLen[i]);
//Printf(" | ");
for(j = 0; j < RxPacketLen[i]; j++)
{
sprintf(StringBuffer,"%02x ",RxPacket[i][j]);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
Ycursor+=12;
//PrintChar(RxPacket[i][j]);
//Printf(" ");
}
received_crc = ((WORD)RxPacket[i][RxPacketLen[i]-1]) + (((WORD)RxPacket[i][RxPacketLen[i]-2]) << 8);
calculated_crc = CRC16(RxPacket[i], RxPacketLen[i]-2);
if( received_crc != calculated_crc )
{
//Printf(" * CRC");
sprintf(StringBuffer," * CRC");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
}
RxPacketValid[i] = FALSE;
}
}
//i=MRF49XA_Receive_Packet(&rfData);
//DelayUs(50);
//if(i==3) break;
//if(i==2) break;
//if(i==1) break;
//sprintf(StringBuffer,"%x,%x,%x",RF_IRQ,RF_FINT,SPI_SDI);
//LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,AZZURRO);
if(PORTDbits.RD14==0) break;
}
Xcursor-=8;
sprintf(StringBuffer,"Ricevuto! %d, 0x%02x, 0x%02x, 0x%02x, 0x%02x",i,rfData.buffer[0],rfData.buffer[1],rfData.buffer[2],rfData.buffer[3]);
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
}
if(SendApp)
{
SendApp=0;
//LCD_FastRect(121,0,239,319,AZZURRO);
AddRFData(&rfData,Param2[0]);
MRF49XA_Send_Packet(&rfData);
InitRFData(&rfData);
sprintf(StringBuffer,"Dato inviato..");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,BLACK,NONE);
}
if(HighApp)
{
HighApp=0;
if(strcmp(Param2,"D2")==FALSE)
{
sprintf(StringBuffer,"D2 Actived! 1");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,GREEN,NONE);
mPORTDSetPinsDigitalOut(BIT_2);
mPORTDSetBits(BIT_2);
}
else
{
sprintf(StringBuffer,"Port Not Found!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,RED,NONE);
}
}
if(LowApp)
{
LowApp=0;
if(strcmp(Param2,"D2")==FALSE)
{
sprintf(StringBuffer,"D2 Deactived! 0");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,GREEN,NONE);
mPORTDSetPinsDigitalOut(BIT_2);
mPORTDClearBits(BIT_2);
}
else
{
sprintf(StringBuffer,"Port Not Found!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,RED,NONE);
}
}
if(SyntaxError)
{
SyntaxError=0;
sprintf(StringBuffer,"Syntax Error!");
LCD_Text57Land(Xcursor,Ycursor,StringBuffer,1,RED,NONE);
}
if(ExitApp==1) break;
Xcursor-=8;
Ycursor=2;
for(i=0; i<10; i++)
{
StringBuffer[i]=0x00;
Param1[i]=0x00;
Param2[i]=0x00;
Param3[i]=0x00;
}
}
if(PORTDbits.RD3==0) break;
}
}
void PrintConsoleMenu(void)
{
unsigned char byteReceived;
static BOOL waitingResponse = FALSE;
WIFLY_Result_t result;
char OutString[128];
if((strlen(consoleMsg) <= 1) & (!waitingResponse))
{
byteReceived = consoleMsg[0];
switch(byteReceived)
{
case 'a':
putsConsole("\r\nEnter BAUDRATE\r\n");
waitingResponse = TRUE;
consoleState = 'a';
break;
case 'b':
putsConsole("\r\nEnabling Pass-thru mode for RN1723\r\n");
RN_UartCmdMode = TRUE;
RN_COMMAND_MODE();
{
unsigned long int timeout;
timeout = TickGet() + TICK_SECOND * 1;
while ((UINT32)TickGet() < timeout);
}
RN_DATA_MODE();
//XEEWriteCompleteArray(USER_RN_UART_SETTING, (unsigned char *) &RN_UartCmdMode, sizeof(RN_UartCmdMode));
break;
case 'c':
putsConsole("\r\nResetting System to RN1723 Factory Defaults\r\n");
_Factory_Reset_RN();
break;
case '0':
self_test();
case '1':
//putsConsole("\r\nProgramming RN Application Default Settings");
RN_UartCmdMode = TRUE;
Wifly_Default_Config(FALSE); //web app mode turned off
RN_RESET_LOW();
{
//pulse of atleast 160 us
unsigned long int timeout = TickGet();
while(TickGet() < (timeout + (1 * TICK_MILLISECOND)));
}
RN_RESET_HIGH();
RN_UartCmdMode = FALSE;
putsConsole("\r\n>>");
Reset();
break;
case '2':
putsConsole("\r\nScanning for networks\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("scan\r\n","END:",SEC(10))==Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
putsConsole("\r\n>>");
break;
case '3':
putsConsole("\r\nEnter SSID\r\n");
waitingResponse = TRUE;
consoleState = 0x03;
break;
case '4':
putsConsole("\r\nEnter DNS name\r\n");
waitingResponse = TRUE;
consoleState = 0x04;
break;
case '5':
putsConsole("\r\nEnter Host IP Address\r\n");
waitingResponse = TRUE;
consoleState = 0x05;
break;
case '6':
putsConsole("\r\nEnter destination port number\r\n");
waitingResponse = TRUE;
consoleState = 0x06;
break;
case '7':
putsConsole("\r\nChange SYS Wake time\r\n");
waitingResponse = TRUE;
consoleState = 0x07;
break;
case '8':
putsConsole("\r\nEnter RN1723 Dev Board Base-URI\r\n");
waitingResponse = TRUE;
consoleState = 0x08;
break;
case '9':
putsConsole("\r\nEnter Date in mm/dd/yyyy format\r\n");
waitingResponse = TRUE;
consoleState = 0x09;
break;
default:
putsConsole("\r\n\r\nChoose from the below options:\r\n");
putsConsole("------------------------------------------");
putsConsole("\r\na. Configure PIC32 to RN-UART BAUDRATE");
putsConsole("\r\nb. Pass Terminal to RN-UART");
putsConsole("\r\nc. Factory Reset System\r\n");
putsConsole("\r\n1. Restore RN1723 Dev Board Default Settings");
putsConsole("\r\n2. Scan for networks to join");
putsConsole("\r\n3. Configure SSID, Passphrase");
putsConsole("\r\n4. Change DNS Name");
putsConsole("\r\n5. Change Host IP Address");
putsConsole("\r\n6. Change Destination port");
putsConsole("\r\n7. Change RN SYS Wake time");
putsConsole("\r\n8. Change RN1723 Dev Board Base-URI");
putsConsole("\r\n9. Enter Date and Time (Used for SSL Peer Validation)");
putsConsole("\r\n\r\nPress 'ESC' to exit PIC32 Console Mode");
putsConsole("\r\n>>");
break;
}
}
else
{
waitingResponse = FALSE;
switch(consoleState)
{
case 'a':
{
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set uart baud %s\r\n", consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
}
break;
case 0x03:
putsConsole("\r\nProgramming SSID...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set wlan ssid %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,"OK",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", "OK", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
putsConsole("\r\nEnter Passphrase\r\n");
waitingResponse = TRUE;
consoleState = 0x32;
break;
case 0x04:
putsConsole("\r\nProgramming DNS...\r\n");
if(strlen(consoleMsg) > 2)
{
memset(hostName, '\0', 40);
strcpy(hostName, consoleMsg);
XEEWriteCompleteArray(USER_HOST_NAME, (char*) &hostName, 40);
}
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set dns name %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("set ip host 0\r\n", ">", SEC(1))== Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x05:
putsConsole("\r\nProgramming host IP...\r\n");
if(strlen(consoleMsg) > 2)
{
memset(hostName, '\0', 40);
strcpy(hostName, consoleMsg);
XEEWriteCompleteArray(USER_HOST_NAME, (char*) &hostName, 40);
}
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set ip host %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("set dns name 0\r\n",">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x06:
putsConsole("\r\nProgramming Destination port...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set ip remote %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x07:
putsConsole("\r\nProgramming sys wake time...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set sys wake %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x08:
putsConsole("\r\nProgramming Base-URI...\r\n");
memset(moduleBaseURI, '\0', 40);
strcpy(moduleBaseURI, consoleMsg);
XEEWriteCompleteArray(USER_BASE_URI_ADDRESS, (char*) &moduleBaseURI, 40);
consoleState = 0;
break;
case 0x09:
{
char *indexPtr;
if(indexPtr = strchr(consoleMsg, '/'))
{
unsigned char temp[4] = {"\0"};
temp[0] = *(indexPtr-2);
temp[1] = *(indexPtr-1);
timeNow.tm_mon = atoi(temp);
sprintf(OutString,"Month %d\r\n", timeNow.tm_mon);
putsConsole(OutString);
indexPtr = strchr(indexPtr+1, '/');
temp[0] = *(indexPtr-2);
temp[1] = *(indexPtr-1);
timeNow.tm_mday = atoi(temp);
sprintf(OutString,"Day %d\r\n", timeNow.tm_mday);
putsConsole(OutString);
temp[0] = *(indexPtr+1);
temp[1] = *(indexPtr+2);
temp[2] = *(indexPtr+3);
temp[3] = *(indexPtr+4);
timeNow.tm_year = (atoi(temp)-1900);
sprintf(OutString,"Year %d\r\n", atoi(temp));
putsConsole(OutString);
putsConsole("\r\nEnter Time in HH:MM (Hours:Minutes) format\r\n");
waitingResponse = TRUE;
consoleState = 0x92;
}
break;
}
case 0x32:
putsConsole("\r\nProgramming Passphrase...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set wlan pass %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,"OK",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("set wlan join 1\r\n",">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", "OK", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
EEPROM_Config_Defaults();
putsConsole("\r\nSetting EEPROM provisioned flag...");
{
unsigned char xeeVal = DEVICE_PROVISION_VAL;
XEEWriteCompleteArray(EE_PROVISION_ADDR, (char *) &xeeVal, sizeof(xeeVal));
}
consoleState = 0;
//resets the board after new configurations are programmed
SoftReset();
case 0x92:
{
char *indexPtr;
if(indexPtr = strchr(consoleMsg, ':'))
{
unsigned char temp[2] = {"\0"};
temp[0] = *(indexPtr-2);
temp[1] = *(indexPtr-1);
timeNow.tm_hour = atoi(temp);
sprintf(OutString,"Hours %d\r\n", timeNow.tm_hour);
putsConsole(OutString);
temp[0] = *(indexPtr+1);
temp[1] = *(indexPtr+2);
timeNow.tm_min = atoi(temp);
sprintf(OutString,"Min %d\r\n", timeNow.tm_min);
putsConsole(OutString);
}
}
timeNow.tm_isdst = 0;
sprintf(OutString, "\r\nOld Time in secs - %lu\r\n", PIC32_time);
putsConsole(OutString);
PIC32_time = mktime(&timeNow);
sprintf(OutString, "\r\nNew Time in secs - %lu\r\n", PIC32_time);
putsConsole(OutString);
XEEWriteCompleteArray(CURRENT_TIME_INFO, (char *) &PIC32_time, 4);
consoleState = 0;
break;
default:
consoleState = 0;
break;
//Resets console selection
//Unexpected state
}
putsConsole("\r\n>>");
}
memset(consoleMsg, '\0', sizeof(consoleMsg));
}
void ReadButtons(){
unsigned int p1ButtonsLo=0,p2ButtonsLo=0;
unsigned char i;
//latch controllers
JOYPAD_OUT_PORT|=_BV(JOYPAD_LATCH_PIN);
#if SNES_MOUSE == 1
if(snesMouseEnabled){
WaitUs(1);
}else{
Wait200ns();
Wait200ns();
}
#else
Wait200ns();
Wait200ns();
#endif
JOYPAD_OUT_PORT&=~(_BV(JOYPAD_LATCH_PIN));
//read button states
for(i=0;i<16;i++){
p1ButtonsLo>>=1;
p2ButtonsLo>>=1;
#if SNES_MOUSE == 1
if(snesMouseEnabled){
WaitUs(5);
}else{
Wait200ns();
Wait200ns();
}
#else
Wait200ns();
Wait200ns();
#endif
//pulse clock pin
JOYPAD_OUT_PORT&=~(_BV(JOYPAD_CLOCK_PIN));
if((JOYPAD_IN_PORT&(1<<JOYPAD_DATA1_PIN))==0) p1ButtonsLo|=(1<<15);
if((JOYPAD_IN_PORT&(1<<JOYPAD_DATA2_PIN))==0) p2ButtonsLo|=(1<<15);
JOYPAD_OUT_PORT|=_BV(JOYPAD_CLOCK_PIN);
#if SNES_MOUSE == 1
if(snesMouseEnabled){
WaitUs(5);
}else{
Wait200ns();
Wait200ns();
}
#else
Wait200ns();
Wait200ns();
#endif
}
#if JOYSTICK==TYPE_SNES
joypad1_status_lo=p1ButtonsLo;
joypad2_status_lo=p2ButtonsLo;
#else
joypad1_status_lo=p1ButtonsLo&0xff;
joypad2_status_lo=p2ButtonsLo&0xff;
#endif
if(joypad1_status_lo==(BTN_START+BTN_SELECT+BTN_Y+BTN_B) || joypad2_status_lo==(BTN_START+BTN_SELECT+BTN_Y+BTN_B)){
SoftReset();
}
}
int32_t main()
{
/***************************************************************************
* ClkInit()
****************************************************************************/
ClkInit();
/***************************************************************************
* GPIOInit();
****************************************************************************/
// DrvGPIO_InitFunction(E_FUNC_GPIO);
outpw(&SYS->P0_MFP, 0);
outpw(&SYS->P1_MFP, 0);
outpw(&SYS->P2_MFP, 0);
outpw(&SYS->P3_MFP, 0);
outpw(&SYS->P4_MFP, 0);
_GPIO_SET_PIN_MODE(MODEM_ON_PORT, MODEM_ON_PIN, GPIO_PMD_OUTPUT);
ModuleOn(TRUE);
_GPIO_SET_PIN_MODE(MODEM_POWER_PORT, MODEM_POWER_PIN, GPIO_PMD_OUTPUT);
ModulePowerOn(FALSE);
_GPIO_SET_PIN_MODE(LOCK_POWER_PORT, LOCK_POWER_PIN, GPIO_PMD_OUTPUT);
LockPower(FALSE);
_GPIO_SET_PIN_MODE(KEY_HELP_PORT, KEY_HELP_PIN, GPIO_PMD_QUASI);
_GPIO_SET_PIN_MODE(KEY_BAT_PORT, KEY_BAT_PIN, GPIO_PMD_QUASI);
_GPIO_SET_PIN_MODE(SLEEP_PORT, SLEEP_PIN, GPIO_PMD_OUTPUT);
ModemSleep(FALSE);
_GPIO_SET_PIN_MODE(LED_PORT, LED_PIN, GPIO_PMD_OUTPUT);
LedDark();
_GPIO_SET_PIN_MODE(INT_PORT, INT_PIN, GPIO_PMD_INPUT);
/***************************************************************************
* TimerInit();
****************************************************************************/
SysTick_Config(SYS_TICK);
// SYS_LockReg();
/***************************************************************************
* UartInit();
****************************************************************************/
UartInit();
// debug(VERSION);
// DrvSYS_GetPLLClockFreq();
/***************************************************************************
* WatchdogInit();
****************************************************************************/
WatchdogInit();
// udpTest();
NvInit();
WhatToDo();
AdcInit();
WaitLockPower();
LockPower(!custermParam.param.lockState);
InitMsgDebug();
if( Communication(10) == FALSE )
SoftReset();
if( isCheckingBattery )
{
delay_50ms(40);
MeasurePower(4);
}
else
{
MeasurePower(2);
}
Flag_ModuleOn = TRUE;
//Flag_ModuleOn = TRUE;
ModemVolumeInit();
///--------------------24.11.2015----------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////
while(PressHelp()&&(tmp_my<200)&&(PressBatter())){
tmp_my++;
delay_50ms(1);
if (tmp_my>=150) {
LedLight(144);
if (custermParam.param.lockState) {
LockPower(TRUE);
custermParam.param.lockState = FALSE;
WriteToNv( &custermParam ); //- save to eeprom
PlayVoice("\"unitUnlock.wav\",2\r");
delay_ms(2000);
LockPower(FALSE);
} else {
// debug("ins");
while(PressBatter()){};
tmp_my=0;
while (tmp_my<25){
tmp_my++;
delay_ms(150);
if (PressBatter()){counterPress++;
while(!PressBatter()){};
}
if (counterPress>2){
PlayVoice("\"unitLock.wav\",2\r");
delay_ms(2000);
custermParam.param.lockState = TRUE;
WriteToNv( &custermParam ); //- save to eeprom
tmp_my=0;
delay_ms(2000);
LockPower(DISABLE);
}
}
LedBlink();
}
///////
tmp_my=0;
}
}
while(custermParam.param.lockState){}
///////////////////////////////////////////////////////////////////////////////////////////////
#ifdef DELAY_TEST
DelayTest();
#endif
PowerOn();
if(state==STATE_POWERING_DOWN || Flag_Power_Down)
{
Flag_Power_Down = FALSE;
EnterPowerDown();
while( TimerWait )
FeedWatchdog();
PowerDown();
//不会返回
}
InitVariables();
if(state == STATE_NULL)
{
state = STATE_1ST_CALL;
TimerWait = 100; // 5 s
}
TimerTestMode = 6000;
//debug("ent main loop");
while(1)
{
///--------------------
if (!TimerTestMode && state==STATE_TEST)
{
PlayMusic(MUSIC_PD);
EnterPowerDown();
}
///--------------------
if( Flag_Incomming )
{
#if 1
TimerWait = 200;
Flag_Incomming = FALSE;
TimerStandby = custermParam.param.delay;
//if(state != STATE_ACTIVE)
{
ModemSleep(FALSE);
state = STATE_INCOMMING;
}
#else
Flag_Incomming = FALSE;
if(state != STATE_INCOMMING)
{
state = STATE_INCOMMING;
ModemSleep(FALSE);
EnterAnswer();
}
#endif
}
if(TimerWait == 0)
{
switch(state)
{
case STATE_POWERING_DOWN:
PowerDown();
break;
case STATE_1ST_CALL:
RegisterWait();
break;
case STATE_REGISTER_OK:
GetCpsiInfo();
if( Flag_ObtainCpsi==TRUE)
{
state = STATE_GSM_STEADY;
if( Flag_SimExist )
{
//delay_50ms(200);
SockOpen();
TimerWait = 400;
}
else
{
TimerWait = 60;
}
}
else
{
TimerWait = 70;
}
break;
case STATE_GSM_STEADY:
if( gPhoneNumOk==PHONE_NUM_READY || Flag_SimExist==FALSE)
EnterCall();
else
TimerWait = 40;
break;
case STATE_CALL_PROMPT:
Call();
break;
case STATE_ALERT:
EnterCallFail();
break;
case STATE_NEXT_CALL:
Redial();
break;
case STATE_BATT_DISPLAY:
EnterPowerDown();
break;
case STATE_INCOMMING:
TimerStandby = custermParam.param.delay;
EnterStandby();
break;
}
}
if( TimerSock==0 && Flag_SimExist
&& ( (state>=STATE_GSM_STEADY && state<STATE_STANDBY) || progress>=TEST_GPS ) )
{
switch(sockState)
{
//case SOCKSTATE_NULL:
case SOCKSTATE_CONFIG:
case SOCKSTATE_OPENNING:
SockOpen(); // 打开失败，从新打开
break;
case SOCKSTATE_OPENED:
SendAtWaitRsq(50, 1, FALSE, "AT+CIPOPEN=0,\"UDP\",,,%s\r\n", custermParam.param.local_port);
TimerSock = 80;
break;
#if 0
case SOCKSTATE_CONNECTING:
SockConnect(); // 连接失败，从新连接
break;
#endif
case SOCKSTATE_CONNECT_OK:
if( witchApn == 1)
ClientInit();
break;
default:
break;
}
}
KeyHandle();
SecondHandle();
//SignalCheck();
BatterCheck();
PowerDownHandle();
MsgHandle();
if( Flag_SimExist )
{
UdpHandle();
SmsHandle();
PowerDownHandle();
}
FeedWatchdog();
}
}
void DoSerial() // Serial Processing of any input data
{
char c;
uint8 i;
if(Serial2Available())
{
SerialConnected=1; // Client has connected so we can now send stuff.. (Set until POR as we dont have the equivelent for a disconnect)
c = Serial2Read();
if(c==3) // 3. Raw image test (focus setup etc)
{
while(c!=1 && c!=9)
{
OC_COUNT(ON);
AquireImage();
Serial2Write(3);
Serial2Write(99);
for(i=0; i<128; i++)
Serial2Write(RawData[i]);
Serial2Write(99);
DelayMicroseconds(100000);
if(Serial2Available()) c = Serial2Read();
}
}
if(c==4) // 4. end processing
{
PowerSaveSleep(); // END!
while(1);
}
if(c==5) // 5. Send fixed (NVM) settings
{
Serial2Write(5);
Serial2Write(99);
Serial2Write(Tmin);
Serial2Write(algorithm);
Serial2Write(cap);
Serial2Write(neck);
Serial2Write(SampleRate>>8);
Serial2Write(SampleRate);
Serial2Write(RejOnTime>>8);
Serial2Write(RejOnTime);
Serial2Write(tollerance);
}
if(c==6) SendCounters();// 6. Send current settings
if(c==7) // 7. Receive new settings temporary until reset or permanent if written to NVM
{
Tmin=Serial2Read();
algorithm=Serial2Read();
cap=Serial2Read();
neck=Serial2Read();
SampleRate=Serial2Read()<<8 + Serial2Read();
RejOnTime=Serial2Read()<<8 + Serial2Read();
tollerance=Serial2Read();
NVMChanged=1;
Serial2Write(7);
}
if(c==8 && NVMChanged) // 8. Save to NVM
{
if( (void*)(NVMPtr+8) >= NVM_END) // used all the flash page so we have to erase whole page and start again (will never happen seriously!)
{
NVMErasePage(NVM_START);
NVMPtr = NVM_START;
}
// Each variable is stored as a 32 bit integer which is the minimum size programable to flash NVMPtr will always be set at next free FLASH slot after POR or a write
NVMWriteWord( (void*) (NVMPtr++) , Tmin );
NVMWriteWord( (void*) (NVMPtr++) , algorithm );
NVMWriteWord( (void*) (NVMPtr++) , cap );
NVMWriteWord( (void*) (NVMPtr++) , neck );
NVMWriteWord( (void*) (NVMPtr++) , SampleRate );
NVMWriteWord( (void*) (NVMPtr++) , RejOnTime);
NVMWriteWord( (void*) (NVMPtr++) , tollerance);
NVMChanged = 0; // All good so unflag change
Serial2Write(8);
}
if(c==9) SoftReset(); // 9. RESET Sensor!
}
void sndTest()
{
char buf[80];
// int i, vol, numchans;
int selectedTrack = 0;
//MusicPlayerTrack * t;
LoadFrame();
DrawFrame(1,28,1,18);
vwClear(1);
vwWrite(0,0,"\x80\x1A\x80\x1B");
sprintf(buf, "%d. %s",selectedTrack,songNames[selectedTrack]);
vwWrite(24,0,buf);
/*
vwWrite(0,16,"Song header");
vwWrite(80,16,"Not playing");
vwWrite(0,32,"Tracks");
vwWrite(0,48,"Mix channels");
vwWrite(0,64,"Volume");
*/
vwSetLine(3,24,2,96,15);
vwSetLine(3,24,6,160,15);
vwSetLine(3,24,8,224,15);
vwSetLine(3,24,10,288,15);
vwSetLine(3,24,12,352,15);
vw_SetSmall();
vwWrite(4,129,"¦SELECT ¢PLAY £STOP");
vwSetLine(2,18,16, 608, 15);
vw_SetBig();
while(1)
{
DoVBlank();
KeyRead();
if(Trg & KEY_START)
{
*(u16*)0x05000000 = 0x7FFF;
sndWaitForCry(315, 30);
*(u16*)0x05000000 = 0x0000;
}
if(Trg & KEY_SELECT)
sndWaitForCry(25, 30);
//sndPlayFanfare(12);
if((Trg & L_KEY) || (Trg & R_KEY))
{
selectedTrack = wrap(selectedTrack + key_tri_horz(), 0, (const)( sizeof(songNames) / sizeof(const char*) ) );
vwClearLine(1,0);
vwClearLine(1,1);
vwWrite(0,0,"\x80\x1A\x80\x1B");
sprintf(buf, "%d. %s",selectedTrack,songNames[selectedTrack]);
vwWrite(24,0,buf);
}
if(Trg & A_BUTTON)
{
sndPlaySound(selectedTrack, 0);
//sprintf(buf, "0x%08x", (unsigned int)mplay_table[0].ma->song);
//vwWrite(80,16, buf);
}
if(Trg & B_BUTTON)
{
if(sndIsMusicPlaying())
sndPauseSound();
else
SoftReset();
}
}
}
/* main ***********************************************************************/
int main (void){
CO_NMT_reset_cmd_t reset = CO_RESET_NOT;
/* Configure system for maximum performance and enable multi vector interrupts. */
SYSTEMConfig(CO_FSYS*1000, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
INTEnableInterrupts();
/* Disable JTAG and trace port */
DDPCONbits.JTAGEN = 0;
DDPCONbits.TROEN = 0;
/* Verify, if OD structures have proper alignment of initial values */
if(CO_OD_RAM.FirstWord != CO_OD_RAM.LastWord) while(1) ClearWDT();
if(CO_OD_EEPROM.FirstWord != CO_OD_EEPROM.LastWord) while(1) ClearWDT();
if(CO_OD_ROM.FirstWord != CO_OD_ROM.LastWord) while(1) ClearWDT();
/* initialize EEPROM - part 1 */
#ifdef USE_EEPROM
CO_ReturnError_t eeStatus = CO_EE_init_1(&CO_EEO, (uint8_t*) &CO_OD_EEPROM, sizeof(CO_OD_EEPROM),
(uint8_t*) &CO_OD_ROM, sizeof(CO_OD_ROM));
#endif
programStart();
/* increase variable each startup. Variable is stored in eeprom. */
OD_powerOnCounter++;
while(reset != CO_RESET_APP){
/* CANopen communication reset - initialize CANopen objects *******************/
CO_ReturnError_t err;
uint16_t timer1msPrevious;
uint16_t TMR_TMR_PREV = 0;
/* disable timer and CAN interrupts */
CO_TMR_ISR_ENABLE = 0;
CO_CAN_ISR_ENABLE = 0;
CO_CAN_ISR2_ENABLE = 0;
/* initialize CANopen */
err = CO_init();
if(err != CO_ERROR_NO){
while(1) ClearWDT();
/* CO_errorReport(CO->em, CO_EM_MEMORY_ALLOCATION_ERROR, CO_EMC_SOFTWARE_INTERNAL, err); */
}
/* initialize eeprom - part 2 */
#ifdef USE_EEPROM
CO_EE_init_2(&CO_EEO, eeStatus, CO->SDO, CO->em);
#endif
/* initialize variables */
timer1msPrevious = CO_timer1ms;
OD_performance[ODA_performance_mainCycleMaxTime] = 0;
OD_performance[ODA_performance_timerCycleMaxTime] = 0;
reset = CO_RESET_NOT;
/* Configure Timer interrupt function for execution every 1 millisecond */
CO_TMR_CON = 0;
CO_TMR_TMR = 0;
#if CO_PBCLK > 65000
#error wrong timer configuration
#endif
CO_TMR_PR = CO_PBCLK - 1; /* Period register */
CO_TMR_CON = 0x8000; /* start timer (TON=1) */
CO_TMR_ISR_FLAG = 0; /* clear interrupt flag */
CO_TMR_ISR_PRIORITY = 3; /* interrupt - set lower priority than CAN (set the same value in interrupt) */
/* Configure CAN1 Interrupt (Combined) */
CO_CAN_ISR_FLAG = 0; /* CAN1 Interrupt - Clear flag */
CO_CAN_ISR_PRIORITY = 5; /* CAN1 Interrupt - Set higher priority than timer (set the same value in '#define CO_CAN_ISR_PRIORITY') */
CO_CAN_ISR2_FLAG = 0; /* CAN2 Interrupt - Clear flag */
CO_CAN_ISR2_PRIORITY = 5; /* CAN Interrupt - Set higher priority than timer (set the same value in '#define CO_CAN_ISR_PRIORITY') */
communicationReset();
/* start CAN and enable interrupts */
CO_CANsetNormalMode(ADDR_CAN1);
CO_TMR_ISR_ENABLE = 1;
CO_CAN_ISR_ENABLE = 1;
#if CO_NO_CAN_MODULES >= 2
CO_CANsetNormalMode(ADDR_CAN2);
CO_CAN_ISR2_ENABLE = 1;
#endif
while(reset == CO_RESET_NOT){
/* loop for normal program execution ******************************************/
uint16_t timer1msCopy, timer1msDiff;
ClearWDT();
/* calculate cycle time for performance measurement */
timer1msCopy = CO_timer1ms;
timer1msDiff = timer1msCopy - timer1msPrevious;
timer1msPrevious = timer1msCopy;
uint16_t t0 = CO_TMR_TMR;
uint16_t t = t0;
if(t >= TMR_TMR_PREV){
t = t - TMR_TMR_PREV;
t = (timer1msDiff * 100) + (t / (CO_PBCLK / 100));
}
else if(timer1msDiff){
t = TMR_TMR_PREV - t;
t = (timer1msDiff * 100) - (t / (CO_PBCLK / 100));
}
else t = 0;
OD_performance[ODA_performance_mainCycleTime] = t;
if(t > OD_performance[ODA_performance_mainCycleMaxTime])
OD_performance[ODA_performance_mainCycleMaxTime] = t;
TMR_TMR_PREV = t0;
/* Application asynchronous program */
programAsync(timer1msDiff);
ClearWDT();
/* CANopen process */
reset = CO_process(CO, timer1msDiff);
ClearWDT();
#ifdef USE_EEPROM
CO_EE_process(&CO_EEO);
#endif
}
}
/* program exit ***************************************************************/
CO_DISABLE_INTERRUPTS();
/* delete objects from memory */
programEnd();
CO_delete();
/* reset */
SoftReset();
}
static void task_a_8144114(u8 taskIdA)
{
if (!gPaletteFade.active)
SoftReset(0xFF);
}
/******************************************************************************
* Function: void ProcessIO(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is a place holder for other user routines.
* It is a mixture of both USB and non-USB tasks.
*
* Note: None
*****************************************************************************/
void USBUpdate(void) {
byte data[2];
byte i;
byte paramNum;
ulong tempLong;
USBDeviceTasks();
if ((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl==1)) {
return;
}
//As the device completes the enumeration process, the USBCBInitEP() function will
//get called. In this function, we initialize the user application endpoints (in this
//example code, the user application makes use of endpoint 1 IN and endpoint 1 OUT).
//The USBGenRead() function call in the USBCBInitEP() function initializes endpoint 1 OUT
//and "arms" it so that it can receive a packet of data from the host. Once the endpoint
//has been armed, the host can then send data to it (assuming some kind of application software
//is running on the host, and the application software tries to send data to the USB device).
//If the host sends a packet of data to the endpoint 1 OUT buffer, the hardware of the SIE will
//automatically receive it and store the data at the memory location pointed to when we called
//USBGenRead(). Additionally, the endpoint handle (in this case USBGenericOutHandle) will indicate
//that the endpoint is no longer busy. At this point, it is safe for this firmware to begin reading
//from the endpoint buffer, and processing the data. In this example, we have implemented a few very
//simple commands. For example, if the host sends a packet of data to the endpoint 1 OUT buffer, with the
//first byte = 0x80, this is being used as a command to indicate that the firmware should "Toggle LED(s)".
if(!USBHandleBusy(USBGenericOutHandle) && //Check if the endpoint has received any data from the host.
//Now check to make sure no previous attempts to send data to the host are still pending. If any attemps are still
//pending, we do not want to write to the endpoint 1 IN buffer again, until the previous transaction is complete.
//Otherwise the unsent data waiting in the buffer will get overwritten and will result in unexpected behavior.
(!USBGenericInHandle || !USBHandleBusy(USBGenericInHandle))) {
if (OUTPacket[USB_PACKET_LEN] < 7) {
// message too short
}
else {
usbActivityTimeout = 3000; // reset timeout (in ms) 3 seconds
switch(OUTPacket[USB_PACKET_CMD]) { //Data arrived, check what kind of command might be in the packet of data.
case USB_CMD_NULL: // 0x00
if (OUTPacket[USB_PACKET_LEN] != 7) {
data[0] = USB_ERR_BAD_LEN;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else {
UsbSendResp(USB_RESP_NULL, data);
}
break;
case USB_CMD_GET_VSTRING:
if (OUTPacket[USB_PACKET_LEN] != 7) {
data[0] = USB_ERR_BAD_LEN;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else {
UsbSendResp(USB_RESP_GET_VSTRING, data);
}
break;
case USB_CMD_GET_CHAN:
if (OUTPacket[USB_PACKET_LEN] != 7) {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else if (OUTPacket[USB_PACKET_STR] >= NUM_STRINGS) {
data[0] = USB_ERR_BAD_PRM;
data[1] = 0;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else if (!OUTPacket[USB_PACKET_MCT] || OUTPacket[USB_PACKET_MCT] > NUM_MCT) {
data[0] = USB_ERR_BAD_PRM;
data[1] = 1;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else {
UsbSendResp(USB_RESP_GET_CHAN, data);
}
break;
case USB_CMD_GET_MIRRORS:
if (OUTPacket[USB_PACKET_LEN] != 7) {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else if (OUTPacket[USB_PACKET_STR] >= NUM_STRINGS) {
data[0] = USB_ERR_BAD_PRM;
data[1] = 0;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else if (!OUTPacket[USB_PACKET_MCT] || OUTPacket[USB_PACKET_MCT] > NUM_MCT) {
data[0] = USB_ERR_BAD_PRM;
data[1] = 1;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else {
UsbSendResp(USB_RESP_GET_MIRRORS, data);
}
break;
case USB_CMD_GET_STRING:
if (OUTPacket[USB_PACKET_LEN] != 7) {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else if (OUTPacket[USB_PACKET_STR] >= NUM_STRINGS) {
data[0] = USB_ERR_BAD_PRM;
data[1] = 0;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
else {
UsbSendResp(USB_RESP_GET_STRING, data);
}
break;
case USB_CMD_FIELD_STATE:
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_FIELD_STATE, data);
}
else if (OUTPacket[USB_PACKET_LEN] == 8) {
FieldNewState(OUTPacket[USB_PACKET_DATA]);
UsbSendResp(USB_RESP_FIELD_STATE, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_GET_FCE:
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_GET_FCE, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_GET_RTU:
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_GET_RTU, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_SEND_MCT485: // 0x64
if (OUTPacket[USB_PACKET_LEN] >= 11
&& OUTPacket[USB_PACKET_LEN] < MCT485_MAX_INDEX + 7) {
//Mct485CannedMsg(MSG_ORIGIN_USB,
// OUTPacket[USB_PACKET_STR],
// OUTPacket[USB_PACKET_LEN]-7,
// &OUTPacket[USB_PACKET_DATA]);
usb485TxString = OUTPacket[USB_PACKET_STR];
usb485TxLen = OUTPacket[USB_PACKET_LEN]-7;
for (i = 0; i < usb485TxLen; i++) {
usb485TxBuffer[i] = OUTPacket[USB_PACKET_DATA+i];
}
// clear 485 response buffer
usb485RxLen = 0;
UsbSendResp(USB_RESP_SEND_MCT485, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_GET_MCT485: // 0x65
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_GET_MCT485, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_RTC: // 0x66
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_RTC, data);
}
else if (OUTPacket[USB_PACKET_LEN] == 13) {
RtcSetClock(&OUTPacket[USB_PACKET_DATA]);
UsbSendResp(USB_RESP_RTC, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_LOG: // 0x67
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_LOG, data);
}
else if (OUTPacket[USB_PACKET_LEN] == 8) {
if (OUTPacket[USB_PACKET_DATA] == 0) {
DataLogFindFirstEntry();
}
else if (OUTPacket[USB_PACKET_DATA] == 0xFF) {
DataLogErase();
}
UsbSendResp(USB_RESP_LOG, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_DESICCANT: // 0x68
if (OUTPacket[USB_PACKET_LEN] == 7) {
UsbSendResp(USB_RESP_DESICCANT, data);
}
else if (OUTPacket[USB_PACKET_LEN] == 9) {
// manual force dessicant to set of outputs or state
DesiccantNewState(OUTPacket[USB_PACKET_DATA], OUTPacket[USB_PACKET_DATA+1]);
UsbSendResp(USB_RESP_DESICCANT, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_SFC_PARAM: // 0x69
if (OUTPacket[USB_PACKET_LEN] == 8) {
UsbSendResp(USB_RESP_SFC_PARAM, data);
}
else if (OUTPacket[USB_PACKET_LEN] > 8 && !(OUTPacket[USB_PACKET_LEN] & 0x03)) {
// process one param at a time, prevents I2C queue entry overflow and avoids
// I2C page boundary problems
paramNum = OUTPacket[USB_PACKET_DATA];
i = USB_PACKET_DATA+1;
while (i < OUTPacket[USB_PACKET_LEN]-2) {
tempLong = OUTPacket[i++];
tempLong *= 256;
tempLong += OUTPacket[i++];
tempLong *= 256;
tempLong += OUTPacket[i++];
tempLong *= 256;
tempLong += OUTPacket[i++];
ParamWrite(paramNum, tempLong);
paramNum++;
}
UsbSendResp(USB_RESP_SFC_PARAM, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_MEMORY: // 0x6A
if (OUTPacket[USB_PACKET_LEN] == 11) {
data[4] = 16;
UsbSendResp(USB_RESP_MEMORY, data);
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
case USB_CMD_TEST: // 0x6B
if (OUTPacket[USB_PACKET_LEN] == 8) {
UsbSendResp(USB_RESP_TEST, data);
for (tempLong = 0; tempLong < 1000000; tempLong++) {
}
if (OUTPacket[USB_PACKET_DATA] == 0x01) {
Mct485Init();
}
else if (OUTPacket[USB_PACKET_DATA] == 0x02) {
StringInit();
}
else if (OUTPacket[USB_PACKET_DATA] == 0x03) {
FieldInit();
}
else if (OUTPacket[USB_PACKET_DATA] == 0x04) {
SoftReset();
}
}
else {
data[0] = USB_ERR_BAD_LEN;
data[1] = 7;
UsbSendResp(USB_RESP_BAD_MSG, data);
}
break;
} // switch (cmd)
} // else process messages
//Re-arm the OUT endpoint for the next packet:
//The USBGenRead() function call "arms" the endpoint (and makes it "busy"). If the endpoint is armed, the SIE will
//automatically accept data from the host, if the host tries to send a packet of data to the endpoint. Once a data
//packet addressed to this endpoint is received from the host, the endpoint will no longer be busy, and the application
//can read the data which will be sitting in the buffer.
USBGenericOutHandle = USBGenRead(USBGEN_EP_NUM,(BYTE*)&OUTPacket,USBGEN_EP_SIZE);
} // if
}// UsbUpdate()
static int cbHeaderComplete(http_parser* parser) {
if(parser->status_code == 200)
SoftReset();
else
return 1;
}
/*
* UEFI Reset () function
*
*/
EFI_STATUS
EFIAPI
SnpReset (
IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
IN BOOLEAN Verification
)
{
UINT32 PmConf;
UINT32 HwConf;
UINT32 ResetFlags;
EFI_STATUS Status;
PmConf = 0;
HwConf = 0;
ResetFlags = 0;
// Check Snp Instance
if (Snp == NULL) {
return EFI_INVALID_PARAMETER;
}
// First check that driver has not already been initialized
if (Snp->Mode->State == EfiSimpleNetworkStarted) {
DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not yet initialized\n"));
return EFI_DEVICE_ERROR;
} else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not started\n"));
return EFI_NOT_STARTED;
}
// Initiate a PHY reset
Status = PhySoftReset (PHY_RESET_PMT, Snp);
if (EFI_ERROR (Status)) {
Snp->Mode->State = EfiSimpleNetworkStopped;
return EFI_NOT_STARTED;
}
// Initiate a software reset
ResetFlags |= SOFT_RESET_CHECK_MAC_ADDR_LOAD | SOFT_RESET_CLEAR_INT;
if (Verification) {
ResetFlags |= SOFT_RESET_SELF_TEST;
}
Status = SoftReset (ResetFlags, Snp);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_WARN, "Warning: Soft Reset Failed: Hardware Error\n"));
return EFI_DEVICE_ERROR;
}
// Read the PM register
PmConf = MmioRead32 (LAN9118_PMT_CTRL);
// MPTCTRL_WOL_EN: Allow Wake-On-Lan to detect wake up frames or magic packets
// MPTCTRL_ED_EN: Allow energy detection to allow lowest power consumption mode
// MPTCTRL_PME_EN: Allow Power Management Events
PmConf |= (MPTCTRL_WOL_EN | MPTCTRL_ED_EN | MPTCTRL_PME_EN);
// Write the current configuration to the register
MmioWrite32 (LAN9118_PMT_CTRL, PmConf);
gBS->Stall (LAN9118_STALL);
// Check that a buffer size was specified in SnpInitialize
if (gTxBuffer != 0) {
HwConf = MmioRead32 (LAN9118_HW_CFG); // Read the HW register
HwConf &= ~HW_CFG_TX_FIFO_SIZE_MASK; // Clear buffer bits first
HwConf |= HW_CFG_TX_FIFO_SIZE(gTxBuffer); // assign size chosen in SnpInitialize
MmioWrite32 (LAN9118_HW_CFG, HwConf); // Write the conf
gBS->Stall (LAN9118_STALL);
}
// Enable the receiver and transmitter and clear their contents
StartRx (START_RX_CLEAR, Snp);
StartTx (START_TX_MAC | START_TX_CFG | START_TX_CLEAR, Snp);
// Now acknowledge all interrupts
MmioWrite32 (LAN9118_INT_STS, ~0);
return EFI_SUCCESS;
}
static BOOL MessageDone() {
// TODO: check pin capabilities
switch (rx_msg.type) {
case HARD_RESET:
CHECK(rx_msg.args.hard_reset.magic == IOIO_MAGIC);
HardReset();
break;
case SOFT_RESET:
SoftReset();
Echo();
break;
case SET_PIN_DIGITAL_OUT:
CHECK(rx_msg.args.set_pin_digital_out.pin < NUM_PINS);
SetPinDigitalOut(rx_msg.args.set_pin_digital_out.pin,
rx_msg.args.set_pin_digital_out.value,
rx_msg.args.set_pin_digital_out.open_drain);
break;
case SET_DIGITAL_OUT_LEVEL:
CHECK(rx_msg.args.set_digital_out_level.pin < NUM_PINS);
SetDigitalOutLevel(rx_msg.args.set_digital_out_level.pin,
rx_msg.args.set_digital_out_level.value);
break;
case SET_PIN_DIGITAL_IN:
CHECK(rx_msg.args.set_pin_digital_in.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_digital_in.pull < 3);
SetPinDigitalIn(rx_msg.args.set_pin_digital_in.pin, rx_msg.args.set_pin_digital_in.pull);
break;
case SET_CHANGE_NOTIFY:
CHECK(rx_msg.args.set_change_notify.pin < NUM_PINS);
if (rx_msg.args.set_change_notify.cn) {
Echo();
}
SetChangeNotify(rx_msg.args.set_change_notify.pin, rx_msg.args.set_change_notify.cn);
if (!rx_msg.args.set_change_notify.cn) {
Echo();
}
break;
case SET_PIN_PWM:
CHECK(rx_msg.args.set_pin_pwm.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_pwm.pwm_num < NUM_PWM_MODULES);
SetPinPwm(rx_msg.args.set_pin_pwm.pin, rx_msg.args.set_pin_pwm.pwm_num,
rx_msg.args.set_pin_pwm.enable);
break;
case SET_PWM_DUTY_CYCLE:
CHECK(rx_msg.args.set_pwm_duty_cycle.pwm_num < NUM_PWM_MODULES);
SetPwmDutyCycle(rx_msg.args.set_pwm_duty_cycle.pwm_num,
rx_msg.args.set_pwm_duty_cycle.dc,
rx_msg.args.set_pwm_duty_cycle.fraction);
break;
case SET_PWM_PERIOD:
CHECK(rx_msg.args.set_pwm_period.pwm_num < NUM_PWM_MODULES);
SetPwmPeriod(rx_msg.args.set_pwm_period.pwm_num,
rx_msg.args.set_pwm_period.period,
rx_msg.args.set_pwm_period.scale_l
| (rx_msg.args.set_pwm_period.scale_h) << 1);
break;
case SET_PIN_ANALOG_IN:
CHECK(rx_msg.args.set_pin_analog_in.pin < NUM_PINS);
SetPinAnalogIn(rx_msg.args.set_pin_analog_in.pin);
break;
case UART_DATA:
CHECK(rx_msg.args.uart_data.uart_num < NUM_UART_MODULES);
UARTTransmit(rx_msg.args.uart_data.uart_num,
rx_msg.args.uart_data.data,
rx_msg.args.uart_data.size + 1);
break;
case UART_CONFIG:
CHECK(rx_msg.args.uart_config.uart_num < NUM_UART_MODULES);
CHECK(rx_msg.args.uart_config.parity < 3);
UARTConfig(rx_msg.args.uart_config.uart_num,
rx_msg.args.uart_config.rate,
rx_msg.args.uart_config.speed4x,
rx_msg.args.uart_config.two_stop_bits,
rx_msg.args.uart_config.parity);
break;
case SET_PIN_UART:
CHECK(rx_msg.args.set_pin_uart.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_uart.uart_num < NUM_UART_MODULES);
SetPinUart(rx_msg.args.set_pin_uart.pin,
rx_msg.args.set_pin_uart.uart_num,
rx_msg.args.set_pin_uart.dir,
rx_msg.args.set_pin_uart.enable);
break;
case SPI_MASTER_REQUEST:
CHECK(rx_msg.args.spi_master_request.spi_num < NUM_SPI_MODULES);
CHECK(rx_msg.args.spi_master_request.ss_pin < NUM_PINS);
{
const BYTE total_size = rx_msg.args.spi_master_request.total_size + 1;
const BYTE data_size = rx_msg.args.spi_master_request.data_size_neq_total
? rx_msg.args.spi_master_request.data_size
: total_size;
const BYTE res_size = rx_msg.args.spi_master_request.res_size_neq_total
? rx_msg.args.spi_master_request.vararg[
rx_msg.args.spi_master_request.data_size_neq_total]
: total_size;
const BYTE* const data = &rx_msg.args.spi_master_request.vararg[
rx_msg.args.spi_master_request.data_size_neq_total
+ rx_msg.args.spi_master_request.res_size_neq_total];
SPITransmit(rx_msg.args.spi_master_request.spi_num,
rx_msg.args.spi_master_request.ss_pin,
data,
data_size,
total_size,
total_size - res_size);
}
break;
case SPI_CONFIGURE_MASTER:
CHECK(rx_msg.args.spi_configure_master.spi_num < NUM_SPI_MODULES);
SPIConfigMaster(rx_msg.args.spi_configure_master.spi_num,
rx_msg.args.spi_configure_master.scale,
rx_msg.args.spi_configure_master.div,
rx_msg.args.spi_configure_master.smp_end,
rx_msg.args.spi_configure_master.clk_edge,
rx_msg.args.spi_configure_master.clk_pol);
break;
case SET_PIN_SPI:
CHECK(rx_msg.args.set_pin_spi.mode < 3);
CHECK((!rx_msg.args.set_pin_spi.enable
&& rx_msg.args.set_pin_spi.mode == 1)
|| rx_msg.args.set_pin_spi.pin < NUM_PINS);
CHECK((!rx_msg.args.set_pin_spi.enable
&& rx_msg.args.set_pin_spi.mode != 1)
|| rx_msg.args.set_pin_spi.spi_num < NUM_SPI_MODULES);
SetPinSpi(rx_msg.args.set_pin_spi.pin,
rx_msg.args.set_pin_spi.spi_num,
rx_msg.args.set_pin_spi.mode,
rx_msg.args.set_pin_spi.enable);
break;
case I2C_CONFIGURE_MASTER:
CHECK(rx_msg.args.i2c_configure_master.i2c_num < NUM_I2C_MODULES);
I2CConfigMaster(rx_msg.args.i2c_configure_master.i2c_num,
rx_msg.args.i2c_configure_master.rate,
rx_msg.args.i2c_configure_master.smbus_levels);
break;
case I2C_WRITE_READ:
CHECK(rx_msg.args.i2c_write_read.i2c_num < NUM_I2C_MODULES);
{
unsigned int addr;
if (rx_msg.args.i2c_write_read.ten_bit_addr) {
addr = rx_msg.args.i2c_write_read.addr_lsb;
addr = addr << 8
| ((rx_msg.args.i2c_write_read.addr_msb << 1)
| 0b11110000);
} else {
CHECK(rx_msg.args.i2c_write_read.addr_msb == 0
&& rx_msg.args.i2c_write_read.addr_lsb >> 7 == 0
&& rx_msg.args.i2c_write_read.addr_lsb >> 2 != 0b0011110);
addr = rx_msg.args.i2c_write_read.addr_lsb << 1;
}
I2CWriteRead(rx_msg.args.i2c_write_read.i2c_num,
addr,
rx_msg.args.i2c_write_read.data,
rx_msg.args.i2c_write_read.write_size,
rx_msg.args.i2c_write_read.read_size);
}
break;
case SET_ANALOG_IN_SAMPLING:
CHECK(rx_msg.args.set_analog_pin_sampling.pin < NUM_PINS);
ADCSetScan(rx_msg.args.set_analog_pin_sampling.pin,
rx_msg.args.set_analog_pin_sampling.enable);
break;
case CHECK_INTERFACE:
CheckInterface(rx_msg.args.check_interface.interface_id);
break;
case ICSP_SIX:
ICSPSix(rx_msg.args.icsp_six.inst);
break;
case ICSP_REGOUT:
ICSPRegout();
break;
case ICSP_PROG_ENTER:
ICSPEnter();
break;
case ICSP_PROG_EXIT:
ICSPExit();
break;
case ICSP_CONFIG:
if (rx_msg.args.icsp_config.enable) {
Echo();
}
ICSPConfigure(rx_msg.args.icsp_config.enable);
if (!rx_msg.args.icsp_config.enable) {
Echo();
}
break;
case INCAP_CONFIG:
CHECK(rx_msg.args.incap_config.incap_num < NUM_INCAP_MODULES);
CHECK(!rx_msg.args.incap_config.double_prec
|| 0 == (rx_msg.args.incap_config.incap_num & 0x01));
CHECK(rx_msg.args.incap_config.mode < 6);
CHECK(rx_msg.args.incap_config.clock < 4);
InCapConfig(rx_msg.args.incap_config.incap_num,
rx_msg.args.incap_config.double_prec,
rx_msg.args.incap_config.mode,
rx_msg.args.incap_config.clock);
break;
case SET_PIN_INCAP:
CHECK(rx_msg.args.set_pin_incap.incap_num < NUM_INCAP_MODULES);
CHECK(!rx_msg.args.set_pin_incap.enable
|| rx_msg.args.set_pin_incap.pin < NUM_PINS);
SetPinInCap(rx_msg.args.set_pin_incap.pin,
rx_msg.args.set_pin_incap.incap_num,
rx_msg.args.set_pin_incap.enable);
break;
case SOFT_CLOSE:
log_printf("Soft close requested");
Echo();
state = STATE_CLOSING;
break;
case SET_PIN_PULSECOUNTER:
CHECK(rx_msg.args.set_pin_pulsecounter.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_pulsecounter.mode < 4);
CHECK(rx_msg.args.set_pin_pulsecounter.rateord < 9);
CHECK(rx_msg.args.set_pin_pulsecounter.stepsord < 4);
SetPinPulseCounter(rx_msg.args.set_pin_pulsecounter.pin,
rx_msg.args.set_pin_pulsecounter.enable,
rx_msg.args.set_pin_pulsecounter.mode,
rx_msg.args.set_pin_pulsecounter.rateord,
rx_msg.args.set_pin_pulsecounter.stepsord);
break;
// BOOKMARK(add_feature): Add incoming message handling to switch clause.
// Call Echo() if the message is to be echoed back.
default:
return FALSE;
}
return TRUE;
}
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
BCSCTL1 = CALBC1_1MHZ; // Set range
DCOCTL = CALDCO_1MHZ; // Set DCO step + modulation
// the only INPUT pin is P1.3 (INT1)
P1DIR = 0xFF;
P1DIR &= ~BIT3;
P1OUT = 0;
P2DIR = 0xFF;
P2OUT = 0;
P2SEL = 0;
//P1DIR = BIT6 | BIT5 | BIT0 | BIT1 | BIT2 | BIT4; -- old code
USICTL0 |= USIPE7 + USIPE6 + USIPE5 + USIMST + USIOE; // setup SPI mode
USICTL0 |= USISWRST; // enable software reset to begin spi init
// setup clock polarity and edge
USICKCTL &= ~USICKPL;
USICTL1 = USICKPH;
USICKCTL |= USIDIV_2 | USISSEL_2; // SPI clock
USICTL0 &= ~USISWRST; // release USI for operation
// CS disable, set CS high
P1OUT |= BIT1;
SoftReset();
// Turn on LED P1.2 if ADXL362 is not found
// result = Identify();
// if (result==0xAD)
// P1OUT &= ~BIT2;
// else
// P1OUT |= BIT2;
// turn off LED 1.2
P1OUT &= ~BIT2;
// turn off LED P1.4
P1OUT &= ~BIT4;
// set activity threshold to 100 mg
WriteByteToRegister( 0x20, 0x64 );
WriteByteToRegister( 0x21, 0x0 );
// Default Mode and Referenced Activity only (don't care about Inactivity)
WriteByteToRegister( 0x27, 0x3 );
// map activity status to int1
WriteByteToRegister( 0x2A, 0x10 );
// begin measurement in wakeup mode
WriteByteToRegister( 0x2D, 0x0A );
// interrupt check on P1.3
P1IE = BIT3;
P1IES &= ~BIT3; // rise edge
P1IFG &= ~BIT3; // P1.3 IFG cleared
_BIS_SR(LPM4_bits + GIE);
}
