uint8 RDA_bt_SerialCommTxByte(uint8 data) /* return 0 --> ack */
{
int32 i;
uint8 temp_value = 0;
for(i=7; (i>=0)&&(i<=7); i--)
{
GPIO_WriteIO( 0, RDA5868_SCL); /* low */
DELAY(DURATION_LOW);
if(i==7)GPIO_InitIO(1,RDA5868_SDA);
DELAY(DURATION_LOW);
GPIO_WriteIO(((data>>i)&0x01), RDA5868_SDA);
DELAY(DURATION_LOW/2);
GPIO_WriteIO( 1, RDA5868_SCL); /* high */
DELAY(DURATION_HIGH);
}
GPIO_WriteIO(0, RDA5868_SCL); /* low */
DELAY(DURATION_LOW);
GPIO_InitIO(0,RDA5868_SDA);/* input */
DELAY(DURATION_LOW/2);
GPIO_WriteIO(1, RDA5868_SCL); /* high */
DELAY(DURATION_HIGH);
temp_value = GPIO_ReadIO(RDA5868_SDA);
GPIO_WriteIO(0, RDA5868_SCL); /* low */
DELAY(DURATION_LOW);
return temp_value;
}
kal_uint8 SerialCommRxByte(kal_uint8 addr, kal_uint8 *data)
{
kal_int16 i;
kal_uint16 dataRead=0;
*data = 0;
GPIO_WriteIO(1, LE);
GPIO_InitIO(1,SDA);
for(i=8; --i>=0;){
GPIO_WriteIO( 0, SCL);
GPIO_WriteIO(addr&0x01, SDA);
GPIO_WriteIO(1, SCL);
addr >>= 1;
I2C_DUMMY_DELAY(5);
}
GPIO_InitIO(0,SDA);
GPIO_WriteIO(0, LE);
for(i=0; i<8; i++){
GPIO_WriteIO( 0, SCL);
I2C_DUMMY_DELAY(5);
GPIO_WriteIO( 1, SCL);
dataRead = GPIO_ReadIO(SDA);
*data |= (dataRead << i);
}
I2C_DUMMY_DELAY(10);
}
void RDA_bt_SerialCommRxByte(uint8 *data, uint8 ack)
{
int32 i;
uint32 dataCache;
dataCache = 0;
for(i=7; (i>=0)&&(i<=7); i--)
{
GPIO_WriteIO(0, RDA5868_SCL);
DELAY(DURATION_LOW);
if(i==7)GPIO_InitIO(0,RDA5868_SDA);
DELAY(DURATION_LOW);
GPIO_WriteIO(1, RDA5868_SCL);
DELAY(DURATION_HIGH);
dataCache |= (GPIO_ReadIO(RDA5868_SDA)<<i);
DELAY(DURATION_LOW/2);
}
GPIO_WriteIO(0, RDA5868_SCL);
DELAY(DURATION_LOW);
GPIO_InitIO(1,RDA5868_SDA);
GPIO_WriteIO(ack, RDA5868_SDA);
DELAY(DURATION_LOW/2);
GPIO_WriteIO(1, RDA5868_SCL);
DELAY(DURATION_HIGH);
GPIO_WriteIO(0, RDA5868_SCL); /* low */
DELAY(DURATION_LOW);
*data = (uint8)dataCache;
}
/******************************************************************************
* Function:
* GPSLocateVibSensorStart
*
* Usage:
* Start vibration sensor monitor
*
* Parameters:
* None
*
* Return:
* None
******************************************************************************/
void GPSLocateVibSensorStart(void)
{
kal_bool bResult;
kal_uint8 SilenceThreshold;
if (gGPSVibSensorTimer != NULL)
{
//has already started, do nothing
return;
}
bResult = GPSLocateNvramReadRecord(
GPS_NVRAM_RECID_VIBSENSOR_POLLINGINTERVAL,
&gGPSVibSensorPollingInterval,
sizeof(kal_uint8)
);
if (bResult != KAL_TRUE)
{
return;
}
bResult = GPSLocateNvramReadRecord(
GPS_NVRAM_RECID_VIBSENSOR_SILENCETHRESHOLD,
&SilenceThreshold,
sizeof(kal_uint8)
);
if (bResult != KAL_TRUE)
{
return;
}
/*
NOTE:
unit of SilenceThreshold is minute
unit of gGPSVibSensorPollingInterval is 50ms
so, the following convert is needed.
*/
gGPSVibSensorSilenceThreshold = (SilenceThreshold*60*1000)/(gGPSVibSensorPollingInterval*50);
gGPSVibSensorTimer = GPSAppTimer_Create(
GENERAL_GPSAPP_TIMERID,
GPSLocateVibSensorExpireProc,
gGPSVibSensorPollingInterval*KAL_TICKS_50_MSEC,
gGPSVibSensorPollingInterval*KAL_TICKS_50_MSEC,
KAL_TRUE
);
/*
Configurate GPIO: input, pull-up/down disable
*/
GPIO_ModeSetup(GPS_VIBRATION_SENSOR_GPIO, 0);
GPIO_InitIO(INPUT, GPS_VIBRATION_SENSOR_GPIO);
GPIO_PullenSetup(GPS_VIBRATION_SENSOR_GPIO, KAL_FALSE);
//get the initial IO value
gGPSVibSensorPreviousIOValue = GPIO_ReadIO(GPS_VIBRATION_SENSOR_GPIO);
//initialize the state
gGPSVibSensorCurrState = GPSLOCATE_VIBSENSORSTATUS_SILENCE;
//initialize silence counter
gSilenceCounter = 0;
}
uint8 SerialCommTxByte(uint8 data) /* return 0 --> ack */
{
int32 i;
for(i=7; i>=0; i--) {
GPIO_WriteIO( 0, SCL); /* low */
/* The bus operates at a maximum clock frequency of 400 kHz */
if(i==7)GPIO_InitIO(1,SDA); // dummy
GPIO_WriteIO(((data>>i)&0x01), SDA);
GPIO_WriteIO( 1, SCL); /* high */
}
GPIO_WriteIO(0, SCL); /* low */
GPIO_InitIO(0,SDA);
GPIO_WriteIO(1, SCL); /* high */
return GPIO_ReadIO(SDA);
}
void SerialCommRxByte(uint8 *data, uint8 ack)
{
int32 i;
uint32 dataCache;
dataCache = 0;
for(i=7; i>=0; i--) {
GPIO_WriteIO(0, SCL);
if(i==7)GPIO_InitIO(0,SDA);
GPIO_WriteIO(1, SCL);
dataCache |= (GPIO_ReadIO(SDA)<<i);
}
GPIO_WriteIO(0, SCL);
GPIO_InitIO(1,SDA);
GPIO_WriteIO(ack, SDA);
GPIO_WriteIO(1, SCL);
*data = (uint8)dataCache;
}
void SerialCommRxByte(kal_uint8 *data, kal_uint8 ack)
{
kal_int16 i;
kal_uint32 dataCache;
dataCache = 0;
GPIO_InitIO(0,SDA);
for(i=8; --i>=0;){
dataCache <<= 1;
GPIO_WriteIO(1, SCL);
I2C_DUMMY_DELAY(5);
dataCache |= GPIO_ReadIO(SDA);
GPIO_WriteIO(0, SCL);
I2C_DUMMY_DELAY(5);
}
GPIO_InitIO(1,SDA);
GPIO_WriteIO(ack, SDA);
I2C_DUMMY_DELAY(5);
GPIO_WriteIO(1, SCL);
*data = (kal_uint8)dataCache;
GPIO_WriteIO(0, SCL);
}
void SerialCommRxByte(uint8 *data, uint8 ack)
{
int32 i;
uint32 dataCache;
dataCache = 0;
for(i=7; i>=0; i--){
GPIO_WriteIO(0, SCL);
if(i==7)GPIO_InitIO(0,SDA);
{ // For EV200 only, solve a hardware bug
kal_int32 cnt; // dummy for_loop
for(cnt=0; cnt<20; cnt++);
}
GPIO_WriteIO(1, SCL);
dataCache |= (GPIO_ReadIO(SDA)<<i);
}
GPIO_WriteIO(0, SCL);
GPIO_InitIO(1,SDA);
GPIO_WriteIO(ack, SDA);
GPIO_WriteIO(1, SCL);
*data = (uint8)dataCache;
}
void SerialCommRxByte(unsigned char *data, unsigned char ack)
{
int i;
unsigned int dataCache;
dataCache = 0;
GPIO_InitIO(INPUT,SDA);
for(i=8; --i>=0;){
dataCache <<= 1;
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO(1, SCL);
I2C_DUMMY_DELAY(I2C_DELAY);
dataCache |= GPIO_ReadIO(SDA);
GPIO_WriteIO(0, SCL);
I2C_DUMMY_DELAY(I2C_DELAY);
}
GPIO_InitIO(OUTPUT,SDA);
GPIO_WriteIO(ack, SDA);
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO(1, SCL);
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO(0, SCL);
I2C_DUMMY_DELAY(I2C_DELAY);
*data = (unsigned char)dataCache;
}
unsigned int SerialCommTxByte(unsigned char data) /* return 0 --> ack */
{
int i, ack;
GPIO_InitIO(OUTPUT,SDA);
for(i=8; --i>0;){
GPIO_WriteIO((data>>i)&0x01, SDA);
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO( 1, SCL); /* high */
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO( 0, SCL); /* low */
I2C_DUMMY_DELAY(I2C_DELAY);
}
GPIO_WriteIO((data>>i)&0x01, SDA);
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO( 1, SCL); /* high */
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO( 0, SCL); /* low */
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO(0, SDA);
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_InitIO(INPUT,SDA);
I2C_DUMMY_DELAY(I2C_DELAY);
GPIO_WriteIO(1, SCL);
I2C_DUMMY_DELAY(I2C_DELAY);
ack = GPIO_ReadIO(SDA); /// ack 1: error , 0:ok
GPIO_WriteIO(0, SCL);
I2C_DUMMY_DELAY(I2C_DELAY);
if(ack==1)
return 0;
else
return 1;
}
kal_uint8 SerialCommTxByte(kal_uint8 data) /* return 0 --> ack */
{
kal_int16 i, ack;
GPIO_InitIO(1,SDA);
for(i=8; --i>0;){
GPIO_WriteIO((data>>i)&0x01, SDA);
I2C_DUMMY_DELAY(5);
GPIO_WriteIO( 1, SCL); /* high */
I2C_DUMMY_DELAY(5);
GPIO_WriteIO( 0, SCL); /* low */
I2C_DUMMY_DELAY(5);
}
GPIO_WriteIO((data>>i)&0x01, SDA);
I2C_DUMMY_DELAY(5);
GPIO_WriteIO( 1, SCL); /* high */
I2C_DUMMY_DELAY(5);
GPIO_WriteIO( 0, SCL); /* low */
GPIO_InitIO(0,SDA);
GPIO_WriteIO(1, SCL);
I2C_DUMMY_DELAY(5);
ack = GPIO_ReadIO(SDA); /// ack
GPIO_WriteIO(0, SCL);
}
static void GPSLocateVibSensorExpireProc(GPSAppTimerID_t Id)
{
char CurrIOValue;
CurrIOValue = GPIO_ReadIO(GPS_VIBRATION_SENSOR_GPIO);
#if _VIBSENSOR_DBG_
trace_printf("VSEP: CIO=%d, PIO=%d", CurrIOValue, gGPSVibSensorPreviousIOValue);
trace_printf("VSEP: CS=%d", gGPSVibSensorCurrState);
trace_printf("VSEP: SC=%d, ST=%d", gSilenceCounter, gGPSVibSensorSilenceThreshold);
#endif //_VIBSENSOR_DBG_
if (CurrIOValue != gGPSVibSensorPreviousIOValue)
{
///////// status changed ///////////
// 1. save the current IO value as the previous one
gGPSVibSensorPreviousIOValue = CurrIOValue;
// 2. clear the silence counter
gSilenceCounter = 0;
// 3. check and post vibration message if needed
if (gGPSVibSensorCurrState == GPSLOCATE_VIBSENSORSTATUS_SILENCE)
{
//post vibration message
GPSLocateVibSensorStatusIndStruct_t *pStatusInd;
pStatusInd = (GPSLocateVibSensorStatusIndStruct_t*)construct_local_para(sizeof(GPSLocateVibSensorStatusIndStruct_t), TD_UL);
pStatusInd->Status = GPSLOCATE_VIBSENSORSTATUS_VIBRATING;
SendMsg2GPSApp(
stack_int_get_active_module_id(),
MSG_ID_GPSLOCATE_VIBSENSORSTATUS_IND,
(void*)pStatusInd
);
#if _VIBSENSOR_DBG_
trace_printf("VSEP: V");
#endif //_VIBSENSOR_DBG_
//change state
gGPSVibSensorCurrState = GPSLOCATE_VIBSENSORSTATUS_VIBRATING;
}
}
else
{
////////// status not changed ///////////////
gSilenceCounter++;
if (gGPSVibSensorCurrState == GPSLOCATE_VIBSENSORSTATUS_VIBRATING
&& gSilenceCounter >= gGPSVibSensorSilenceThreshold)
{
//////// consider as silence ///////////
//post silence message
GPSLocateVibSensorStatusIndStruct_t *pStatusInd;
pStatusInd = (GPSLocateVibSensorStatusIndStruct_t*)construct_local_para(sizeof(GPSLocateVibSensorStatusIndStruct_t), TD_UL);
pStatusInd->Status = GPSLOCATE_VIBSENSORSTATUS_SILENCE;
SendMsg2GPSApp(
stack_int_get_active_module_id(),
MSG_ID_GPSLOCATE_VIBSENSORSTATUS_IND,
(void*)pStatusInd
);
#if _VIBSENSOR_DBG_
trace_printf("VSEP: S");
#endif //_VIBSENSOR_DBG_
//change state
gGPSVibSensorCurrState = GPSLOCATE_VIBSENSORSTATUS_SILENCE;
}
}
}
DCL_STATUS DclGPIO_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
{
kal_char port;
port= 0x000000FF & handle;
if(DCL_HANDLE_INVALID==handle)
return STATUS_FAIL;
if(DCL_GPIO_IS_HANDLE_MAGIC(handle))
{
switch(cmd)
{
case GPIO_CMD_READ:
{
GPIO_CTRL_READ_T *prRead;
prRead = &(data->rRead);
prRead->u1IOData = GPIO_ReadIO(port);
break;
}
case GPIO_CMD_WRITE_LOW:
{
GPIO_MD_WriteIO(GPIO_IO_LOW, port);
break;
}
case GPIO_CMD_WRITE_HIGH:
{
GPIO_MD_WriteIO(GPIO_IO_HIGH, port);
break;
}
case GPIO_CMD_SET_MODE_0:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_0);
break;
}
case GPIO_CMD_SET_MODE_1:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_1);
break;
}
case GPIO_CMD_SET_MODE_2:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_2);
break;
}
case GPIO_CMD_SET_MODE_3:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_3);
break;
}
case GPIO_CMD_SET_MODE_4: //mode4-7 only for chip support more than 3bit mode control.
{
GPIO_MD_ModeSetup(port, GPIO_MODE_4);
break;
}
case GPIO_CMD_SET_MODE_5:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_5);
break;
}
case GPIO_CMD_SET_MODE_6:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_6);
break;
}
case GPIO_CMD_SET_MODE_7:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_7);
break;
}
case GPIO_CMD_SET_MODE_8:
{
GPIO_MD_ModeSetup(port, GPIO_MODE_8);
break;
}
case GPIO_CMD_SET_DIR_OUT:
{
GPIO_MD_InitIO(GPIO_DIR_OUT,port);
break;
}
case GPIO_CMD_SET_DIR_IN:
{
GPIO_MD_InitIO(GPIO_DIR_IN,port);
break;
}
case GPIO_CMD_ENABLE_PULL:
{
GPIO_MD_PullenSetup(port, (kal_bool)GPIO_PULL_ENABLE);
break;
}
case GPIO_CMD_DISABLE_PULL:
{
GPIO_MD_PullenSetup(port, (kal_bool)GPIO_PULL_DISABLE);
break;
}
case GPIO_CMD_SET_PULL_HIGH:
{
GPIO_PullSelSetup(port,(kal_bool) GPIO_PULL_HIGH);
break;
}
case GPIO_CMD_SET_PULL_LOW:
{
GPIO_MD_PullSelSetup(port, (kal_bool)GPIO_PULL_LOW);
break;
}
case GPIO_CMD_SET_DINV:
{
GPIO_CTRL_SET_DINV_T *prSetDinv;
prSetDinv = &(data->rSetDinv);
GPIO_MD_DinvSetup(port,(kal_bool)( prSetDinv->fgSetDinv));
break;
}
case GPIO_CMD_GET_AP_PIN:
{
GPIO_CTRL_RETURN_AP_T *prGetApData;
prGetApData=&(data->rReturnAp);
prGetApData->u1RetApData=port;
break;
}
#ifdef __CUST_NEW__
case GPIO_CMD_SET_DIR_OUT_NO_IRQ_MASK:
{
GPIO_InitIO_FAST(GPIO_DIR_OUT,port);
break;
}
case GPIO_CMD_SET_DIR_IN_NO_IRQ_MASK:
{
GPIO_InitIO_FAST(GPIO_DIR_IN,port);
break;
}
case GPIO_CMD_WRITE_HIGH_NO_IRQ_MASK:
{
GPIO_WriteIO_FAST(GPIO_IO_HIGH,port);
break;
}
case GPIO_CMD_WRITE_LOW_NO_IRQ_MASK:
{
GPIO_WriteIO_FAST(GPIO_IO_LOW,port);
break;
}
case GPIO_CMD_READ_NO_IRQ_MASK:
{
GPIO_CTRL_READ_T *prRead;
prRead = &(data->rRead);
prRead->u1IOData = GPIO_ReadIO_FAST(port);
break;
}
#endif
case GPIO_CMD_WRITE_FOR_SPI:
{
GPIO_CTRL_WRITE_FOR_SPI_T *prWrite;
prWrite = &(data->rWriteSpi);
GPIO_WriteIO_FAST2(prWrite->data,prWrite->no,prWrite->remainder_shift);
break;
}
default:
EXT_ASSERT(0,handle,cmd,0);
return STATUS_INVALID_CMD;
}
}
else if(DCL_GPO_IS_HANDLE_MAGIC(handle))
{
switch(cmd)
{
case GPO_CMD_MODE_SET_0:
{
GPO_ModeSetup(port,GPO_MODE_0);
break;
}
case GPO_CMD_MODE_SET_1:
{
GPO_ModeSetup(port,GPO_MODE_1);
break;
}
case GPO_CMD_MODE_SET_2:
{
GPO_ModeSetup(port,GPO_MODE_2);
break;
}
case GPO_CMD_MODE_SET_3:
{
GPO_ModeSetup(port,GPO_MODE_3);
break;
}
case GPO_CMD_WRITE_LOW :
{
GPO_WriteIO(port,GPO_IO_LOW);
break;
}
case GPO_CMD_WRITE_HIGH:
{
GPO_WriteIO(port,GPO_IO_HIGH);
break;
}
case GPO_CMD_RETURN_OUT:
{
GPO_CTRL_RETURN_OUT_T *prReturnOut;
prReturnOut = &(data->oReturnOut);
prReturnOut->u1RetOutData = GPO_ReturnDout(port);
break;
}
case GPO_CMD_RETURN_MODE:
{
GPO_CTRL_RETURN_MODE_T *prReturnMode;
prReturnMode = &(data->oReturnMode);
prReturnMode->u1RetMode = GPO_ReturnMode(port);
break;
}
default:
EXT_ASSERT(0,handle,cmd,0);
return STATUS_INVALID_CMD;
}
}
else if (DCL_GPIO_CLK_IS_HANDLE_MAGIC(handle))
{
switch(cmd)
{
case GPIO_CMD_SET_CLK_DIV:
{
kal_uint8 clknum=0;
GPIO_CTRL_SET_CLK_DIV_T *prSetClkDiv;
prSetClkDiv= &(data->rSetClkDiv);
clknum=get_clknum(prSetClkDiv->u2ClkNum);
GPIO_SetClkDiv(clknum,prSetClkDiv->u2Div);
break;
}
default:
EXT_ASSERT(0,handle,cmd,0);
return STATUS_INVALID_CMD;
}
}
else
{
EXT_ASSERT(0,handle,cmd,0);
return STATUS_INVALID_DCL_HANDLE;
}
return STATUS_OK;
}
