static int __ui_set_flg(struct pt_regs *regs)
{
ID flgid = __xn_reg_arg1(regs);
UINT setptn = __xn_reg_arg2(regs);
return set_flg(flgid, setptn);
}
void hp98035_io_card::update_obuffer(void)
{
if (!m_idr_full && !m_flg && m_obuffer_ptr < m_obuffer_len) {
m_odr = m_obuffer[ m_obuffer_ptr++ ];
set_flg(true);
}
}
void hp98035_io_card::device_reset()
{
hp9845_io_card_device::device_reset();
install_readwrite_handler(read16_delegate(FUNC(hp98035_io_card::reg_r) , this) , write16_delegate(FUNC(hp98035_io_card::reg_w) , this));
m_idr_full = false;
m_idr = 0;
m_odr = 0;
m_ibuffer_ptr = 0;
m_obuffer_len = 0;
m_obuffer_ptr = 0;
sts_w(true);
set_flg(true);
// Set real time from the real world
system_time systime;
machine().base_datetime(systime);
m_msec = 0;
m_sec = systime.local_time.second;
m_min = systime.local_time.minute;
m_hrs = systime.local_time.hour;
m_dom = systime.local_time.mday;
m_mon = systime.local_time.month + 1;
attotime period(attotime::from_msec(1));
m_msec_timer->adjust(period , 0 , period);
half_init();
}
void initialize_console_dri() {
/**
* Fill dummy lines in log buffer with spaces
*/
for (int i = 0; i < CONSOLE_LOG_VIEW_LINES; ++i)
for (int j = 0; j < CONSOLE_LOG_VIEW_LINE_WIDTH; ++j)
log_buffer[i][j] = ' ';
/**
* Draw title
*/
int offset_x;
if (strlen("EV3RT Console") * CONSOLE_TITLE_FONT_WIDTH > 178 /* screen width */)
offset_x = 0;
else
offset_x = (178 /* screen width */ - strlen("EV3RT Console") * CONSOLE_TITLE_FONT_WIDTH) / 2;
bitmap_bitblt(NULL, 0, 0, ev3rt_console_fb, 0, CONSOLE_TITLE_AREA_Y, 178 /* screen width */, CONSOLE_TITLE_FONT_HEIGHT, ROP_SET); // Clear
bitmap_draw_string("EV3RT Console", ev3rt_console_fb, offset_x, CONSOLE_TITLE_AREA_Y, CONSOLE_TITLE_FONT, ROP_COPYINVERTED);
// syslog(LOG_NOTICE, "%s", cm->title);
/**
* Draw menu
*/
console_menu_perform_action(CONSOLE_MENU_ACT_RESET);
/**
* Active by default
*/
SVC_PERROR(set_flg(console_button_flag, 1 << BRICK_BUTTON_BACK));
}
/*
* 計測ルーチン
*/
void
perf_eval(uint_t n)
{
uint_t i, j;
init_hist(1, MAX_TIME, histarea1);
sus_tsk(LOGTASK); /* システムログタスクの動作を止める */
for (i = 0; i < NO_MEASURE; i++) {
ini_flg(FLG1);
for (j = 0; j < n; j++) {
act_tsk(task_list[j]);
}
chg_pri(TSK_SELF, MAIN_PRIORITY_LOW);
/* タスクが待ち状態に入るのを待つ */
chg_pri(TSK_SELF, TPRI_INI);
begin_measure(1);
set_flg(FLG1, 0x01U);
end_measure(1);
chg_pri(TSK_SELF, MAIN_PRIORITY_LOW);
/* タスクが終了するのを待つ */
chg_pri(TSK_SELF, TPRI_INI);
}
rsm_tsk(LOGTASK); /* システムログタスクの動作を再開する */
syslog_1(LOG_NOTICE, "Execution times of set_flg"
" when %d tasks are released from waiting.", n);
print_hist(1);
logtask_flush(0U);
}
void WifiCmd_Done(FLGPTN flag,UINT32 result)
{
DBG_IND("flag %x result %d\r\n",flag,result);
g_result = result;
set_flg(FLG_ID_WIFICMD, flag);
}
/*
* performance evaluation routine
*/
void
perf_eval(uint_t n)
{
uint_t i, j;
init_hist(1, MAX_TIME, histarea1);
for (i = 0; i < NO_MEASURE; i++) {
ini_flg(FLG1);
for (j = 0; j < n; j++) {
act_tsk(task_list[j]);
}
chg_pri(TSK_SELF, MAIN_PRIORITY_LOW);
/* let the task in the waiting queue of the event flag */
chg_pri(TSK_SELF, TPRI_INI);
begin_measure(1);
set_flg(FLG1, 0x01U);
end_measure(1);
chg_pri(TSK_SELF, MAIN_PRIORITY_LOW);
/* wait the task exits */
chg_pri(TSK_SELF, TPRI_INI);
}
syslog_1(LOG_NOTICE, "Execution times of set_flg"
" when %d tasks are released from waiting.", n);
print_hist(1);
syslog_flush();
}
main()
{
init_params();
set_int("SCALE", "7");
set_flg("VERBOSE");
set_str("DISTRIBUTIONS", "'some file name'");
print_params();
set_int("s" , "8");
clr_flg("VERBOSE");
printf("DIST is %s\n", get_str("DISTRIBUTIONS"));
print_params();
usage(NULL, NULL);
}
void hp98035_io_card::update_ibuffer(void)
{
if (m_idr_full && !m_flg) {
// New input byte, put in ibuffer if it's a valid char (A-Z 0-9 = / \n)
if (m_idr == DELIM_CH_0 || m_idr == DELIM_CH_1) {
process_ibuffer();
} else if (((m_idr >= 'A' && m_idr <= 'Z') || (m_idr >= '0' && m_idr <= '9') || m_idr == '=') &&
m_ibuffer_ptr < HP98035_IBUFFER_LEN) {
m_ibuffer[ m_ibuffer_ptr++ ] = m_idr;
}
m_idr_full = false;
set_flg(true);
}
}
void
task3(intptr_t exinf)
{
ER_UINT ercd;
FLGPTN flgptn;
check_point(26);
ercd = wup_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(28);
ercd = set_flg(FLG3, 0x02);
check_ercd(ercd, E_OK);
check_point(30);
ercd = set_flg(FLG3, 0x03);
check_ercd(ercd, E_OK);
check_point(32);
ercd = set_flg(FLG3, 0x03);
check_ercd(ercd, E_OK);
check_point(34);
ercd = set_flg(FLG4, 0x03);
check_ercd(ercd, E_OK);
check_point(36);
ercd = set_flg(FLG4, 0x01);
check_ercd(ercd, E_OK);
check_point(39);
ercd = wai_flg(FLG3, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_finish(44);
check_point(0);
}
/**
BurnIn timer ISR
BurnIn timer ISR
[CalBurnIn internal API]
@param UINT32 uiLoop: Loop number
@param UINT32 uiItem: Item number
@return void
*/
static void Cal_BurnInTimerISR(void)
{
UINT32 uiFlag;
uiFlag = FLGBURNIN_TIMER;
if (uiTimeoutValue != 0)
{
uiTimerCnt += TIMER_INTERVAL;
if (uiTimerCnt >= uiTimeoutValue)
{
uiFlag |= FLGBURNIN_TIMEOUT;
}
}
set_flg(FLG_ID_BURNIN, uiFlag);
}
void
alarm1_handler(intptr_t exinf)
{
ER_UINT ercd;
FLGPTN flgptn;
check_point(40);
ercd = wai_flg(FLG1, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_CTX);
ercd = set_flg(FLG3, 0x01);
check_ercd(ercd, E_OK);
check_point(41);
return;
check_point(0);
}
void hp98035_io_card_device::device_reset()
{
hp9845_io_card_device::device_reset();
m_idr_full = false;
m_idr = 0;
m_odr = 0;
sts_w(true);
set_flg(true);
attotime period(attotime::from_msec(1));
m_msec_timer->adjust(period , 0 , period);
period = attotime::from_hz(DIGIT_MUX_FREQ);
m_clock_timer->adjust(period , 0 , period);
half_init();
}
void hp98035_io_card::device_reset()
{
hp9845_io_card_device::device_reset();
install_readwrite_handler(read16_delegate(FUNC(hp98035_io_card::reg_r) , this) , write16_delegate(FUNC(hp98035_io_card::reg_w) , this));
m_idr_full = false;
m_idr = 0;
m_odr = 0;
sts_w(true);
set_flg(true);
attotime period(attotime::from_msec(1));
m_msec_timer->adjust(period , 0 , period);
period = attotime::from_hz(DIGIT_MUX_FREQ);
m_clock_timer->adjust(period , 0 , period);
half_init();
}
/*
** Initialize the MMCSD controller structure for use
*/
static void MMCSDControllerSetup(void)
{
#if DEBUG_PRINT
UARTprintf("%s()\r\n", __FUNCTION__);
#endif
ctrlInfo.memBase = MMCSD_INST_BASE;
ctrlInfo.ctrlInit = MMCSDLibControllerInit;
ctrlInfo.xferSetup = MMCSDXferSetup;
ctrlInfo.cmdStatusGet = MMCSDCmdStatusGet;
ctrlInfo.xferStatusGet = MMCSDXferStatusGet;
ctrlInfo.cardPresent = MMCSDLibCardPresent;
ctrlInfo.cmdSend = MMCSDLibCmdSend;
ctrlInfo.busWidthConfig = MMCSDLibBusWidthConfig;
ctrlInfo.busFreqConfig = MMCSDLibBusFreqConfig;
ctrlInfo.intrMask = (MMCSD_INTR_CMDCOMP | MMCSD_INTR_CMDTIMEOUT |
MMCSD_INTR_DATATIMEOUT | MMCSD_INTR_TRNFCOMP |
MMCSD_INTR_DATACRCERR);
ctrlInfo.intrMask = 0xFFFFFFFF; // Enable all interrupts for debug -- ertl-liyixiao
ctrlInfo.intrEnable = MMCSDLibIntrEnable;
ctrlInfo.busWidth = (SD_BUS_WIDTH_1BIT | SD_BUS_WIDTH_4BIT);
ctrlInfo.highspeed = 1;
ctrlInfo.ocr = (SD_OCR_VDD_3P0_3P1 | SD_OCR_VDD_3P1_3P2);
ctrlInfo.card = &sdCard;
ctrlInfo.ipClk = MMCSD_IN_FREQ;
ctrlInfo.opClk = MMCSD_INIT_FREQ;
ctrlInfo.cdPinNum = MMCSD_CARD_DETECT_PINNUM;
sdCard.ctrl = &ctrlInfo;
// dmaIsRunning = 0;
// xferCompFlag = 0;
// dataTimeout = 0;
// dataCRCError = 0;
// cmdCompFlag = 0;
// cmdTimeout = 0;
ER ercd = clr_flg(MMCSD_ISR_FLG, 0x0);
assert(ercd == E_OK);
ercd = set_flg(MMCSD_ISR_FLG, MMCSD_ISR_FLGPTN_DMACOMP);
assert(ercd == E_OK);
#if defined(DEBUG) && 0
syslog(LOG_ERROR, "%s(): set_flg(MMCSD_ISR_FLGPTN_DMACOMP)", __FUNCTION__);
#endif
}
int main( void )
{
char buf[1024] = {};
if ( read(0, buf, 1024) == -1)
ERR_EXIT("read");
printf("buf=%s\n", buf);
/*
int flags = fcntl(0, F_GETFL, 0);
if ( flags == -1)
ERR_EXIT("fcntl");
if ( fcntl(0, F_SETFL, O_NONBLOCK|flags) == -1)
ERR_EXIT("fcntl");
*/
set_flg(0, O_NONBLOCK);
clr_flg(0, O_NONBLOCK);
if ( read(0, buf, 1024) == -1) // EAGAIN
ERR_EXIT("read");
return 0;
}
void GPSRecTsk(void)
{
CHAR cLen;
UINT16 CheckSentenceType1, CheckSentenceType2;
UINT32 CheckSentenceType3;
CHAR RecSentence[NMEA_SENTENCE_SIZE];
CHAR *pSentenceData;
static UINT32 Step=0;
kent_tsk();
clr_flg(FLG_ID_GPS, GPS_FLAG_DATAVALID);
clr_flg(FLG_ID_GPS, GPS_FLAG_SHUTDOWN);
while(1)
{
cLen = NMEA_SENTENCE_SIZE ;
#if(UART_DATA_TYPE==UART_CONNECT_MCU)
Step=0;
uart2_getChar(RecSentence);
//debug_msg("Uart2 get char :%x.\r\n",*RecSentence);
if(*RecSentence == MCU_START1_BYTE)
{
Step=1;
}
if(Step==1)
{
uart2_getChar(RecSentence);
//debug_msg("Uart2 get char-2- :%x.\r\n",*RecSentence);
if(*RecSentence == MCU_START2_BYTE)
{
Step=2;
}
}
if(Step==2)
{
uart2_getChar(RecSentence);
debug_msg("GPSRecTsk---Uart2 get char- :%x.\r\n",*RecSentence);
if(*RecSentence == MCU_COMMAND_UPDATE_ACK)
{
debug_msg("Uart2 get char-3- :%x.\r\n",*RecSentence);
MCUInfo.IsUpdateMcuFW = TRUE;
Step=0;
}
else if(*RecSentence == MCU_COMMAND_POWEROF)
{
debug_msg("Uart2 get char-4- :%x.\r\n",*RecSentence);
if(!kchk_flg(FLG_ID_GPS, GPS_FLAG_SHUTDOWN))
{
set_flg(FLG_ID_GPS, GPS_FLAG_SHUTDOWN);
}
Step=0;
}
}
#else
#if (RECEIVE_FROM_UART2)
if (uart2_getString(RecSentence, &cLen) == E_PAR)
#else
if (uart_getString(RecSentence, &cLen) == E_PAR)
#endif
debug_err(("UART2: parameter error!\r\n"));
//debug_err(("%s\r\n",RecSentence));
//Each NMEA sentence begins with '$' (0x24)
if (RecSentence[0] == 0x24)
{
pSentenceData = RecSentence;
CheckSentenceType1 = *(UINT16 *)(pSentenceData + 2);
CheckSentenceType2 = *(UINT16 *)(pSentenceData + 4);
CheckSentenceType3 = ((UINT)CheckSentenceType2 << 16) | (UINT)CheckSentenceType1;
switch(CheckSentenceType3)
{
case GSA_SENTENCE:
NMEASentence.GSA = RecSentence;
GPSRec_NMEAParser(RecSentence, (UINT32)cLen, GSA);
break;
case RMC_SENTENCE:
NMEASentence.RMC = RecSentence;
GPSRec_NMEAParser(RecSentence, (UINT32)cLen, RMC);
break;
case GGA_SENTENCE:
NMEASentence.GGA = RecSentence;
GPSRec_NMEAParser(RecSentence, (UINT32)cLen, GGA);
break;
case GSV_SENTENCE:
NMEASentence.GSV = RecSentence;
GPSRec_NMEAParser(RecSentence, (UINT32)cLen, GSV);
break;
case GLL_SENTENCE:
NMEASentence.GLL = RecSentence;
GPSRec_NMEAParser(RecSentence, (UINT32)cLen, GLL);
break;
case VTG_SENTENCE:
NMEASentence.VTG = RecSentence;
GPSRec_NMEAParser(RecSentence, (UINT32)cLen, VTG);
break;
default:
debug_err(("GPS: Can't identify this sentence 0x%X \r\n",CheckSentenceType3));
break;
}
}
#endif
}
}
/*
* Routine: set_option(int var, char *value)
* Purpose: set a particular parameter; main entry point for the module
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
set_option(char *name, char *param)
{
int res = 1;
option_t *o;
char parse_int[15];
char *cp;
init_params();
res = fnd_param(name);
if (res == -1)
return(res);
o = &options[res];
if (o->flags & OPT_NOP)
{
printf("ERROR: Cannot accept %s.\tNot Implemented!\n", o->name);
return(0);
}
/* option is already set from the command line or hard-coded */
/* and doesn't allow multiple settings */
switch(o->flags & TYPE_MASK)
{
case OPT_FLG:
if ((param && (*param == 'Y' || *param == 'Y' || *param == OPTION_START)) ||
(param == NULL))
{
if (o->action)
if (o->action(o->name, NULL) < 0)
usage(o->name, "Cannot process option");
set_flg(name);
}
else
clr_flg(name);
res = 1;
break;
case OPT_INT:
if (o->action)
{
if ((res = o->action(o->name, param)) < 0)
usage(NULL, "Bad parameter argument");
else
sprintf(parse_int, "%d", res);
}
set_int(name, (o->action)?parse_int:param);
res = 2;
break;
case OPT_STR:
if (*param == '"')
{
cp = strchr((param + 1), '"');
if (cp == NULL) /* non-terminated string literal */
usage(NULL, "Non-terminated string");
*cp = '\0';
param += 1;
}
else
{
cp = strpbrk(param, " \t\n");
if (cp != NULL)
*cp = '\0';
}
if (o->action && strlen(param))
if (o->action(o->name, param) < 0)
usage(o->name, "Cannot process option");
set_str(name, param);
res = 2;
break;
default:
fprintf(stderr, "Invalid option/type (%d/%s)\n",
o->flags & TYPE_MASK, o->name);
exit(0);
break;
}
o->flags |= OPT_SET; /* marked as set */
return(res);
}
void
task2(intptr_t exinf)
{
ER_UINT ercd;
FLGPTN flgptn;
T_RFLG rflg;
check_point(4);
ercd = wai_flg(FLG1, 0x05, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_assert(flgptn == 0x03);
check_point(5);
ercd = wai_flg(FLG1, 0x04, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(7);
check_assert(flgptn == 0x07);
ercd = wai_flg(FLG1, 0x03, TWF_ANDW, &flgptn);
check_ercd(ercd, E_OK);
check_assert(flgptn == 0x07);
check_point(8);
ercd = wai_flg(FLG1, 0x0c, TWF_ANDW, &flgptn);
check_ercd(ercd, E_OK);
check_point(11);
check_assert(flgptn == 0x0f);
ercd = wai_flg(FLG2, 0x05, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_assert(flgptn == 0x01);
ercd = ref_flg(FLG2, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
ercd = set_flg(FLG2, 0x01);
check_ercd(ercd, E_OK);
check_point(12);
ercd = wai_flg(FLG2, 0x04, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(15);
check_assert(flgptn == 0x05);
ercd = ref_flg(FLG2, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
ercd = set_flg(FLG2, 0x03);
check_ercd(ercd, E_OK);
ercd = wai_flg(FLG2, 0x03, TWF_ANDW, &flgptn);
check_ercd(ercd, E_OK);
check_assert(flgptn == 0x03);
ercd = ref_flg(FLG2, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
ercd = set_flg(FLG2, 0x03);
check_ercd(ercd, E_OK);
check_point(16);
ercd = wai_flg(FLG2, 0x05, TWF_ANDW, &flgptn);
check_ercd(ercd, E_OK);
check_point(19);
check_assert(flgptn == 0x07);
check_point(20);
ercd = wai_flg(FLG2, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(23);
check_assert(flgptn == 0x03);
ercd = act_tsk(TASK3);
check_ercd(ercd, E_OK);
check_point(24);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(27);
ercd = wai_flg(FLG3, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(29);
ercd = wai_flg(FLG3, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(33);
ercd = wai_flg(FLG4, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(35);
ercd = wai_flg(FLG4, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(0);
}
void
task1(intptr_t exinf)
{
ER_UINT ercd;
T_RFLG rflg;
FLGPTN flgptn;
test_start(__FILE__);
check_point(1);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
ercd = ref_flg(FLG2, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x01);
check_point(2);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
ercd = set_flg(FLG1, 0x01);
check_ercd(ercd, E_CTX);
ercd = wai_flg(FLG1, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_CTX);
ercd = unl_cpu();
check_ercd(ercd, E_OK);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = wai_flg(FLG1, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_CTX);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = wai_flg(FLG1, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_CTX);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = set_flg(0, 0x01);
check_ercd(ercd, E_ID);
ercd = wai_flg(0, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_ID);
ercd = set_flg(TNUM_FLGID+1, 0x01);
check_ercd(ercd, E_ID);
ercd = wai_flg(TNUM_FLGID+1, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_ID);
ercd = wai_flg(FLG1, 0x00, TWF_ORW, &flgptn);
check_ercd(ercd, E_PAR);
ercd = wai_flg(FLG1, 0x01, 0U, &flgptn);
check_ercd(ercd, E_PAR);
ercd = wai_flg(FLG1, 0x01, (TWF_ORW|TWF_ANDW), &flgptn);
check_ercd(ercd, E_PAR);
ercd = set_flg(FLG1, 0x00);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
ercd = set_flg(FLG1, 0x01);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x01);
ercd = set_flg(FLG1, 0x01);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x01);
ercd = set_flg(FLG1, 0x02);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x03);
ercd = clr_flg(FLG1, ~0x01);
check_ercd(ercd, E_OK);
ercd = set_flg(FLG1, 0x03);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x03);
check_point(3);
ercd = act_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(6);
ercd = set_flg(FLG1, 0x04);
check_ercd(ercd, E_OK);
check_point(9);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = set_flg(FLG1, 0x08);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG1, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x0f);
check_point(10);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
check_point(13);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = set_flg(FLG2, 0x04);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG2, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
check_point(14);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
check_point(17);
ercd = sus_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = set_flg(FLG2, 0x04);
check_ercd(ercd, E_OK);
ercd = ref_flg(FLG2, &rflg);
check_ercd(ercd, E_OK);
check_assert(rflg.wtskid == TSK_NONE);
check_assert(rflg.flgptn == 0x00);
check_point(18);
ercd = rsm_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(21);
ercd = wai_flg(FLG2, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_ILUSE);
ercd = set_flg(FLG2, 0x02);
check_ercd(ercd, E_OK);
ercd = wai_flg(FLG2, 0x02, TWF_ORW, &flgptn);
check_ercd(ercd, E_ILUSE);
check_point(22);
ercd = set_flg(FLG2, 0x01);
check_ercd(ercd, E_OK);
check_point(25);
ercd = wai_flg(FLG3, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(31);
ercd = wai_flg(FLG4, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(37);
ercd = clr_flg(FLG3, 0);
check_ercd(ercd, E_OK);
ercd = sta_alm(ALM1, 2 * TEST_TIME_CP);
check_ercd(ercd, E_OK);
check_point(38);
ercd = wai_flg(FLG3, 0x01, TWF_ORW, &flgptn);
check_ercd(ercd, E_OK);
check_point(42);
ercd = set_flg(FLG3, 0x02);
check_ercd(ercd, E_OK);
check_point(43);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(0);
}
T_TCP_CEP *
tcp_close (T_TCP_CEP *cep)
{
/* タイマーを停止する。*/
tcp_cancel_timers(cep);
/*
* 通信端点をロックし、
* 受信再構成キューのネットワークバッファを解放する。
*/
syscall(wai_sem(cep->semid_lock));
tcp_free_reassq(cep);
syscall(sig_sem(cep->semid_lock));
/* 状態を未使用にする。*/
cep->fsm_state = TCP_FSM_CLOSED;
/*
* 以下に関係しないフラグをクリアーする。
* ・送受信ウィンドバッファの省コピー機能
* ・動的な通信端点の生成・削除機能
*/
cep->flags &= (TCP_CEP_FLG_WBCS_NBUF_REQ | TCP_CEP_FLG_WBCS_MASK |
TCP_CEP_FLG_DYNAMIC | TCP_CEP_FLG_VALID);
#ifdef TCP_CFG_NON_BLOCKING
if (cep->snd_nblk_tfn != TFN_TCP_UNDEF || cep->rcv_nblk_tfn != TFN_TCP_UNDEF) {
/* ノンブロッキングコール */
#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
if (!IS_PTR_DEFINED(cep->callback))
syslog(LOG_WARNING, "[TCP] no call back, CEP: %d.", GET_TCP_CEPID(cep));
else {
if (cep->rcv_nblk_tfn != TFN_TCP_UNDEF) {
ER_UINT len;
switch (cep->rcv_nblk_tfn) {
case TFN_TCP_ACP_CEP:
/* TCP 通信端点からTCP 受付口を解放する。*/
cep->rep = NULL;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)E_CLS);
break;
case TFN_TCP_RCV_BUF:
/* 受信ウィンドバッファの空アドレスを獲得する。*/
len = TCP_GET_RWBUF_ADDR(cep, cep->rcv_p_buf);
/* 異常切断等のエラーを設定する。*/
if (cep->error == E_TMOUT)
len = E_CLS;
else if (cep->error < 0)
len = cep->error;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)(uint32_t)len);
break;
case TFN_TCP_RCV_DAT:
/* 受信ウィンドバッファからデータを取り出す。*/
len = TCP_READ_RWBUF(cep, cep->rcv_data, (uint_t)cep->rcv_len);
/* 異常切断等のエラーを設定する。*/
if (cep->error == E_TMOUT)
len = E_CLS;
else if (cep->error != E_OK)
len = cep->error;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)(uint32_t)len);
break;
case TFN_TCP_CLS_CEP:
if (cep->error == E_TMOUT)
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)E_CLS);
else
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)cep->error);
break;
default:
syslog(LOG_WARNING, "[TCP] unexp TFN: %s.", in_strtfn((FN)cep->rcv_nblk_tfn));
break;
}
/* 記憶されているタスク ID と API 機能コードをクリアーする。*/
cep->rcv_tskid = TA_NULL;
cep->rcv_tfn = cep->rcv_nblk_tfn = TFN_TCP_UNDEF;
}
if (cep->snd_nblk_tfn != TFN_TCP_UNDEF) {
switch (cep->snd_nblk_tfn) {
case TFN_TCP_CON_CEP:
/* TCP 通信端点から TCP 受付口を解放する。*/
cep->rep = NULL;
(*cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, (void*)E_CLS);
break;
case TFN_TCP_SND_DAT:
case TFN_TCP_GET_BUF:
if (cep->error == E_TMOUT)
(*cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, (void*)E_CLS);
else
(*cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, (void*)cep->error);
break;
default:
syslog(LOG_WARNING, "[TCP] unexp TFN: %s.", in_strtfn((FN)cep->snd_nblk_tfn));
break;
}
/* 記憶されているタスク ID と API 機能コードをクリアーする。*/
cep->snd_tskid = TA_NULL;
cep->snd_tfn = cep->snd_nblk_tfn = TFN_TCP_UNDEF;
}
}
#else /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
if (!IS_PTR_DEFINED(cep->callback))
syslog(LOG_WARNING, "[TCP] no call back, CEP: %d.", GET_TCP_CEPID(cep));
else {
if (cep->rcv_nblk_tfn != TFN_TCP_UNDEF) {
ER_UINT len;
switch (cep->rcv_nblk_tfn) {
case TFN_TCP_ACP_CEP:
/* TCP 通信端点からTCP 受付口を解放する。*/
cep->rep = NULL;
len = E_CLS;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)&len);
break;
case TFN_TCP_RCV_BUF:
/* 受信ウィンドバッファの空アドレスを獲得する。*/
len = TCP_GET_RWBUF_ADDR(cep, cep->rcv_p_buf);
/* 異常切断等のエラーを設定する。*/
if (cep->error == E_TMOUT)
len = E_CLS;
else if (cep->error < 0)
len = cep->error;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)&len);
break;
case TFN_TCP_RCV_DAT:
/* 受信ウィンドバッファからデータを取り出す。*/
len = TCP_READ_RWBUF(cep, cep->rcv_data, (uint_t)cep->rcv_len);
/* 異常切断等のエラーを設定する。*/
if (cep->error == E_TMOUT)
len = E_CLS;
else if (cep->error != E_OK)
len = cep->error;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)&len);
break;
case TFN_TCP_CLS_CEP:
if (cep->error == E_TMOUT)
len = E_CLS;
else
len = cep->error;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)&len);
break;
default:
syslog(LOG_WARNING, "[TCP] unexp TFN: %s.", in_strtfn((FN)cep->rcv_nblk_tfn));
break;
}
/* 記憶されているタスク ID と API 機能コードをクリアーする。*/
cep->rcv_tskid = TA_NULL;
cep->rcv_tfn = cep->rcv_nblk_tfn = TFN_TCP_UNDEF;
}
if (cep->snd_nblk_tfn != TFN_TCP_UNDEF) {
ER_UINT len;
switch (cep->snd_nblk_tfn) {
case TFN_TCP_CON_CEP:
/* TCP 通信端点から TCP 受付口を解放する。*/
cep->rep = NULL;
len = E_CLS;
(*cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, (void*)&len);
break;
case TFN_TCP_SND_DAT:
case TFN_TCP_GET_BUF:
if (cep->error == E_TMOUT)
len = E_CLS;
else
len = cep->error;
(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void*)&len);
break;
default:
syslog(LOG_WARNING, "[TCP] unexp TFN: %s.", in_strtfn((FN)cep->snd_nblk_tfn));
break;
}
/* 記憶されているタスク ID と API 機能コードをクリアーする。*/
cep->snd_tskid = TA_NULL;
cep->snd_tfn = cep->snd_nblk_tfn = TFN_TCP_UNDEF;
}
}
#endif /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
/*
* 通信端点をロックし、
* 送受信ウィンドバッファキューのネットワークバッファを解放する。
*/
syscall(wai_sem(cep->semid_lock));
TCP_FREE_RWBUFQ(cep);
TCP_FREE_SWBUFQ(cep);
syscall(sig_sem(cep->semid_lock));
/* 未使用になったことを知らせる。*/
syscall(set_flg(cep->est_flgid, TCP_CEP_EVT_CLOSED));
}
else { /* 非ノンブロッキングコール */
#endif /* of #ifdef TCP_CFG_NON_BLOCKING */
/* 記憶されているタスク ID と API 機能コードをクリアーする。*/
cep->snd_tskid = cep->rcv_tskid = TA_NULL;
cep->snd_tfn = cep->rcv_tfn = TFN_TCP_UNDEF;
/*
* 通信端点をロックし、
* 送受信ウィンドバッファキューのネットワークバッファを解放する。
*/
syscall(wai_sem(cep->semid_lock));
TCP_FREE_RWBUFQ(cep);
TCP_FREE_SWBUFQ(cep);
syscall(sig_sem(cep->semid_lock));
/* 未使用になったことを知らせる。*/
syscall(set_flg(cep->est_flgid, TCP_CEP_EVT_CLOSED));
/*
* 入出力タスクを起床して、
* 送受信不可になったことを知らせる。
*/
syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
syscall(set_flg(cep->rcv_flgid, TCP_CEP_EVT_RWBUF_READY));
#ifdef TCP_CFG_NON_BLOCKING
}
#endif /* of #ifdef TCP_CFG_NON_BLOCKING */
return NULL;
}
/**
KeyScan task
KeyScan task
@param void
@return void
*/
void KeyScanTsk(void)
{
UINT32 uiKeyScanTimerCnt;
UINT32 uiKeyScanQSecCnt;
#if (_TouchPanel_ != DISABLE)
GESTURE_GESTURE_STRUCT TempGesture;
#endif
// Initial Message Queue
// KeyScan may send commands in the boot stage before UIFrameworkTsk starts.
// MessageQueue has to be initialized before KeyScan running.
Ux_InitMessage(MBXID_SYS_EVENT, MBXID_BKG_EVENT);
// Init the callback function of Primary task for file system initialization
Primary_SetFSInitCB(KeyScan_StorageCB);
// Set LED toggle speed
KeyScan_SetLEDToggleSpeed(KEYSCAN_LED_GREEN, KEYSCAN_LED_TSPEED_SLOW);
KeyScan_SetLEDToggleSpeed(KEYSCAN_LED_RED, KEYSCAN_LED_TSPEED_SLOW);
KeyScan_SetLEDToggleSpeed(KEYSCAN_LED_FCS, KEYSCAN_LED_TSPEED_NORMAL);
KeyScan_initTimer();
if (timer_open((UINT *)&g_uiKeyScanTimerID, NULL) != E_OK)
{
debug_err(("KEYSCAN ERR: Error open keyscan timer\r\n"));
while (1)
{
;
}
}
// Turn on green LED and turn off red LED
KeyScan_TurnOnLED(KEYSCAN_LED_GREEN);
KeyScan_TurnOffLED(KEYSCAN_LED_RED);
KeyScan_TurnOffLED(KEYSCAN_LED_FCS);
//Already clr_flg during timer_open procedure
//clr_flg(FLG_ID_INT2, FLGINT2_TIMER0 << g_uiKeyScanTimerID);
timer_set(g_uiKeyScanTimerID, KEYSCAN_TIMER_INTERVAL, _TIMER_CTRL_FREE_RUN | _TIMER_CTRL_INT_ENABLE, _TIMER_PLAY);
// Init variables
uiKeyScanTimerCnt = 0;
uiKeyScanQSecCnt = 0;
// Init Card and File System
KeyScan_DetStrgCard();
KeyScan_DetStrgCard();
//
KeyScanACCDet();
#if (KEYSCAN_BATTERY_DET == ENABLE)
if (!KeyScan_CheckUSBInSysInit())
{
KeyScan_DetBatteryInSysInit();
}
#endif
#if (_DATETIME_SETTING_ == ENABLE)
//KeyScan_SetTime();
#endif
#if (KEYSCAN_KEY_DET == ENABLE)
KeyScan_DetKey();
if (!KeyScan_CheckEngMode() && !KeyScan_CheckUSBInSysInit())
{
Primary_ChangeMode(PRIMARY_MODE_MOVIE);
//Primary_ChangeMode(PRIMARY_MODE_PHOTO);
//Primary_ChangeMode(PRIMARY_MODE_PLAYBACK);
Primary_Wait4ChangeModeDone();
}
#endif
// Init UI USB detection
//KeyScan_DetUSB();
//KeyScan_DetUSB();
// Init UI battery level
//KeyScan_DetBattery();
//KeyScan_DetBattery();
//get the acc
if((GPIOMap_GetAcc12V() == FALSE)&&(gbACCStatus != ACCON2OFF))
{
debug_err(("PowerOnMau TRUE and turn to half an hour mode-----\r\n"));
PowerOnMau=TRUE;
}
//---------------------------------------------------------------------------------------------------
// KeyScan Main Loop
//---------------------------------------------------------------------------------------------------
while (1)
{
//wai_flg((UINT *)&uiFlag, FLG_ID_INT2, FLGINT2_TIMER0 << g_uiKeyScanTimerID, TWF_ORW | TWF_CLR);
timer_waitTimeup(g_uiKeyScanTimerID);
uiKeyScanTimerCnt++;
g_uiKeyScanFlags = 0;
//-----------------------------------------------------------------------------------------------
// Do the following task every 20ms
//-----------------------------------------------------------------------------------------------
// Detect key
#if (KEYSCAN_KEY_DET == ENABLE)
if (g_bKeyScanKeyDetEn == TRUE)
{
KeyScan_DetKey();
}
#endif
#if (KEYSCAN_POWEROFF_DET == ENABLE)
// Detect power off key
KeyScan_DetPoweroff();
#endif
KeyScanACCDet();
// Detect IR Remote key
#if (_IR_REMOTE_ != _IR_REMOTE_NONE_)
// Check IR data expiration, frequency value must be smaller than 100ms
KeyScan_CheckIrRxExp();
// Detect IR remote control receiver detected key, frequency value must be smaller than 50ms
KeyScan_DetIrRxKey();
#endif
if(Ux_GetBackgroundTskBusy() == TRUE)
{
// Detect storage card,prevent card unplug
KeyScan_DetStrgCard();
}
KeyScan_countTimer();
//-----------------------------------------------------------------------------------------------
// Do the following task every 80ms
//-----------------------------------------------------------------------------------------------
if ((uiKeyScanTimerCnt & 3) == 0)
{
// Detect touch panel
#if (_TouchPanel_ != DISABLE)
if(g_bKeyScanTP)
{
Gesture_DetGesture(&TempGesture);
if(TempGesture.Event != GESTURE_EVENT_IDLE)
{
KeyScan_PostNvtTPEvent(&TempGesture);
}
}
#endif
// Toggle LED
KeyScan_ToggleLED();
// Detect flash light
#if (_FLASHLIGHT_ != _FLASHLIGHT_NONE_)
KeyScan_DetFlash();
#endif
}
//-----------------------------------------------------------------------------------------------
// Do the following task every 100ms
//-----------------------------------------------------------------------------------------------
if ((uiKeyScanTimerCnt % 5) == 0)
{
//#if (KEYSCAN_POWEROFF_DET == ENABLE)
// Detect power off key
// KeyScan_DetPoweroff();
// #endif
//-------------------------------------------------------------------------------------------
// Do the following task every 1s
//-------------------------------------------------------------------------------------------
if ((uiKeyScanTimerCnt % 50) == 0)
{
#if (KEYSCAN_AUTOPOWEROFF_DET == ENABLE)
// Detect auto poweroff
if ((KeyScan_GetAutoPoweroffTime() != KEYSCAN_AUTOPOWEROFF_DISABLED) && (g_bKeyScanAutoPoweroffEn == TRUE))
{
KeyScan_DetAutoPoweroff();
}
#endif
#if (_WDT_CONTROL_ == ENABLE)
wdt_setTrig();
#endif
}
}
//-----------------------------------------------------------------------------------------------
// Do the following task every 250ms
//-----------------------------------------------------------------------------------------------
if ((uiKeyScanTimerCnt % 12) == 0)
{
uiKeyScanQSecCnt++;
#if (KEYSCAN_KEY_DET == ENABLE)
// Detect modedial
//if (g_bKeyScanMDDetEn == TRUE)
//{
// KeyScan_DetModedial(FALSE);
//}
#endif
// Detect flash light
//KeyScan_DetFlash();
// Detect USB
//KeyScan_DetUSB();
//Detect macro mode
KeyScan_DetMacro();
//Detect Gsensor
KeyScan_DetGsensor();
//-------------------------------------------------------------------------------------------
// Do the following task every 500ms
//-------------------------------------------------------------------------------------------
if (uiKeyScanQSecCnt & 1)
{
#if (KEYSCAN_CARDDET_INT == DISABLE)
// Detect storage card
KeyScan_DetStrgCard();
#endif
// Detect HDMI
KeyScan_DetHDMI();
// Detect TV
KeyScan_DetTV();
// Detect External Audio (headphone...)
//KeyScan_DetAudio();
// Detect LCD rotate
//KeyScan_DetLCDRotate();
// Detect system is busy or not
KeyScan_DetBusy();
}
//-------------------------------------------------------------------------------------------
// Do the following task every 1s
//-------------------------------------------------------------------------------------------
if ((uiKeyScanQSecCnt % 4) == 0)
{
#if (KEYSCAN_BATTERY_DET == ENABLE)
//if (!KeyScan_IsUSBPlug()) {
//KeyScan_DetBattery();
// }
#endif
//--------------------------------jack lan begin-------------------------------
if ((KeyScan_GetAutoLCDoffTime() != 0))
{
KeyScan_DeLcdOff();
}
//KeyScan_DetAC();
if(gBKeyscanDetGSPNAVIEn == TRUE)
{
KeyScan_DetGSPNAVI();
}
#if 0
if(KeyScan_GetLedLightSta()== LED_AUTO)
{
if (AE__GetLV()>50)
{
if(GPIOMap_IsWhiteLightOn())
{
GPIOMap_TurnOffWhiteLight();
}
}
else
{
if(!GPIOMap_IsWhiteLightOn())
{
GPIOMap_TurnOnWhiteLight();
}
}
}
#endif
//--------------------------------jack lan end-------------------------------
}
//-------------------------------------------------------------------------------------------
// Do the following task every 5s
//-------------------------------------------------------------------------------------------
if ((uiKeyScanQSecCnt % 20) == 0)
{
KeyScan_NAVIComunicate();
}
}
//-----------------------------------------------------------------------------------------------
// End of KeyScanTimer divider
//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------
// Start to set key flag
//-----------------------------------------------------------------------------------------------
if (g_uiKeyScanFlags != 0)
{
#if (_CALIBRATION_MODE_ == ENABLE)
set_flg(FLG_ID_KEY, g_uiKeyScanFlags);
#endif
switch(g_uiKeyScanFlags & FLGKEY_ACT_MASK)
{
case FLGKEY_PRESSED:
Ux_PostEvent(Get_NVTCMD(g_uiKeyScanFlags), 2, NVTEVT_KEY_PRESS, FLGKEY_PRESSED);
break;
case FLGKEY_RELEASED:
Ux_PostEvent(Get_NVTCMD(g_uiKeyScanFlags), 1, NVTEVT_KEY_RELEASE);
break;
case FLGKEY_HOLD:
Ux_PostEvent(Get_NVTCMD(g_uiKeyScanFlags), 2, NVTEVT_KEY_PRESS, FLGKEY_HOLD);
break;
case FLGKEY_LONGHOLD:
Ux_PostEvent(Get_NVTCMD(g_uiKeyScanFlags), 2, NVTEVT_KEY_PRESS, FLGKEY_LONGHOLD);
break;
default:
debug_err(("KeyScanTsk: Unknown key action (0x%.8X)\r\n", (g_uiKeyScanFlags & FLGKEY_ACT_MASK)));
break;
}
g_uiKeyScanFlags = 0;
}
}
}
/** %jp{イベントフラグ資源の返却}%en{Release Flgaphore Resource}
* @param flgid %jp{イベントフラグ資源返却対象のイベントフラグのID番号}%en{ID number of the Eventflag to which resource is released}
*/
ER iset_flg(ID flgid, FLGPTN setptn)
{
return set_flg(flgid, setptn);
}
/**
CIPA test flow
CIPA test flow
@param void
@return void
*/
void Cal_CIPA(void)
{
UINT32 uiCIPACnt, uiCIPA30Cnt;
BOOL bZoomIn, bZoomOut;
INT8 StringBuffer[32];
RECT StringRect = {20, 200, 300, 30};
// Change to Photo Mode
Primary_ChangeMode(PRIMARY_MODE_PHOTO);
uiCIPACnt = 1;
uiCIPA30Cnt = 0;
Cal_CIPAReadPicNum();
bZoomIn = FALSE;
bZoomOut = FALSE;
while (1)
{
uiCIPACnt++;
// Show string
sprintf(StringBuffer,
"CIPA: %ld , Z: %s F: %s",
uiTotalPicNum,
(uiCIPA30Cnt & 1) ? "Out" : "In",
(uiCIPA30Cnt & 1) ? "Off" : "On");
Cal_ShowString(StringBuffer, &StringRect, TRUE);
if (bZoomIn == TRUE)
{
if (Lens_Zoom_GetSection() >= Lens_Zoom_GetMaxSection())
{
uiTotalPicNum++;
Cal_CIPAUpdatePicNum();
bZoomIn = FALSE;
set_flg(FLG_ID_KEY_REL, FLGKEY_ZOOMIN);
set_flg(FLG_ID_KEY, FLGKEY_RELEASED | FLGKEY_SHUTTER1 | FLGKEY_SHUTTER2);
uiCIPA30Cnt++;
}
}
else if (bZoomOut == TRUE)
{
if (Lens_Zoom_GetSection() <= MIN_ZOOM_SECTION)
{
uiTotalPicNum++;
Cal_CIPAUpdatePicNum();
bZoomOut = FALSE;
set_flg(FLG_ID_KEY_REL, FLGKEY_ZOOMOUT);
set_flg(FLG_ID_KEY, FLGKEY_RELEASED | FLGKEY_SHUTTER1 | FLGKEY_SHUTTER2);
uiCIPA30Cnt++;
}
}
// 30 Second
if ((uiCIPACnt % 30) == 0)
{
// Take 10 pictures
if (uiCIPA30Cnt < 10)
{
if (uiCIPA30Cnt & 1)
{
// Zoom Out and Flash = Off
set_flg(FLG_ID_KEY, FLGKEY_ZOOMOUT);
ImgCapture_SetParameter(_FlashMode, _IMGFlashMode_ForceOFF);
bZoomOut = TRUE;
}
else
{
// Zoom In and Flash = FULL
set_flg(FLG_ID_KEY, FLGKEY_ZOOMIN);
ImgCapture_SetParameter(_FlashMode, _IMGFlashMode_ForceON);
bZoomIn = TRUE;
}
}
else
{
KeyScan_Poweroff();
}
}
}
}
void PlaySoundTsk(void)
{
FLGPTN uiFlag;
AUDIO_DEVICE_OBJ AudioDevice;
AUDIO_BUF_QUEUE AudioBufQueue;
//#NT#2010/01/20#JustinLee -begin
//#Add wav header parsing before playing sound data
WAV_FILEINFO WAVFileInfo;
//#NT#2010/01/20#JustinLee -end
while (1)
{
wai_flg(&uiFlag, FLG_ID_SOUND, FLGSOUND_STOP | FLGSOUND_PLAY, TWF_ORW | TWF_CLR);
if (uiFlag & FLGSOUND_STOP)
{
if (g_uiPlaySoundStatus == PLAYSOUND_STS_PLAYING)
{
aud_stop();
aud_close();
g_uiPlaySoundStatus = PLAYSOUND_STS_STOPPED;
set_flg(FLG_ID_SOUND, FLGSOUND_STOPPED);
}
}
if (uiFlag & FLGSOUND_PLAY)
{
//#NT#2009/06/24#Chris Chung -begin
//#NT#avoid re-entry to audio driver.
if(aud_isBusy())
continue;
//#NT#2009/06/24#Chris Chung -end
g_uiPlaySoundStatus = PLAYSOUND_STS_PLAYING;
clr_flg(FLG_ID_SOUND, FLGSOUND_STOPPED);
// Open audio driver
aud_getDeviceObject(&AudioDevice);
AudioDevice.pEventHandler = PlaySound_AudioHdl;
aud_open(&AudioDevice);
switch (g_uiPlaySoundSound)
{
case PLAYSOUND_SOUND_STARTUP:
case PLAYSOUND_SOUND_SHUTDOWN:
// Parse header before playing
if(PlaySound_ParseWAVHeader((UINT32)g_PowerOn_SoundKey.puiData, &WAVFileInfo) == TRUE)
{
// Set sampling rate and channel based on parameter
aud_setSamplingRate(WAVFileInfo.AudioSamplingRate);
aud_setChannel(WAVFileInfo.AudioChannel);
// Set audio buffer queue addr and size
AudioBufQueue.uiAddress = ((UINT32)g_PowerOn_SoundKey.puiData) + (sizeof(WAV_PCMHEADER));
AudioBufQueue.uiSize = WAVFileInfo.uiDataSize;
}
else
{
// Set sampling rate and channel manually
aud_setSamplingRate(AUDIO_SR_32000);
aud_setChannel(AUDIO_CH_LEFT);
// Set audio buffer queue addr and size
AudioBufQueue.uiAddress = (UINT32)g_PowerOn_SoundKey.puiData;
AudioBufQueue.uiSize = g_PowerOn_SoundKey.uiSize;
}
break;
case PLAYSOUND_SOUND_KEY_SHUTTER2:
// Parse header before playing
if(PlaySound_ParseWAVHeader((UINT32)g_Shutter_SoundKey.puiData, &WAVFileInfo) == TRUE)
{
// Set sampling rate and channel based on parameter
aud_setSamplingRate(WAVFileInfo.AudioSamplingRate);
aud_setChannel(WAVFileInfo.AudioChannel);
// Set audio buffer queue addr and size
AudioBufQueue.uiAddress = ((UINT32)g_Shutter_SoundKey.puiData) + (sizeof(WAV_PCMHEADER));
AudioBufQueue.uiSize = WAVFileInfo.uiDataSize;
}
else
{
// Set sampling rate and channel manually
aud_setSamplingRate(AUDIO_SR_32000);
aud_setChannel(AUDIO_CH_LEFT);
// Set audio buffer queue addr and size
AudioBufQueue.uiAddress = (UINT32)g_Shutter_SoundKey.puiData;
AudioBufQueue.uiSize = g_Shutter_SoundKey.uiSize;
}
break;
case PLAYSOUND_SOUND_KEY_OTHERS:
// Parse header before playing
if(PlaySound_ParseWAVHeader((UINT32)g_SoundKey.puiData, &WAVFileInfo) == TRUE)
{
// Set sampling rate and channel based on parameter
aud_setSamplingRate(WAVFileInfo.AudioSamplingRate);
aud_setChannel(WAVFileInfo.AudioChannel);
// Set audio buffer queue addr and size
AudioBufQueue.uiAddress = ((UINT32)g_SoundKey.puiData) + (sizeof(WAV_PCMHEADER));
AudioBufQueue.uiSize = WAVFileInfo.uiDataSize;
}
else
{
// Set sampling rate and channel manually
aud_setSamplingRate(AUDIO_SR_32000);
aud_setChannel(AUDIO_CH_LEFT);
// Set audio buffer queue addr and size
AudioBufQueue.uiAddress = (UINT32)g_SoundKey.puiData;
AudioBufQueue.uiSize = g_SoundKey.uiSize;
}
break;
default:
aud_close();
continue;
}
// Set time code offset and first time code trigger value
aud_setTimecodeOffset(0);
aud_setTimecodeTrigger(AudioBufQueue.uiSize >> 1);
// Reset audio buffer queue and add buffer to queue
aud_resetBufferQueue();
aud_addBufferToQueue(&AudioBufQueue);
// Start to play
aud_playback(FALSE, TRUE);
}
}
}
/**
Detect SD card is inserted or not
Detect SD card is inserted or not.
If SD card is inserted, then detect SD card write protect status and
store it in bStrgCardLock
[KeyScan internal API]
@param void
@return void
*/
void KeyScan_DetStrgCard(void)
{
static UINT32 uiStrgCardPrevSts = KEYSCAN_CARD_UNKNOWN;
UINT32 uiStrgCardCurSts;
if (GPIOMap_DetStrgCard() == TRUE)
{
uiStrgCardCurSts = KEYSCAN_CARD_INSERTED;
}
else
{
uiStrgCardCurSts = KEYSCAN_CARD_REMOVED;
}
// Debounce
if ((uiStrgCardCurSts == uiStrgCardPrevSts) &&
(uiStrgCardCurSts != uiStrgCardStatus))
{
if (uiStrgCardCurSts == KEYSCAN_CARD_INSERTED)
{
#if (KEYSCAN_CARDDET_INT == ENABLE)
gpio_setIntTypePol(KEYSCAN_CD_GPIO_INT, GPIO_INTTYPE_LEVEL, GPIO_INTPOL_POSHIGH);
#endif
bStrgCardLock = GPIOMap_DetStrgCardWP();
SetFSStatus(FS_NOT_INIT);
Primary_ChangeStorage(PRIMARY_STGTYPE_CARD);
#if (KEYSCAN_SDWRPTDET_GPIO == ENABLE)
bStrgCardLock = GPIOMap_DetStrgCardWP();
#endif
if (bStrgCardLock)
{
SetCardStatus(CARD_LOCKED);
}
else
{
SetCardStatus(CARD_INSERTED);
}
debug_err(("Storage Card inserted!\r\n"));
}
else
{
#if (KEYSCAN_CARDDET_INT == ENABLE)
gpio_setIntTypePol(KEYSCAN_CD_GPIO_INT, GPIO_INTTYPE_LEVEL, GPIO_INTPOL_NEGLOW);
#endif
SetFSStatus(FS_NOT_INIT);
Primary_ChangeStorage(PRIMARY_STGTYPE_NAND);
bStrgCardLock = FALSE;
SetCardStatus(CARD_REMOVED);
debug_err(("Storage Card removed!\r\n"));
}
if (uiStrgCardStatus != KEYSCAN_CARD_UNKNOWN)
{
#if (KEYSCAN_CARD_HOTPLUG_FUNC == ENABLE)
//#NT#2011/08/10#KS Hung -begin
switch (FlowMovie_GetMovDataState())
{
case MOV_ST_REC:
case MOV_ST_REC | MOV_ST_ZOOM:
MovRec_Stop(TRUE);
TimerDelayMs(1000);//henry 20141218
break;
default:
//KeyScan_PoweroffFlow();
break;
}
//#NT#2011/08/10#KS Hung -end
// Open storage change notice window to wait NVTEVT_STORAGE_CHANGE evt
// Then utilize mode change (to current mode) to re-init current mode and ui window
if(!GPIOMap_IsLCDBacklightOn())
{
g_uiKeyScanAutoLcdoffCnt = 0;
GPIOMap_TurnOnLCDBacklight();
}
Ux_SendEvent(&UISystemObjCtrl,NVTEVT_CHANGE_DSCMODE,1,DSCMODE_CHGTO_CURR);
#else
//power off while insert or remove card
FilesysAbortCmd(FST_CMD_CLOSE_FILE );
FilesysAbortCmd(FST_CMD_DELETE_FILE );
FilesysAbortCmd(FST_CMD_FORMAT );
FilesysAbortCmd(FST_CMD_STORAGE_COPY_TO );
g_bFilesysAbortCmd = TRUE;
//set fst done for PB_WAIT_INFINITE
set_flg(FLG_ID_FILESYS, FLGFILESYS_DONE);
if(!GPIOMap_IsLCDBacklightOn())
{
g_uiKeyScanAutoLcdoffCnt = 0;
GPIOMap_TurnOnLCDBacklight();
}
KeyScan_PoweroffFlow();
#endif
}
uiStrgCardStatus = uiStrgCardCurSts;
#if (KEYSCAN_CARDDET_INT == ENABLE)
gpio_setIntIsr(KEYSCAN_CD_GPIO_INT, KeyScan_DetStrgCardIsr);
gpio_enableInt(KEYSCAN_CD_GPIO_INT);
#endif
}
uiStrgCardPrevSts = uiStrgCardCurSts;
}
void task1( unsigned int arg )
{
ER ercd;
int tests = 0;
CYG_TEST_INFO( "Task 1 running" );
ercd = dis_dsp();
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
ercd = sta_tsk( 2, 22222 );
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" );
ercd = chg_pri( 2, 5 );
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" );
ercd = ena_dsp();
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
ercd = dly_tsk( 10 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_sem( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" );
ercd = del_sem( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" );
ercd = cre_sem( -6, &t_csem );
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" );
ercd = cre_sem( 99, &t_csem );
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_sem bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
// check it is deleted
ercd = sig_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = preq_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "preq_sem bad ercd !E_NOEXS" );
ercd = twai_sem( 3, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_sem bad ercd !E_NOEXS" );
ercd = wai_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_sem bad ercd !E_NOEXS" );
ercd = ref_sem( &t_rsem, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_sem bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_sem( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" );
#endif
ercd = cre_sem( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" );
t_csem.sematr = 0xfff;
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_sem bad ercd !E_RSATR" );
t_csem.sematr = 0;
#endif // we can test bad param error returns
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
// and check we can use it
ercd = sig_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" );
ercd = wai_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" );
ercd = preq_sem( 3 );
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" );
ercd = twai_sem( 3, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" );
ercd = ref_sem( &t_rsem, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_sem( 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" );
// check they are deleted
ercd = sig_sem( 1 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = sig_sem( 2 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
// re-create and do it again
ercd = cre_sem( 1, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
ercd = cre_sem( 2, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_sem( 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" );
// check they are deleted
ercd = sig_sem( 1 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = sig_sem( 2 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete semaphores");
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_flg( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" );
ercd = del_flg( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" );
ercd = cre_flg( -6, &t_cflg );
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" );
ercd = cre_flg( 99, &t_cflg );
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_flg bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_flg( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
// check it is deleted
ercd = set_flg( 3, 0x6789 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
ercd = clr_flg( 3, 0x9876 );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
ercd = pol_flg( &scratch, 3, 0xdddd, TWF_ANDW );
CYG_TEST_CHECK( E_NOEXS == ercd, "pol_flg bad ercd !E_NOEXS" );
ercd = twai_flg( &scratch, 3, 0x4444, TWF_ORW, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_flg bad ercd !E_NOEXS" );
ercd = wai_flg( &scratch, 3, 0xbbbb, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_flg bad ercd !E_NOEXS" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_flg bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_flg( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" );
#endif
ercd = cre_flg( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" );
t_cflg.flgatr = 0xfff;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_flg bad ercd !E_RSATR" );
#endif // we can test bad param error returns
// now create it well
t_cflg.flgatr = 0;
t_cflg.iflgptn = 0;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// and check we can use it
ercd = clr_flg( 3, 0x7256 );
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" );
ercd = set_flg( 3, 0xff );
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" );
ercd = wai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
ercd = twai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" );
// now create it again with a preset pattern and check that we can
// detect that pattern:
ercd = del_flg( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
t_cflg.flgatr = 0;
t_cflg.iflgptn = 0x1234;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// and check we can use it
ercd = wai_flg( &scratch, 3, 0x1200, TWF_ANDW );
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0x0034, TWF_ANDW );
CYG_TEST_CHECK( E_OK == ercd, "pol_flg bad ercd" );
ercd = twai_flg( &scratch, 3, 0x1004, TWF_ANDW, 10 );
CYG_TEST_CHECK( E_OK == ercd, "twai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0xffedcb, TWF_ORW );
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0x1234 == t_rflg.flgptn, "ref_flg bad ercd" );
ercd = clr_flg( 3, 0 );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_flg( &scratch, 1, 0xaa, TWF_ANDW );
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_flg( &scratch, 2, 0x55, TWF_ANDW, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" );
// check they are deleted
ercd = set_flg( 1, 0x22 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
ercd = clr_flg( 2, 0xdd );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
// re-create and do it again
t_cflg.iflgptn = 0x5555;
ercd = cre_flg( 1, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
t_cflg.iflgptn = 0;
ercd = cre_flg( 2, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_flg( &scratch, 1, 0xaaaa, TWF_ORW | TWF_CLR );
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_flg( &scratch, 2, 0xffff, TWF_ORW, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" );
// check they are deleted
ercd = clr_flg( 1, 0xd00d );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
ercd = set_flg( 2, 0xfff00 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete flags");
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_mbx( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" );
ercd = del_mbx( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" );
ercd = cre_mbx( -6, &t_cmbx );
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );
ercd = cre_mbx( 99, &t_cmbx );
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mbx bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_mbx( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
// check it is deleted
ercd = snd_msg( 3, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = rcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "rcv_msg bad ercd !E_NOEXS" );
ercd = trcv_msg( &msg, 3, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "trcv_msg bad ercd !E_NOEXS" );
ercd = prcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "prcv_msg bad ercd !E_NOEXS" );
ercd = ref_mbx( &t_rmbx, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mbx bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_mbx( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );
#endif
ercd = cre_mbx( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );
t_cmbx.mbxatr = 0xfff;
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mbx bad ercd !E_RSATR" );
t_cmbx.mbxatr = 0;
#endif // we can test bad param error returns
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
// and check we can use it
ercd = snd_msg( 3, t_msg );
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" );
ercd = rcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" );
ercd = trcv_msg( &msg, 3, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" );
ercd = prcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );
ercd = ref_mbx( &t_rmbx, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = rcv_msg( &msg, 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = trcv_msg( &msg, 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );
// check they are deleted
ercd = snd_msg( 1, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = snd_msg( 2, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
// re-create and do it again
ercd = cre_mbx( 1, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
ercd = cre_mbx( 2, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = rcv_msg( &msg, 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = trcv_msg( &msg, 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );
// check they are deleted
ercd = snd_msg( 1, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = snd_msg( 2, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete mboxes");
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE
ercd = ter_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );
ercd = dly_tsk( 5 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
// all done
if ( 0 == tests ) {
CYG_TEST_NA( "No objects have create/delete enabled" );
}
else {
CYG_TEST_EXIT( "All done" );
}
ext_tsk();
}
void GPSRec_NMEAParser(CHAR *NMEA_str, UINT32 Len, NMEATYPE NMEAtype)
{
UINT32 i;
pPostPrt = PostPtr;
PostPtrLen = Len;
GPSRec_TransformData(NMEA_str, Len, pPostPrt, &PostPtrLen);
switch(NMEAtype)
{
case GSA:
sscanf(pPostPrt, "%s %c %d %d %d %d %d %d %d %d %d %d %d %d %d %lf %lf %lf %X\n", type, &SelMode, &FixMode, &SatUsed01, &SatUsed02, &SatUsed03, &SatUsed04, &SatUsed05, &SatUsed06, &SatUsed07, &SatUsed08, &SatUsed09, &SatUsed10, &SatUsed11, &SatUsed12, &PDOP, &HDOP, &VDOP, &CheckSum);
#if (_GPS_CheckSum_Enable)
GPSRec_CheckSum(NMEA_str, Len, CheckSum);
#endif
if (FixMode != No_Fix)
{
GSAInfo.SelMode = SelMode;
GSAInfo.FixMode = FixMode;
GSAInfo.SatUsed01 = SatUsed01;
GSAInfo.SatUsed02 = SatUsed02;
GSAInfo.SatUsed03 = SatUsed03;
GSAInfo.SatUsed04 = SatUsed04;
GSAInfo.SatUsed05 = SatUsed05;
GSAInfo.SatUsed06 = SatUsed06;
GSAInfo.SatUsed07 = SatUsed07;
GSAInfo.SatUsed08 = SatUsed08;
GSAInfo.SatUsed09 = SatUsed09;
GSAInfo.SatUsed10 = SatUsed10;
GSAInfo.SatUsed11 = SatUsed11;
GSAInfo.SatUsed12 = SatUsed12;
GSAInfo.PDOP = PDOP;
GSAInfo.HDOP = HDOP;
GSAInfo.VDOP = VDOP;
GPS_debug(("#GSA SelMode = %c, FixMode = %d \r\n",GSAInfo.SelMode,GSAInfo.FixMode));
GPS_debug(("#GSA SelMode = %c, FixMode = %d \r\n",GSAInfo.SelMode,GSAInfo.FixMode));
GPS_debug(("#GSA SatUsed1 = %d, %d, %d, %d \r\n",GSAInfo.SatUsed01,GSAInfo.SatUsed02, GSAInfo.SatUsed03, GSAInfo.SatUsed04));
GPS_debug(("#GSA SatUsed2 = %d, %d, %d, %d \r\n",GSAInfo.SatUsed05,GSAInfo.SatUsed06, GSAInfo.SatUsed07, GSAInfo.SatUsed08));
GPS_debug(("#GSA SatUsed3 = %d, %d, %d, %d \r\n",GSAInfo.SatUsed09,GSAInfo.SatUsed10, GSAInfo.SatUsed11, GSAInfo.SatUsed12));
GPS_debug(("#PDOP = %.1f, HDOP = %.1f, VDOP = %.1f CheckSum = %X\r\n",GSAInfo.PDOP,GSAInfo.HDOP, GSAInfo.VDOP,CheckSum));
}
if (Len)
{
for (i = 0; i < Len; i++)
NMEA_debug(("%c",*NMEA_str++));
}
NMEA_debug(("\r\n"));
//Check processed sentence
/*
if (PostPtrLen)
{
for (i = 0; i < PostPtrLen; i++)
NMEA_debug(("%c",*pPostPrt++));
}
NMEA_debug(("\r\n"));
*/
break;
case RMC:
sscanf(pPostPrt, "%s %lf %c %lf %c %lf %c %lf %lf %d %lf %c %X\n", type, &UTCTime, &Status, &Lat, &NSInd, &Lon, &EWInd, &Speed, &Angle, &Date, &MagVar, &MagVarInd, &CheckSum);
#if (_GPS_CheckSum_Enable)
GPSRec_CheckSum(NMEA_str, Len, CheckSum);
#endif
RMCInfo.Hour = (UINT32)UTCTime / 10000;
RMCInfo.Minute = ((UINT32)UTCTime % 10000) / 100;
RMCInfo.Second = ((UINT32)UTCTime % 100);
RMCInfo.Status = Status;
RMCInfo.Latitude = Lat;
RMCInfo.NSInd = NSInd;
RMCInfo.Longitude = Lon;
RMCInfo.EWInd = EWInd;
RMCInfo.Speed = Speed;
RMCInfo.Angle = Angle;
RMCInfo.Day = Date / 10000;
RMCInfo.Month = (Date % 10000) / 100;
RMCInfo.Year = (Date % 100);
if (Status == 'A') //Data valid
{
set_flg(FLG_ID_GPS, GPS_FLAG_DATAVALID);
GPS_debug(("\x1b[34m")); //Blue
GPS_debug(("#RMC: Status = %c, Speed = %.1f, Angle = %.1f \r\n",RMCInfo.Status,RMCInfo.Speed,RMCInfo.Angle));
GPS_debug(("#RMC: Date = %d\\%d\\%d CheckSum = %X\r\n",RMCInfo.Year,RMCInfo.Month,RMCInfo.Day,CheckSum));
GPS_debug(("\x1b[30m")); //Black
}
else if (Status == 'V')
{
clr_flg(FLG_ID_GPS, GPS_FLAG_DATAVALID);
}
NMEA_debug(("\x1b[34m")); //Blue
if (Len)
{
for (i = 0; i < Len; i++)
NMEA_debug(("%c",*NMEA_str++));
}
NMEA_debug(("\r\n"));
//Check processed sentence
/*
if (PostPtrLen)
{
for (i = 0; i < PostPtrLen; i++)
NMEA_debug(("%c",*pPostPrt++));
}
NMEA_debug(("\r\n"));
*/
NMEA_debug(("\x1b[30m")); //Black
break;
case GGA:
sscanf(pPostPrt, "%s %lf %lf %c %lf %c %d %d %lf %lf %c %lf %c %d %d %X\n", type, &UTCTime, &Lat, &NSInd, &Lon, &EWInd, &PosFixInd, &SatNumber, &HDOP, &Alt, &M1, &MSL, &M2, &Empty1, &Empty2, &CheckSum);
#if (_GPS_CheckSum_Enable)
GPSRec_CheckSum(NMEA_str, Len, CheckSum);
#endif
if (PosFixInd == 1) //Data valid
{
GGAInfo.Hour = (UINT32)UTCTime / 10000;
GGAInfo.Minute = ((UINT32)UTCTime % 10000) / 100;
GGAInfo.Second = ((UINT32)UTCTime % 100);
GGAInfo.Latitude = Lat;
GGAInfo.NSInd = NSInd;
GGAInfo.Longitude = Lon;
GGAInfo.EWInd = EWInd;
GGAInfo.PosFixInd = PosFixInd;
GGAInfo.SatNumber = SatNumber;
GGAInfo.HDOP = HDOP;
GGAInfo.Altitude = Alt;
GGAInfo.MSL = MSL;
GPS_debug(("\x1b[31m")); //Red
GPS_debug(("#GGA: Time = %d:%d:%d CheckSum = %X\r\n", GGAInfo.Hour, GGAInfo.Minute, GGAInfo.Second,CheckSum));
GPS_debug(("#GGA: Lat = %1f %c, Lon = %1f %c \r\n", GGAInfo.Latitude, NSInd, GGAInfo.Longitude, EWInd));
GPS_debug(("#GGA: PosFixInd = %d, SatNum = %d, HDOP = %2.1f, Alt = %.1f, MSL = %.1f \r\n", GGAInfo.PosFixInd, GGAInfo.SatNumber, GGAInfo.HDOP, GGAInfo.Altitude, GGAInfo.MSL));
GPS_debug(("\x1b[30m")); //Black
}
NMEA_debug(("\x1b[31m")); //Red
if (Len)
{
for (i = 0; i < Len; i++)
NMEA_debug(("%c",*NMEA_str++));
}
NMEA_debug(("\r\n"));
//Check processed sentence
/*
if (PostPtrLen)
{
for (i = 0; i < PostPtrLen; i++)
NMEA_debug(("%c",*pPostPrt++));
}
NMEA_debug(("\r\n"));
*/
NMEA_debug(("\x1b[30m")); //Black
break;
case GSV:
sscanf(pPostPrt, "%s %d %d %d %s\n", type, &NumOfSen, &SenNum, &SatInView, RemainStr);
if (NumOfSen == SenNum)
{
if ((SatInView % 4) == 1)
sscanf(pPostPrt, "%s %d %d %d %d %d %d %d %X\n", type, &NumOfSen, &SenNum, &SatInView, &SatNum1, &Elev1, &Azi1, &SNR1, &CheckSum);
else if ((SatInView % 4) == 2)
sscanf(pPostPrt, "%s %d %d %d %d %d %d %d %d %d %d %d %X\n", type, &NumOfSen, &SenNum, &SatInView, &SatNum1, &Elev1, &Azi1, &SNR1, &SatNum2, &Elev2, &Azi2, &SNR2, &CheckSum);
else if ((SatInView % 4) == 3)
sscanf(pPostPrt, "%s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %X\n", type, &NumOfSen, &SenNum, &SatInView, &SatNum1, &Elev1, &Azi1, &SNR1, &SatNum2, &Elev2, &Azi2, &SNR2, &SatNum3, &Elev3, &Azi3, &SNR3, &CheckSum);
else
sscanf(pPostPrt, "%s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %X\n", type, &NumOfSen, &SenNum, &SatInView, &SatNum1, &Elev1, &Azi1, &SNR1, &SatNum2, &Elev2, &Azi2, &SNR2, &SatNum3, &Elev3, &Azi3, &SNR3, &SatNum4, &Elev4, &Azi4, &SNR4, &CheckSum);
}
else
sscanf(pPostPrt, "%s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %X\n", type, &NumOfSen, &SenNum, &SatInView, &SatNum1, &Elev1, &Azi1, &SNR1, &SatNum2, &Elev2, &Azi2, &SNR2, &SatNum3, &Elev3, &Azi3, &SNR3, &SatNum4, &Elev4, &Azi4, &SNR4, &CheckSum);
#if (_GPS_CheckSum_Enable)
GPSRec_CheckSum(NMEA_str, Len, CheckSum);
#endif
if (SenNum == 1) //GSV1
{
GSVInfo.NumOfSen = NumOfSen;
GSVInfo.SatInView = SatInView;
GSVInfo.SAT01.SatNum = SatNum1;
GSVInfo.SAT01.Elev = Elev1;
GSVInfo.SAT01.Azi = Azi1;
GSVInfo.SAT01.SNR = SNR1;
GSVInfo.SAT02.SatNum = SatNum2;
GSVInfo.SAT02.Elev = Elev2;
GSVInfo.SAT02.Azi = Azi2;
GSVInfo.SAT02.SNR = SNR2;
GSVInfo.SAT03.SatNum = SatNum3;
GSVInfo.SAT03.Elev = Elev3;
GSVInfo.SAT03.Azi = Azi3;
GSVInfo.SAT03.SNR = SNR3;
GSVInfo.SAT04.SatNum = SatNum4;
GSVInfo.SAT04.Elev = Elev4;
GSVInfo.SAT04.Azi = Azi4;
GSVInfo.SAT04.SNR = SNR4;
GPS_debug(("\x1b[35m")); //Violet
GPS_debug(("#GSV%d SatInView = %d, CheckSum = %X\r\n",SenNum, SatInView, CheckSum));
GPS_debug(("#GSV%d Sat1 = %d, %d, %d, %d, Sat2 = %d, %d, %d, %d\r\n",SenNum, SatNum1, Elev1, Azi1, SNR1, SatNum2, Elev2, Azi2, SNR2));
GPS_debug(("#GSV%d Sat3 = %d, %d, %d, %d, Sat4 = %d, %d, %d, %d\r\n",SenNum, SatNum3, Elev3, Azi3, SNR3, SatNum4, Elev4, Azi4, SNR4));
GPS_debug(("\x1b[30m")); //Black
}
else if (SenNum == 2) //GSV2
{
GSVInfo.NumOfSen = NumOfSen;
GSVInfo.SatInView = SatInView;
GSVInfo.SAT05.SatNum = SatNum1;
GSVInfo.SAT05.Elev = Elev1;
GSVInfo.SAT05.Azi = Azi1;
GSVInfo.SAT05.SNR = SNR1;
GSVInfo.SAT06.SatNum = SatNum2;
GSVInfo.SAT06.Elev = Elev2;
GSVInfo.SAT06.Azi = Azi2;
GSVInfo.SAT06.SNR = SNR2;
GSVInfo.SAT07.SatNum = SatNum3;
GSVInfo.SAT07.Elev = Elev3;
GSVInfo.SAT07.Azi = Azi3;
GSVInfo.SAT07.SNR = SNR3;
GSVInfo.SAT08.SatNum = SatNum4;
GSVInfo.SAT08.Elev = Elev4;
GSVInfo.SAT08.Azi = Azi4;
GSVInfo.SAT08.SNR = SNR4;
GPS_debug(("\x1b[35m")); //Violet
GPS_debug(("#GSV%d SatInView = %d, CheckSum = %X\r\n",SenNum, SatInView, CheckSum));
GPS_debug(("#GSV%d Sat5 = %d, %d, %d, %d, Sat6 = %d, %d, %d, %d\r\n",SenNum, SatNum1, Elev1, Azi1, SNR1, SatNum2, Elev2, Azi2, SNR2));
GPS_debug(("#GSV%d Sat7 = %d, %d, %d, %d, Sat8 = %d, %d, %d, %d\r\n",SenNum, SatNum3, Elev3, Azi3, SNR3, SatNum4, Elev4, Azi4, SNR4));
GPS_debug(("\x1b[30m")); //Black
}
else if (SenNum == 3) //GSV3
{
GSVInfo.NumOfSen = NumOfSen;
GSVInfo.SatInView = SatInView;
GSVInfo.SAT09.SatNum = SatNum1;
GSVInfo.SAT09.Elev = Elev1;
GSVInfo.SAT09.Azi = Azi1;
GSVInfo.SAT09.SNR = SNR1;
GSVInfo.SAT10.SatNum = SatNum2;
GSVInfo.SAT10.Elev = Elev2;
GSVInfo.SAT10.Azi = Azi2;
GSVInfo.SAT10.SNR = SNR2;
GSVInfo.SAT11.SatNum = SatNum3;
GSVInfo.SAT11.Elev = Elev3;
GSVInfo.SAT11.Azi = Azi3;
GSVInfo.SAT11.SNR = SNR3;
GSVInfo.SAT12.SatNum = SatNum4;
GSVInfo.SAT12.Elev = Elev4;
GSVInfo.SAT12.Azi = Azi4;
GSVInfo.SAT12.SNR = SNR4;
GPS_debug(("\x1b[35m")); //Violet
GPS_debug(("#GSV%d SatInView = %d, CheckSum = %X\r\n",SenNum, SatInView, CheckSum));
GPS_debug(("#GSV%d Sat9 = %d, %d, %d, %d, Sat10 = %d, %d, %d, %d\r\n",SenNum, SatNum1, Elev1, Azi1, SNR1, SatNum2, Elev2, Azi2, SNR2));
GPS_debug(("#GSV%d Sat11 = %d, %d, %d, %d, Sat12 = %d, %d, %d, %d\r\n",SenNum, SatNum3, Elev3, Azi3, SNR3, SatNum4, Elev4, Azi4, SNR4));
GPS_debug(("\x1b[30m")); //Black
}
else
debug_err(("GPS: Invalid number of GSV"));
NMEA_debug(("\x1b[35m")); //Violet
if (Len)
{
for (i = 0; i < Len; i++)
NMEA_debug(("%c",*NMEA_str++));
}
NMEA_debug(("\r\n"));
//Check processed sentence
/*
if (PostPtrLen)
{
for (i = 0; i < PostPtrLen; i++)
NMEA_debug(("%c",*pPostPrt++));
}
NMEA_debug(("\r\n"));
*/
NMEA_debug(("\x1b[30m")); //Black
break;
//Do not support GLL and VTG yet
case GLL:
NMEA_debug(("\x1b[36m")); //Blue
if (Len)
{
for (i = 0; i < Len; i++)
NMEA_debug(("%c",*NMEA_str++));
}
NMEA_debug(("\r\n"));
NMEA_debug(("\x1b[30m")); //Black
break;
case VTG:
NMEA_debug(("\x1b[32m")); //Green
if (Len)
{
for (i = 0; i < Len; i++)
NMEA_debug(("%c",*NMEA_str++));
}
NMEA_debug(("\r\n"));
NMEA_debug(("\x1b[30m")); //Black
break;
default:
break;
}
}
/**
BurnIn main loop
BurnIn main loop
[CalBurnIn internal API]
@param UINT32 uiOperation: Which operation you want to run
BURNIN_OP_BURNIN (Burn In)
BURNIN_OP_ZOOMAF (ZoomAF Lasting)
BURNIN_OP_FLASH (Flash Lasting)
BURNIN_OP_168H (168H)
@return void
*/
static void Cal_BurnIn(UINT32 uiOperation)
{
UINT32 uiTimerID, uiFlag;
UINT32 uiKeyFlagID, uiKeyEvent;
// UINT32 uiOldPressConfig, uiOldReleaseConfig;
UINT32 uiTotalIteration;
UINT32 uiInterval;
UINT32 uiEventCnt;
PSIM_EVENT pSimEvent, pStartEvent;
UINT8 uiKeyStatus, uiRepeatCnt;
if(i2c_getLockStatus())
i2c_unlock();
// Open timer
if (TIMEROpen((UINT *)&uiTimerID, Cal_BurnInTimerISR) != E_OK)
{
/*
set_scankey_press_config(uiOldPressConfig);
set_scankey_release_config(uiOldReleaseConfig);
*/
return;
}
switch (uiOperation)
{
case BURNIN_OP_BURNIN:
//read cal status for check finish item
ReadCalData();
FilesysFormat(Primary_GetStorageObj(PRIMARY_STGTYPE_NAND), TRUE);
FilesysWaitCmdFinish(FST_TIME_INFINITE);
FilesysFormat(Primary_GetStorageObj(PRIMARY_STGTYPE_NAND), TRUE);
//if(Cal_CheckStatus()!= 0)
// return ;
uiTotalIteration = 40; //2hour //10 ; // 10*3 min = 30 mins
pStartEvent = (PSIM_EVENT)&BurnInEvent;
Primary_ChangeMode(PRIMARY_MODE_PHOTO);
break;
case BURNIN_OP_ZOOMAF:
uiTotalIteration = 1000;
pStartEvent = (PSIM_EVENT)&ZoomAFEvent;
Primary_ChangeMode(PRIMARY_MODE_PHOTO);
break;
case BURNIN_OP_FLASH:
FilesysWaitCmdFinish(FST_TIME_INFINITE);
FilesysFormat(Primary_GetStorageObj(PRIMARY_STGTYPE_NAND), TRUE);
uiTotalIteration = 8; //15 min * 8 = 2 hr
pStartEvent = (PSIM_EVENT)&FlashEvent;
Primary_ChangeMode(PRIMARY_MODE_PHOTO);
SysSetFlag(FL_FLASH, FLASH_ON);
break;
case BURNIN_OP_168H:
//read cal status for check finish item
ReadCalData();
FilesysWaitCmdFinish(FST_TIME_INFINITE);
FilesysFormat(Primary_GetStorageObj(PRIMARY_STGTYPE_NAND), TRUE);
//if(Cal_CheckStatus()!= 0)
// return ;
uiTotalIteration = 0xFFFFFFFF;
pStartEvent = (PSIM_EVENT)&BurnInEvent;
Primary_ChangeMode(PRIMARY_MODE_PHOTO);
break;
case BURNIN_OP_10MIN:
//read cal status for check finish item
ReadCalData();
FilesysWaitCmdFinish(FST_TIME_INFINITE);
FilesysFormat(Primary_GetStorageObj(PRIMARY_STGTYPE_NAND), TRUE);
//if(Cal_CheckStatus()!= 0)
// return ;
uiTotalIteration = 10; // 3 min * 10 =30 mins
pStartEvent = (PSIM_EVENT)&BurnInEvent;
Primary_ChangeMode(PRIMARY_MODE_PHOTO);
break;
}
// Init variable
uiTimeoutValue = 0;
// Enable timer and clear all flags
clr_flg(FLG_ID_BURNIN, FLGBURNIN_ALL);
TIMERSet(uiTimerID, TIMER_INTERVAL, _TIMER_CTRL_FREE_RUN | _TIMER_CTRL_INT_ENABLE, _TIMER_PLAY);
for (uiIteration=1; uiIteration<=uiTotalIteration; uiIteration++)
{
debug_ind(("\n\r ***Loop = %ld,Event= %ld ***\r\n", uiIteration, uiEventCnt));
pSimEvent = pStartEvent;
uiRepeatCnt = 0;
uiInterval = 0;
uiEventCnt = 0;
if(uiOperation == BURNIN_OP_FLASH)
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_EXE_SLIDE,1,SLIDE_5SEC);
ImageInfoTable = FlashImageInfoTable;
}
else
ImageInfoTable = BurnInImageInfoTable;
Delay_DelayMs(2000);
Cal_SetImageInfor_Value(uiRepeatCnt);
while (1)
{
wai_flg((UINT *)&uiFlag, FLG_ID_BURNIN, FLGBURNIN_TIMER, TWF_ORW | TWF_CLR);
uiInterval += TIMER_INTERVAL;
//avoid display msg too much
if(uiInterval%2000 == 0)
Cal_BurnInShowLoop(uiIteration, uiEventCnt,uiRepeatCnt);
//accumlate time until to interval;the post event
if (uiInterval >= pSimEvent->uiInterval)
{
uiInterval = 0;
#if 0
if((uiOperation == BURNIN_OP_BURNIN || uiOperation == BURNIN_OP_10MIN ) && (uiIteration == 4)) //about 10 min,run dark dp
{
Cal_BurnInLog(uiIteration,uiEventCnt,999);
if(uiOperation == BURNIN_OP_10MIN)
Cal_DPinBurnIn(FALSE); //not check dp status
else
Cal_DPinBurnIn(TRUE); // check dp status
break;
}
#endif
// End of event
if (pSimEvent->uiKeyFlagID == SIM_END)
{
break;
}
// Wait for specific flag, or change mode
else if (pSimEvent->uiKeyFlagID == FLG_ID_BURNIN)
{
if (pSimEvent->uiKeyEvent == FLGBURNIN_WAITING)
{
// Enable timeout
uiTimeoutValue = pSimEvent->uiInterval;
uiTimerCnt = 0;
clr_flg(FLG_ID_BURNIN, FLGBURNIN_TIMEOUT);
Cal_BurnInLog(uiIteration,uiEventCnt,uiRepeatCnt);
wai_flg((UINT *)&uiFlag, FLG_ID_BURNIN, pSimEvent->uiKeyEvent | FLGBURNIN_TIMEOUT, TWF_ORW | TWF_CLR);
if (uiFlag & FLGBURNIN_TIMEOUT)
{
debug_err(("Wait for specific flag timeout %d\r\n",pSimEvent->uiInterval));
}
// Disable timeout
uiTimeoutValue = 0;
// Clear timer flag
clr_flg(FLG_ID_BURNIN, FLGBURNIN_TIMER);
uiRepeatCnt = 0;
pSimEvent++;
uiEventCnt++;
debug_ind(("\n\rFLGBURNIN_WAITING ***Loop = %ld,Event= %ld ***\r\n", uiIteration, uiEventCnt));
continue;
}
}
else // FLG_ID_KEY
{
//log current event
Cal_BurnInLog(uiIteration,uiEventCnt,uiRepeatCnt);
uiKeyFlagID = pSimEvent->uiKeyFlagID;
uiKeyEvent = pSimEvent->uiKeyEvent;
uiKeyStatus = pSimEvent->uiKeyStatus;
// Set key event
if (uiKeyFlagID != NULL && uiKeyEvent != NULL)
{
//change key event to post message
if(uiKeyFlagID == FLG_ID_KEY)
{
/*
NVTMSG msg;
if(uiKeyStatus == KEY_STATUS_PRESS)
SET_COMMAND(&msg, NVTEVT_KEY_PRESS);
else
SET_COMMAND(&msg, NVTEVT_KEY_RELEASE);
debug_ind(("uiKeyEvent %x nvtcmd %x \r\n",uiKeyEvent ,Get_NVTCMD(uiKeyEvent)));
SET_KEY_EVENT(&msg,Get_NVTCMD(uiKeyEvent));
PostMessage(&msg);
*/
if(uiKeyEvent & (Input_GetKeyMask(KEY_PRESS)))
{
debug_err(("Ux_PostEvent %d \r\n",uiKeyEvent));
Ux_PostEvent(Get_NVTCMD(uiKeyEvent), 1, Get_NVTCMD(uiKeyEvent));
}
}
else
{
set_flg(uiKeyFlagID, uiKeyEvent);
}
}
}
uiRepeatCnt++;
// Move to next event
if (uiRepeatCnt == pSimEvent->uiRepeatCnt)
{
uiRepeatCnt = 0;
pSimEvent++;
uiEventCnt++;
debug_ind(("*****next event*Loop = %ld,Event= %ld ***************\r\n", uiIteration, uiEventCnt));
}
if ((pSimEvent == pStartEvent)&&((uiOperation==BURNIN_OP_10MIN)||(uiOperation==BURNIN_OP_BURNIN) || (uiOperation==BURNIN_OP_168H) || (uiOperation==BURNIN_OP_FLASH)) )
{
Delay_DelayMs(2000);
//for set flash charg,so set capture index first
Cal_SetImageInfor_Value(uiRepeatCnt);
}
}
}
}
TIMERClose(uiTimerID);
//tmp write to AAA for read cal data
AAA_Adjust.ISO_Status = _ISO_Status;
WriteCalData();
if(uiOperation == BURNIN_OP_FLASH)
sprintf(LogStringBuf,"Flash O\r\n");
else
sprintf(LogStringBuf,"BurnIn O\r\n");
Cal_ShowStringWithColor((INT8 *)LogStringBuf, 64,170, _OSD_INDEX_GREEN);
#if 0
Menu_PowerOff(POWER_OFF);
#endif
while(1)
;;
/*
set_scankey_press_config(uiOldPressConfig);
set_scankey_release_config(uiOldReleaseConfig);
*/
// Power off DSC after burn in done
// Premier don't want to power off now (2005.10.16)
/*
if (uiOperation == BURNIN_OP_BURNIN)
{
PowerOffFlow(TRUE, FALSE);
}
*/
}
/**
Lens control task
Lens control task to handle interrupt event.
@param void
@return void
*/
void LensCtrlTsk(void)
{
FLGPTN uiFlag;
while (1)
{
set_flg(FLG_ID_LENS, FLGLENS_IDLE);
wai_flg(&uiFlag, FLG_ID_LENS,
FLGLENS_ZOOMFWD |
FLGLENS_ZOOMREV |
FLGLENS_ZOOMBRK |
FLGLENS_ZOOMOFF |
FLGLENS_ZOOMCHANGE |
FLGLENS_FOCUSFWD |
FLGLENS_FOCUSREV |
FLGLENS_APERTUREMOVE |
FLGLENS_SHUTTERMOVE |
FLGLENS_POWEROFF
, TWF_ORW | TWF_CLR);
clr_flg(FLG_ID_LENS, FLGLENS_IDLE);
if(gLensCtrlObj.pMotor == NULL)
{
LENS_ERR(("LENS_E: %s pMotor is null\r\n", __func__));
continue;
}
if(uiFlag & FLGLENS_ZOOMBRK)
{
gLensCtrlObj.pMotor->zoom_setState(MOTOR_ZOOM_BRAKE, 0);
}
if(uiFlag & FLGLENS_ZOOMFWD)
{
gLensCtrlObj.pMotor->zoom_setState(MOTOR_ZOOM_FWD, gLensCtrlParamObj.uiZoomStep);
}
if(uiFlag & FLGLENS_ZOOMREV)
{
gLensCtrlObj.pMotor->zoom_setState(MOTOR_ZOOM_BWD, gLensCtrlParamObj.uiZoomStep);
}
if(uiFlag & FLGLENS_ZOOMOFF)
{
gLensCtrlObj.pMotor->zoom_setState(MOTOR_ZOOM_OFF, 0);
}
if(uiFlag & FLGLENS_ZOOMCHANGE)
{
if(gLensCtrlObj.fpLensCB != NULL)
{
AlgMsgInfo AlgMsg;
AlgMsg.OzoomIndex = gLensCtrlObj.pLens->zoom_getNextSection();
gLensCtrlObj.fpLensCB(ALGMSG_CHGOZOOMSTEP, &AlgMsg);
}
}
if(uiFlag & FLGLENS_FOCUSFWD)
{
gLensCtrlObj.pMotor->focus_setState(MOTOR_FOCUS_FWD, gLensCtrlParamObj.uiFocusStep);
}
if(uiFlag & FLGLENS_FOCUSREV)
{
gLensCtrlObj.pMotor->focus_setState(MOTOR_FOCUS_BWD, gLensCtrlParamObj.uiFocusStep);
}
if(uiFlag & FLGLENS_APERTUREMOVE)
{
gLensCtrlObj.pMotor->aperture_setState(gLensCtrlParamObj.uiApertureState);
}
if(uiFlag & FLGLENS_SHUTTERMOVE)
{
gLensCtrlObj.pMotor->shutter_setState(gLensCtrlParamObj.uiShutterState);
}
if(uiFlag & FLGLENS_POWEROFF)
{
TimerDelayMs(LENS_MAX_WAIT_TIME);
gLensCtrlObj.pMotor->changeMode(MOTOR_MODE_STANDBY);
gLensCtrlObj.pMotor->power(MOTOR_POWER_OFF);
}
}
}
