2263 lines
58 KiB
C
2263 lines
58 KiB
C
/*
|
|
* Battery s_stCharger driver for X-Powers AXP
|
|
*
|
|
* Copyright (C) 2013 X-Powers, Ltd.
|
|
* Zhang Donglu <zhangdonglu@x-powers.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
|
|
#include <sf_mcu.h>
|
|
|
|
#include <sf_commu_mcu.h>
|
|
|
|
#define __MODULE__ sf_mcu
|
|
#define __DBGLVL__ 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
|
|
#define __DBGFLT__ "*" // *=All, [mark]=CustomClass
|
|
#include "kwrap/debug.h"
|
|
//#include <kwrap/debug.h>
|
|
#include <kwrap/stdio.h>
|
|
#include <kwrap/util.h>
|
|
#include "comm/hwclock.h"
|
|
#include "comm/timer.h"
|
|
//#include <time.h>
|
|
#include <rtos_na51089/gpio.h>
|
|
#include <UIInfo.h>
|
|
#include "GxUSB.h"
|
|
|
|
#include <uart.h>
|
|
#include "FileSysTsk.h"
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sf_i2c_driver.h>
|
|
#include "PrjCfg.h"
|
|
#include "sf_battery.h"
|
|
|
|
static UINT8 McuSubVersion = 0;
|
|
static UINT16 McuVersion = 0;
|
|
static UINT8 DailyReportStartMode = 0;
|
|
UINT16 IRSHTTER = 0;
|
|
static UINT8 PowerOnMode = 0; //=>PWR_ON_SETUP
|
|
static UINT8 POWEROFF = 0;
|
|
static BOOL ConfigureModeFlag = 0; /* 0: HTC Mode, 1: Nomal Mode */
|
|
static UINT8 AeNightMode = 0; /* 0:day 1:night */
|
|
//#define printf(fmt, args...) printk(fmt , ## args)
|
|
static UINT32 simCardInsert=1;
|
|
static UINT8 gModuleSleep = 1;
|
|
static UINT32 SmsCheck = 0;
|
|
//static SF_CAMERA_CMD_S CameraCmd = {0};
|
|
static UINT8 McuProductInfo = 0;
|
|
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_68CS_)
|
|
static UINT8 drNoResetTimeSync = FALSE; //0:reset; 1:no reset;
|
|
|
|
#elif defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
static UINT8 isSignalReady = 0;
|
|
static UINT32 GPRS_ERRNO = 0;
|
|
|
|
#endif
|
|
|
|
SF_SRCFILE_ATTR_S *pThumbFileCfg = NULL;
|
|
|
|
#if DIGITAL_PIR
|
|
const UINT8 PirDigtSensRegValue[3] = { 7, 9, 16 }; /*digital Level PIR: 7/9/16 -> reg:9/7/5*/
|
|
#else /*analog PIR*/
|
|
const UINT8 PirDigtSensLevel[3] = { 0, 1, 2 }; /*analog PIR: High/Middle/Low/OFF*/
|
|
#endif
|
|
const UINT8 digPirLevel[3] = {9, 7, 5};
|
|
const UINT8 digPirCount[3] = {1, 1, 0};
|
|
|
|
#if HUNTING_MCU_I2C == ENABLE
|
|
|
|
static SF_I2C sf_i2c = {
|
|
SF_I2C_ID_3, MCU_I2C_SLAVE_ADDR
|
|
};
|
|
|
|
static INT32 sf_i2c_write(UINT32 addr, UINT32 data)
|
|
{
|
|
struct i2c_msg msgs;
|
|
UINT8 buf[2];
|
|
INT32 ret;
|
|
|
|
buf[0] = addr & 0xFF;
|
|
buf[1] = data & 0xFF;
|
|
msgs.addr = sf_i2c.addr;
|
|
msgs.flags = 0;//w
|
|
msgs.len = 2;
|
|
msgs.buf = buf;
|
|
|
|
ret = sf_i2c_transfer(&msgs, 1);
|
|
return ret;
|
|
}
|
|
|
|
static INT32 sf_i2c_read(UINT32 addr, UINT8 *data)
|
|
{
|
|
struct i2c_msg msgs[2];
|
|
UINT8 buf[1], buf2[1];
|
|
INT32 ret;
|
|
|
|
buf[0] = addr & 0xFF;
|
|
msgs[0].addr = sf_i2c.addr;
|
|
msgs[0].flags = 0;//w
|
|
msgs[0].len = 1;
|
|
msgs[0].buf = buf;
|
|
|
|
buf2[0] = 0;
|
|
msgs[1].addr = sf_i2c.addr;
|
|
msgs[1].flags = 1;//r
|
|
msgs[1].len = 1;
|
|
msgs[1].buf = buf2;
|
|
|
|
ret = sf_i2c_transfer(msgs, 2);
|
|
if (ret == 0) { //OK
|
|
*data = buf2[0];
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT8 sf_mcu_read(UINT32 reg, UINT8 *data)
|
|
{
|
|
UINT8 data2 = 0;
|
|
|
|
sf_i2c_read(reg, data);
|
|
//vos_util_delay_us(30);
|
|
|
|
sf_i2c_read(reg, &data2);
|
|
printf("R_addr[%lu]=0x%02x\n", reg, data2);
|
|
|
|
if(*data != data2)
|
|
{
|
|
printf("%s:%d ERROR\n", __FUNCTION__, __LINE__);
|
|
printf("[ERROR]-[sf_i2c_read]reg:%lu,data:%d,data2:%d\n", reg, *data, data2);
|
|
vos_util_delay_us(300);
|
|
sf_i2c_read(reg, data);
|
|
printf("[ERROR]-[sf_i2c_read]reg:%lu,data3:%d,data2:%d\n", reg, *data, data2);
|
|
}
|
|
|
|
//vos_util_delay_us(200);
|
|
|
|
return 0;
|
|
}
|
|
|
|
UINT8 sf_mcu_write(UINT32 reg, UINT32 data)
|
|
{
|
|
UINT8 data2 = 0;
|
|
|
|
sf_i2c_write(reg, data);
|
|
//vos_util_delay_us(20);
|
|
|
|
sf_i2c_read(reg, &data2);
|
|
printf("W_addr[%lu]=0x%02x\n", reg, data2);
|
|
|
|
if(data != data2)
|
|
{
|
|
printf("%s:%d ERROR reg:%lu,data:%lu,data2:%d\n", __FUNCTION__, __LINE__, reg, data, data2);
|
|
vos_util_delay_us(300);
|
|
sf_i2c_write(reg, data);
|
|
}
|
|
|
|
//vos_util_delay_us(200);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int sf_init_mcu(void)
|
|
{
|
|
CHKPNT;
|
|
INT32 ret = 0;
|
|
ret = sf_i2c_init_driver(sf_i2c.id);
|
|
return ret;
|
|
}
|
|
|
|
UINT8 sf_mcu_write_multi(UINT8 reg[], UINT8 data[], UINT32 num)
|
|
{
|
|
UINT32 i;
|
|
|
|
for(i = 0; i < num; i++)
|
|
{
|
|
sf_mcu_write(reg[i], data[i]);
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_power_on_para_get
|
|
Description: read MCU register data to update uipara and variable.
|
|
Input: attrId:which kind of para want to get
|
|
Output: N/A
|
|
Return: start mode
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_mcu_power_on_para_get(MCUParam_t attrId)
|
|
{
|
|
UINT8 dataTemp1 = 0, dataTemp2 = 0;
|
|
UINT8 startMode = 0;
|
|
UINT8 mcuVer = 0;
|
|
|
|
if(attrId != SF_MCU_POWERON)
|
|
{
|
|
sf_mcu_read(START_MODE, &dataTemp1);
|
|
startMode = dataTemp1 & 0x1F;
|
|
|
|
return startMode;
|
|
}
|
|
|
|
sf_mcu_read(MCU_SUB_VER, &McuSubVersion);
|
|
#if 0//defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
sf_mcu_read(MCU_VER, &mcuVer);
|
|
McuVersion = mcuVer;
|
|
#else
|
|
sf_mcu_read(MCU_VER_L, &mcuVer);
|
|
McuVersion = mcuVer;
|
|
sf_mcu_read(MCU_VER_H, &mcuVer);
|
|
McuVersion = (UINT16)mcuVer << 8 | McuVersion;
|
|
sf_mcu_read(MCU_PRODUCT_INFO, &McuProductInfo);
|
|
#endif
|
|
|
|
sf_mcu_read(START_MODE, &dataTemp1);
|
|
startMode = dataTemp1 & 0x1F;
|
|
DailyReportStartMode = (dataTemp1 & 0xc0) >> 6;
|
|
|
|
#if 0
|
|
sf_mcu_i2c_read(CAMERA_MODE, &CameraMode);
|
|
sf_mcu_i2c_read(IRLED_LUMINANCE, &IrLedPercent);
|
|
#endif
|
|
|
|
sf_mcu_read(LUMINANCE_L, &dataTemp1);
|
|
sf_mcu_read(LUMINANCE_H, &dataTemp2);
|
|
IRSHTTER = (dataTemp2 << 8) | dataTemp1;
|
|
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
if(startMode == PWR_ON_TIME_SYNC)
|
|
{
|
|
startMode = PWR_ON_DAILY_REPORT;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if(startMode > PWR_ON_TIME_SEND) //if start mode err, USB IN default power on SETUP
|
|
{
|
|
startMode = PWR_ON_SETUP;
|
|
}
|
|
}
|
|
|
|
printf(" start mode = %d IRSHTTER = %d\n", startMode, IRSHTTER);
|
|
|
|
return startMode;
|
|
}
|
|
|
|
#else
|
|
|
|
UINT8 sf_mcu_read(UINT32 reg, UINT8 *data)
|
|
{
|
|
//UINT8 data2 = 0;
|
|
|
|
*data = sf_commu_get_mcu(reg);
|
|
//vos_util_delay_us(30);
|
|
|
|
//data2 = sf_commu_get_mcu(reg);
|
|
printf("R_addr[%lu]=0x%02x\n", reg, *data);
|
|
|
|
/*if(*data != data2)
|
|
{
|
|
printf("%s:%d ERROR\n", __FUNCTION__, __LINE__);
|
|
printf("[ERROR]-[sf_i2c_read]reg:%lu,data:%d,data2:%d\n", reg, *data, data2);
|
|
vos_util_delay_us(300);
|
|
*data = sf_commu_get_mcu(reg);
|
|
printf("[ERROR]-[sf_i2c_read]reg:%lu,data3:%d,data2:%d\n", reg, *data, data2);
|
|
}*/
|
|
|
|
//vos_util_delay_us(200);
|
|
|
|
return 0;
|
|
}
|
|
|
|
UINT8 sf_mcu_write(UINT32 reg, UINT32 data)
|
|
{
|
|
//UINT8 data2 = 0;
|
|
|
|
sf_commu_set_mcu(reg, data);
|
|
//vos_util_delay_us(20);
|
|
printf("W_addr[%lu]=0x%lu\n", reg, data);
|
|
|
|
/*data2 = sf_commu_get_mcu(reg);
|
|
printf("W_addr[%lu]=0x%02x\n", reg, data2);
|
|
|
|
if(data != data2)
|
|
{
|
|
printf("%s:%d ERROR reg:%lu,data:%lu,data2:%d\n", __FUNCTION__, __LINE__, reg, data, data2);
|
|
vos_util_delay_us(300);
|
|
sf_commu_set_mcu(reg, data);
|
|
}*/
|
|
|
|
//vos_util_delay_us(200);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int sf_init_mcu(void)
|
|
{
|
|
CHKPNT;
|
|
ER ret = 0;
|
|
UART_INIT_PARA UartParaBasic;
|
|
UartParaBasic.BaudRate = UART_BAUDRATE_115200;
|
|
UartParaBasic.BaudRate = 115200;
|
|
UartParaBasic.Length = UART_LEN_L8_S1;
|
|
UartParaBasic.Parity = UART_PARITY_NONE;
|
|
UartParaBasic.FlowCtrlMode = UART_FC_MODE_NONE;
|
|
UartParaBasic.DataTransMode = UART_DATA_TRANS_PIO;
|
|
//uart3_setConfig(UART_CONFIG_ID_RX_TRIGGER_LEVEL,0x0);
|
|
ret = uart3_open();
|
|
uart3_initHW(&UartParaBasic);
|
|
uart3_setConfig(UART_CONFIG_ID_RX_TRIGGER_LEVEL,0x0);
|
|
|
|
/*UART_DATA_PARA DataPara;
|
|
DataPara.Action = UART_ACT_GET;
|
|
DataPara.BufferInfo.uiSize = 64;
|
|
DataPara.BufferInfo.pBuffer = getbuffer;
|
|
ret = uart3_operateData(&DataPara);*/
|
|
|
|
return ret;
|
|
}
|
|
|
|
UINT8 sf_mcu_write_multi(UINT8 reg[], UINT8 data[], UINT32 num)
|
|
{
|
|
UINT32 i;
|
|
unsigned int pnum = num;
|
|
if(0 <= sf_commu_set_mcu_many(reg, data, &pnum))
|
|
{
|
|
for(i = 0; i < num; i++)
|
|
{
|
|
printf("W_addr[%d]=0x%02x\n", reg[i], data[i]);
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
return FAIL;
|
|
}
|
|
|
|
UINT8 sf_mcu_read_multi(UINT8 reg[], UINT8 data[], UINT32 num)
|
|
{
|
|
UINT32 i;
|
|
unsigned int pnum = num;
|
|
if(0 <= sf_commu_get_mcu_many(reg, data, &pnum))
|
|
{
|
|
for(i = 0; i < num; i++)
|
|
{
|
|
printf("R_addr[%d]=0x%02x\n", reg[i], data[i]);
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
return FAIL;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_power_on_para_get
|
|
Description: read MCU register data to update uipara and variable.
|
|
Input: attrId:which kind of para want to get
|
|
Output: N/A
|
|
Return: start mode
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_mcu_power_on_para_get(MCUParam_t attrId)
|
|
{
|
|
UINT8 dataTemp1 = 0;//, dataTemp2 = 0
|
|
UINT8 startMode = 0;
|
|
//UINT8 mcuVer = 0;
|
|
UINT8 mcuReg[REG_SIZE] = { 0 };
|
|
UINT8 mcuData[REG_SIZE] = { 0 };
|
|
UINT8 i = 0;
|
|
|
|
if(attrId != SF_MCU_POWERON)
|
|
{
|
|
mcuReg[i++] = START_MODE;
|
|
sf_mcu_read_multi(mcuReg, mcuData, i);
|
|
i = 0;
|
|
dataTemp1 = mcuData[i++];
|
|
startMode = dataTemp1 & 0xF;
|
|
DailyReportStartMode = (dataTemp1 & 0xc0) >> 6;
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
if(startMode == PWR_ON_TIME_SYNC)
|
|
{
|
|
startMode = PWR_ON_DAILY_REPORT;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if(startMode > PWR_ON_TIME_SEND) //if start mode err, USB IN default power on SETUP
|
|
{
|
|
startMode = PWR_ON_SETUP;
|
|
}
|
|
}
|
|
printf(" start mode = %d \n", startMode);
|
|
return startMode;
|
|
}
|
|
mcuReg[i++] = MCU_SUB_VER;
|
|
mcuReg[i++] = MCU_VER_L;
|
|
mcuReg[i++] = MCU_VER_H;
|
|
mcuReg[i++] = MCU_PRODUCT_INFO;
|
|
//mcuReg[i++] = START_MODE;
|
|
//mcuReg[i++] = LUMINANCE_L;
|
|
//mcuReg[i++] = LUMINANCE_H;
|
|
|
|
sf_mcu_read_multi(mcuReg, mcuData, i);
|
|
i = 0;
|
|
McuSubVersion = mcuData[i++];
|
|
|
|
McuVersion = mcuData[i++];
|
|
McuVersion = (UINT16)mcuData[i++] << 8 | McuVersion;
|
|
McuProductInfo = mcuData[i++];
|
|
//dataTemp1 = mcuData[i++];
|
|
//startMode = dataTemp1 & 0x1F;
|
|
//DailyReportStartMode = (dataTemp1 & 0xc0) >> 6;
|
|
//dataTemp1= mcuData[i++];
|
|
//dataTemp2 = mcuData[i++];
|
|
//IRSHTTER = (dataTemp2 << 8) | dataTemp1;
|
|
|
|
#if 0
|
|
sf_mcu_read(MCU_SUB_VER, &McuSubVersion);
|
|
#if 0//defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
sf_mcu_read(MCU_VER, &mcuVer);
|
|
McuVersion = mcuVer;
|
|
#else
|
|
sf_mcu_read(MCU_VER_L, &mcuVer);
|
|
McuVersion = mcuVer;
|
|
sf_mcu_read(MCU_VER_H, &mcuVer);
|
|
McuVersion = (UINT16)mcuVer << 8 | McuVersion;
|
|
sf_mcu_read(MCU_PRODUCT_INFO, &McuProductInfo);
|
|
#endif
|
|
|
|
sf_mcu_read(START_MODE, &dataTemp1);
|
|
startMode = dataTemp1 & 0x1F;
|
|
DailyReportStartMode = (dataTemp1 & 0xc0) >> 6;
|
|
|
|
#if 0
|
|
sf_mcu_i2c_read(CAMERA_MODE, &CameraMode);
|
|
sf_mcu_i2c_read(IRLED_LUMINANCE, &IrLedPercent);
|
|
#endif
|
|
|
|
sf_mcu_read(LUMINANCE_L, &dataTemp1);
|
|
sf_mcu_read(LUMINANCE_H, &dataTemp2);
|
|
IRSHTTER = (dataTemp2 << 8) | dataTemp1;
|
|
#endif
|
|
/*
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
if(startMode == PWR_ON_TIME_SYNC)
|
|
{
|
|
startMode = PWR_ON_DAILY_REPORT;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if(startMode > PWR_ON_TIME_SEND) //if start mode err, USB IN default power on SETUP
|
|
{
|
|
startMode = PWR_ON_SETUP;
|
|
}
|
|
}
|
|
printf(" start mode = %d \n", startMode);
|
|
*/
|
|
//printf(" start mode = %d IRSHTTER = %d\n", startMode, IRSHTTER);
|
|
sf_get_mcu_rtc_set_sys();
|
|
|
|
return startMode;
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
Function: sf_get_mcu_rtc_set_sys
|
|
Description: get mcu rtc,set to sys
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_get_mcu_rtc_set_sys(void)
|
|
{
|
|
UINT8 mcuReg[REG_SIZE] = { 0 };
|
|
UINT8 mcuData[REG_SIZE] = { 0 };
|
|
UINT8 i = 0;
|
|
UINT16 year;
|
|
UINT16 mon;
|
|
UINT16 day;
|
|
UINT16 hour;
|
|
UINT16 min;
|
|
UINT16 sec;
|
|
struct tm Curr_DateTime = {0};
|
|
|
|
mcuReg[i++] = SF_RTC_YEAR;
|
|
mcuReg[i++] = SF_RTC_MONTH;
|
|
mcuReg[i++] = SF_RTC_DAY;
|
|
mcuReg[i++] = SF_RTC_HOUR;
|
|
mcuReg[i++] = SF_RTC_MINUTE;
|
|
mcuReg[i++] = SF_RTC_SEC;
|
|
|
|
sf_mcu_read_multi(mcuReg, mcuData, i);
|
|
i = 0;
|
|
year = mcuData[i++] + 2000;
|
|
mon = mcuData[i++];
|
|
day = mcuData[i++];
|
|
hour = mcuData[i++];
|
|
min = mcuData[i++];
|
|
sec = mcuData[i++];
|
|
|
|
if(sec == 0)
|
|
{
|
|
i = 0;
|
|
mcuReg[i++] = SF_RTC_YEAR;
|
|
mcuReg[i++] = SF_RTC_MONTH;
|
|
mcuReg[i++] = SF_RTC_DAY;
|
|
mcuReg[i++] = SF_RTC_HOUR;
|
|
mcuReg[i++] = SF_RTC_MINUTE;
|
|
mcuReg[i++] = SF_RTC_SEC;
|
|
|
|
sf_mcu_read_multi(mcuReg, mcuData, i);
|
|
i = 0;
|
|
year = mcuData[i++] + 2000;
|
|
mon = mcuData[i++];
|
|
day = mcuData[i++];
|
|
hour = mcuData[i++];
|
|
min = mcuData[i++];
|
|
sec = mcuData[i++];
|
|
}
|
|
|
|
printf("%s:%d %d : %d : %d : %d : %d : %d\n", __FUNCTION__, __LINE__,year, mon,day,hour,min,sec);
|
|
|
|
if((year >= SF_DATE_TIME_YEAR_MIN) && (year <= SF_DATE_TIME_YEAR_MAX) && (mon <= 12) && (day <= 31) && (hour < 24) && (min < 60) && (sec < 60))
|
|
{
|
|
Curr_DateTime.tm_year = year;
|
|
Curr_DateTime.tm_mon = mon;
|
|
Curr_DateTime.tm_mday = day;
|
|
Curr_DateTime.tm_hour = hour;
|
|
Curr_DateTime.tm_min = min;
|
|
Curr_DateTime.tm_sec = sec;
|
|
|
|
hwclock_set_time(TIME_ID_CURRENT, *(struct tm*)&Curr_DateTime, 0);
|
|
return SUCCESS;
|
|
}
|
|
|
|
return FAIL;
|
|
}
|
|
|
|
#endif
|
|
|
|
int sf_off_mcu(void)
|
|
{
|
|
|
|
#if HUNTING_MCU_I2C != ENABLE
|
|
uart3_close();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
Function: sf_get_daily_report_start_mode
|
|
Description: get dailyreport start mode
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: 0:ON mode 1:OFF mode
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_get_daily_report_start_mode(void)
|
|
{
|
|
return DailyReportStartMode;
|
|
}
|
|
|
|
|
|
UINT8 sf_mcu_wdg_set(UINT8 value)
|
|
{
|
|
UINT8 i = 0;
|
|
UINT8 mcuReg[2] = {0};
|
|
UINT8 mcuPara[2] = {0};
|
|
printf("%s:%d s\n",__FUNCTION__,__LINE__);
|
|
|
|
mcuReg[i] = WDT_TIME;
|
|
mcuPara[i++] = value;
|
|
|
|
mcuReg[i] = DSP_WRITE_FLG;
|
|
mcuPara[i++] = 1;
|
|
sf_mcu_write_multi(mcuReg, mcuPara, i);
|
|
printf("%s:%d e\n",__FUNCTION__,__LINE__);
|
|
|
|
return SUCCESS;
|
|
}
|
|
void sf_set_sim_insert(UINT32 sim)
|
|
{
|
|
simCardInsert = sim;
|
|
}
|
|
|
|
UINT32 sf_get_sim_insert(void)
|
|
{
|
|
return simCardInsert;
|
|
}
|
|
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_68CS_)
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_version_get
|
|
Description: get mcu ver
|
|
Input: N/A
|
|
Output: ver str
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_mcu_version_get(UINT8 *mcuVer)
|
|
{
|
|
UINT8 str[10] = { 0 };
|
|
|
|
if(McuProductInfo == 1)
|
|
{
|
|
sprintf((char *)str, "SYAM");
|
|
}
|
|
else if(McuProductInfo == 2)
|
|
{
|
|
sprintf((char *)str, "SYM");
|
|
}
|
|
else
|
|
{
|
|
sprintf((char *)str, "SYPM");
|
|
}
|
|
|
|
sprintf((char *)mcuVer, "%s%d.%d.%d", str, (McuVersion >> 8) & 0xFF, McuVersion & 0xFF, McuSubVersion);
|
|
}
|
|
#endif
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_module_off
|
|
Description: power off module
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_mcu_module_off(void)
|
|
{
|
|
UINT8 i = 0;
|
|
UINT8 mcuReg[2] = { 0 };
|
|
UINT8 mcuPara[2] = { 0 };
|
|
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
mcuPara[i++] = 0x00;
|
|
|
|
mcuReg[i] = DSP_WRITE_FLG;
|
|
mcuPara[i++] = 1;
|
|
|
|
sf_mcu_write_multi(mcuReg, mcuPara, i);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
UINT8 sf_convert_power_on_mode(void)
|
|
{
|
|
PowerOnMode &= 0x0f;
|
|
//printf("[%s:%d]PowerOnMode=0x%x\n",__FUNCTION__,__LINE__,PowerOnMode);
|
|
return PowerOnMode;
|
|
}
|
|
|
|
UINT8 sf_get_power_off_flag(void)
|
|
{
|
|
//printf("[%s:%d]POWEROFF=0x%x\n", __FUNCTION__, __LINE__, POWEROFF);
|
|
return POWEROFF;
|
|
}
|
|
void sf_set_power_off_flag(UINT8 flag)
|
|
{
|
|
POWEROFF = flag;
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
Function: sf_get_power_on_mode
|
|
Description: get power start mode
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: 0:ON mode 1:OFF mode
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_get_power_on_mode(void)
|
|
{
|
|
static int ModeFlag = 1;
|
|
if(ModeFlag)
|
|
{
|
|
ModeFlag = 0;
|
|
//PowerOnMode = sf_mcu_power_on_para_get(SF_MCU_POWERON);
|
|
PowerOnMode = sf_mcu_power_on_para_get(SF_MCU_STARTMODE);
|
|
PowerOnMode &= 0x0f;
|
|
//sf_is_night_mode(1);
|
|
if(1 == PowerOnMode)
|
|
{
|
|
ConfigureModeFlag = 1;
|
|
}
|
|
}
|
|
return PowerOnMode;
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
Function: sf_is_night_mode
|
|
Description: whether or not night mode
|
|
Input: isRefresh: 1:refresh 0:unrefresh
|
|
Output: N/A
|
|
Return: TRUE:night mode; FALSE:day mode
|
|
Others: N/A
|
|
*************************************************/
|
|
BOOL sf_is_night_mode(BOOL isRefresh)
|
|
{
|
|
static BOOL nightMode = FALSE;
|
|
|
|
if(sf_get_mode_flag()) //setup always use new status
|
|
{
|
|
return AeNightMode;
|
|
}
|
|
else if(isRefresh)
|
|
{
|
|
sf_mcu_get_irshtter();
|
|
if(IRSHTTER < SF_MCU_NIGHT_MODE_LUMINANCE)
|
|
{
|
|
nightMode = TRUE;
|
|
}
|
|
else
|
|
{
|
|
nightMode = FALSE;
|
|
}
|
|
}
|
|
//printf("[%s:%d]nightMode=%d\n",__FUNCTION__,__LINE__,nightMode);
|
|
return nightMode;
|
|
}
|
|
|
|
UINT32 sf_get_send_pic_sieze(void)
|
|
{
|
|
UINT32 SendPicSize = 0;
|
|
if(sf_is_night_mode(0) != TRUE)
|
|
{
|
|
SendPicSize = 1;
|
|
}
|
|
return SendPicSize;
|
|
}
|
|
|
|
UINT32 sf_gpio_get_status(UINT32 ipin)
|
|
{
|
|
//printf("%s(%d) ipin:%d\n", __FUNCTION__, __LINE__,ipin);
|
|
gpio_direction_input(ipin);
|
|
return (UINT32) ((gpio_get_value(ipin) == 1) ? 1 : 0 );
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_dataready_get
|
|
Description:
|
|
Input: attrId:which kind of para want to get
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_mcu_dataready_get(void)
|
|
{
|
|
#if 0
|
|
UINT8 startMode = 0;
|
|
|
|
startMode = sf_mcu_power_on_para_get(SF_MCU_STARTMODE);
|
|
printf("startMode=%d\n", startMode);
|
|
|
|
if(GxUSB_GetIsUSBPlug())//sf_gpio_get_status(GPIO_INT_USBPLUGIN))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(sf_get_mode_flag())
|
|
{
|
|
if(startMode == 0) //OFF
|
|
{
|
|
sf_set_power_off_flag(1);
|
|
gModuleSleep = 0;
|
|
//LCD_BACKLIGHT_OFF;
|
|
//profLogPrintf(0,"[sf_mcu_dataready_get],APP_POWER_OFF_NORMAL");
|
|
printf("[power off] %s(%d)\n", __FUNCTION__, __LINE__);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, 0); //shutdown start
|
|
}
|
|
else if(startMode == 1) //SETUP
|
|
{
|
|
/*exit pir mode*/
|
|
}
|
|
else if(startMode == 3) //ON
|
|
{
|
|
sf_set_auto_off_time(0);
|
|
sf_set_pir_statu_flag(1);
|
|
printf("%s:%d-------PIR Key Pressed.------\n", __FUNCTION__, __LINE__);
|
|
//Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, 0); //shutdown start
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((startMode == 0) || (startMode == 1)) //PIR MODE: ON->OFF/ ON->SETUP
|
|
{
|
|
gModuleSleep = 0; //power off 4G module
|
|
sf_set_power_off_flag(1);
|
|
printf("[power off] %s(%d)\n", __FUNCTION__, __LINE__);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, 0); //shutdown start
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_68CS_)
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_reg_set
|
|
Description: set data to MCU
|
|
Input: attrId:which kind of para want to get
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_mcu_reg_set(MCUParam_t attrId, UINT8 val)
|
|
{
|
|
UINT8 mcuReg[REG_SIZE] = { 0 };
|
|
UINT8 mcuData[REG_SIZE] = { 0 };
|
|
UINT8 i = 0;
|
|
//UINT8 j = 0;
|
|
UINT8 temp = 0;
|
|
UINT8 paraSyncFlag = 0;
|
|
UINT8 gpsAlwaysFlag = 0;
|
|
UINT8 PowerOnMode = 0;
|
|
UINT8 DailyHour = 0;
|
|
UINT8 DailyMin = 0;
|
|
printf("Firmware compile time:%s %s VER:%s\n", __DATE__, __TIME__,SF_BASE_VERSION);
|
|
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
PowerOnMode = sf_get_power_on_mode();
|
|
|
|
gpsAlwaysFlag = gpsAlwaysFlag;
|
|
|
|
if(attrId > SF_MCU_PARAM_MAX)
|
|
{
|
|
printf("%s:%d attrId ERROR!\n", __FUNCTION__, __LINE__);
|
|
return FAIL;
|
|
}
|
|
|
|
printf("%s:%d attrId=%d val=%d\n", __FUNCTION__, __LINE__, attrId, val);
|
|
|
|
//4G
|
|
if((simCardInsert) && (1 == SysGetFlag(NeedTimeSyncStartUp)))
|
|
{
|
|
paraSyncFlag = 1;
|
|
}
|
|
|
|
if(attrId == SF_MCU_POWEROFF)
|
|
{
|
|
|
|
struct tm ctv = {0};
|
|
ctv = hwclock_get_time(TIME_ID_CURRENT);
|
|
/*if(ctv.tm_year < DEFAULT_YEAR) {
|
|
ctv.tm_year = DEFAULT_YEAR;
|
|
ctv.tm_mon = DEFAULT_MON;
|
|
ctv.tm_mday = DEFAULT_DAY;
|
|
ctv.tm_hour = DEFAULT_HOUR;
|
|
ctv.tm_min = DEFAULT_MIN;
|
|
ctv.tm_sec = DEFAULT_SEC;
|
|
hwclock_set_time(TIME_ID_CURRENT, ctv, 0);
|
|
}*/
|
|
mcuReg[i] = SF_RTC_YEAR;
|
|
mcuData[i++] = ctv.tm_year - 2000;
|
|
mcuReg[i] = SF_RTC_MONTH;
|
|
mcuData[i++] = ctv.tm_mon;
|
|
mcuReg[i] = SF_RTC_DAY;
|
|
mcuData[i++] = ctv.tm_mday;
|
|
mcuReg[i] = SF_RTC_HOUR;
|
|
mcuData[i++] = ctv.tm_hour;
|
|
mcuReg[i] = SF_RTC_MINUTE;
|
|
mcuData[i++] = ctv.tm_min;
|
|
mcuReg[i] = SF_RTC_SEC;
|
|
mcuData[i++] = ctv.tm_sec;
|
|
|
|
gpsAlwaysFlag = 0;
|
|
|
|
if(1 == SysGetFlag(PirSwitch))
|
|
{
|
|
temp = 0x01;
|
|
}
|
|
else
|
|
{
|
|
temp = 0x00;
|
|
}
|
|
|
|
if(1 == SysGetFlag(TimelapseSwitch))
|
|
{
|
|
temp |= 0x02;
|
|
}
|
|
|
|
if(1 == SysGetFlag(PirDelaySwitch))
|
|
{
|
|
temp |= 0x04;
|
|
}
|
|
|
|
printf("[%s:%d]paraSyncFlag=%d\n", __FUNCTION__, __LINE__, paraSyncFlag);
|
|
|
|
if(paraSyncFlag)
|
|
{
|
|
temp |= 0x08;
|
|
}
|
|
|
|
|
|
if(((simCardInsert) && (1 == SysGetFlag(GprsMode))) || (1 == SysGetFlag(DailyReportSwitch))) //dailyreport open
|
|
{
|
|
temp |= 0x10;
|
|
}
|
|
else
|
|
{
|
|
temp &= ~0x10;
|
|
}
|
|
|
|
mcuReg[i] = FUNCTION_SWTICH0;
|
|
mcuData[i++] = temp;
|
|
|
|
temp = 0;
|
|
|
|
if((1 == SysGetFlag(GpsSwitch)) && (sf_get_mode_flag() || paraSyncFlag))
|
|
{
|
|
mcuReg[i] = GPS_POWER_TIMER_CLEAR;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 1;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
printf("PirSensitivity:%lu\n", SysGetFlag(PirSensitivity));
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
temp = SysGetFlag(PirSensitivity);
|
|
printf("[%s:%d] GprsMode=%lu,gModuleSleep=%d,NetWorkNeedSearch=%lu\n", __FUNCTION__, __LINE__, SysGetFlag(GprsMode), gModuleSleep, SysGetFlag(NetWorkNeedSearch));
|
|
|
|
if(simCardInsert && (SysGetFlag(NetWorkNeedSearch)))
|
|
{
|
|
//4.0PCG, first to PIR mode, will power on in A,search net. so 4G mode should power down
|
|
//instant mode ,dp power on, 4G mode should power down
|
|
temp &= ~0x60; /*bit5&bit6=0,daily mode*/
|
|
}
|
|
else if(simCardInsert && (1 == SysGetFlag(GprsMode)) && gModuleSleep)
|
|
{
|
|
temp |= 0x40; /*bit6=1,instant mode*/
|
|
}
|
|
else if(simCardInsert && (0 == SysGetFlag(GprsMode)) && gModuleSleep)
|
|
{
|
|
temp |= 0x20; /*bit5=1,hybrid mode*/
|
|
}
|
|
|
|
printf("[%s:%d]drNoResetTimeSync=%d\n", __FUNCTION__, __LINE__, drNoResetTimeSync);
|
|
if((PowerOnMode == PWR_ON_AUTO) || (PowerOnMode == PWR_ON_SETUP) || (PowerOnMode == PWR_ON_GPRS_INIT) || ((PowerOnMode == PWR_ON_DAILY_REPORT) && (drNoResetTimeSync != TRUE)))
|
|
{
|
|
temp |= 0x10; /*bit4 rest*/
|
|
}
|
|
|
|
if(SysGetFlag(GprsSwitch) && (simCardInsert))
|
|
{
|
|
temp |= 0x80;
|
|
}
|
|
|
|
mcuData[i++] = temp;
|
|
|
|
#if DIGITAL_PIR
|
|
mcuReg[i] = DIGITAL_PIR_SENSITIVITY;
|
|
mcuData[i++] = PirDigtSensRegValue[SysGetFlag(PirSensitivity)];
|
|
mcuReg[i] = DIGITAL_PIR_CFG;
|
|
mcuData[i++] = (0 << 4)| (PirDigtSensRegValue[SysGetFlag(PirSensitivity)] <= 10 ? 1 : 0);
|
|
#endif
|
|
|
|
//DSP busy/idle
|
|
mcuReg[i] = DSP_BUSY_STATUS;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0;
|
|
|
|
temp = 0;
|
|
|
|
if(simCardInsert && (SysGetFlag(NetWorkNeedSearch))
|
|
&& ((PowerOnMode == PWR_ON_AUTO) || (PowerOnMode == PWR_ON_SETUP) || (PowerOnMode == PWR_ON_DAILY_REPORT)))/* SET->ON, OFF->ON*/
|
|
{
|
|
temp = 1;
|
|
}
|
|
/*else if(simCardInsert && (TRUE == sf_get_net_reboot()))//reboot net
|
|
{
|
|
temp = 1;
|
|
}*/
|
|
else if(SmsCheck)
|
|
{
|
|
temp = 2;
|
|
}
|
|
|
|
mcuReg[i] = POWEROFF_TYPE;
|
|
mcuData[i++] = (0) << 7 | (val == APP_POWER_OFF_BATT_EMPTY) << 6 | (val == APP_POWER_OFF_APO) << 6 | temp;
|
|
|
|
//battery recovery
|
|
mcuReg[i] = VBAT_RECOVER_VAL;
|
|
|
|
if(SF_BATT_LI == SysGetFlag(BatteryType))
|
|
{
|
|
mcuData[i++] = SF_LI_BATT_RECOVERY;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = SF_OTHER_BATT_RECOVERY;
|
|
}
|
|
|
|
if(SysGetFlag(TimelapseSwitch))
|
|
{
|
|
mcuReg[i] = TIMELAPSE_HOUR;
|
|
mcuData[i++] = puiPara->TimelapseTime.Hour;
|
|
mcuReg[i] = TIMELAPSE_MINUTE;
|
|
mcuData[i++] = puiPara->TimelapseTime.Min;
|
|
mcuReg[i] = TIMELAPSE_SEC;
|
|
|
|
if((SysGetFlag(TimelapseSwitch)) && (puiPara->TimelapseTime.Hour == 0) && (puiPara->TimelapseTime.Min == 0) && (puiPara->TimelapseTime.Sec == 0))
|
|
{
|
|
mcuData[i++] = 5;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = puiPara->TimelapseTime.Sec;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = TIMELAPSE_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = TIMELAPSE_MINUTE;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = TIMELAPSE_SEC;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(SysGetFlag(PirDelaySwitch))
|
|
{
|
|
mcuReg[i] = PIR_DELAY_HOUR;
|
|
mcuData[i++] = puiPara->PirDelayTime.Hour;
|
|
mcuReg[i] = PIR_DELAY_MINUTE;
|
|
mcuData[i++] = puiPara->PirDelayTime.Min;
|
|
mcuReg[i] = PIR_DELAY_SEC;
|
|
mcuData[i++] = puiPara->PirDelayTime.Sec;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = PIR_DELAY_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = PIR_DELAY_MINUTE;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = PIR_DELAY_SEC;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(paraSyncFlag)
|
|
{
|
|
mcuReg[i] = TIME_SYNC_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = TIME_SYNC_MINUTE;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = TIME_SYNC_SEC;
|
|
mcuData[i++] = 30;
|
|
}
|
|
|
|
printf("end dailyHour:%d,dailyMin:%d\n", puiPara->DailyReportTime.Hour, puiPara->DailyReportTime.Min);
|
|
|
|
//set dr time.
|
|
sf_calculate_daily_report(&DailyHour, &DailyMin);
|
|
printf("end dailyHour:%d,dailyMin:%d\n",DailyHour,DailyMin);
|
|
//rtcTime
|
|
mcuReg[i] = DAILY_REPORT_HOUR;
|
|
if(SF_REMOTE_CONTROL_DEALY_24H == SysGetFlag(GprsMode))
|
|
{
|
|
if((ctv.tm_min + DailyMin) == 0)
|
|
{
|
|
if((ctv.tm_hour + DailyHour) == 0)
|
|
{
|
|
mcuData[i++] = (ctv.tm_hour + DailyHour + 24 - 1)%24;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = (ctv.tm_hour + DailyHour - 1)%24;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = (ctv.tm_hour + DailyHour)%24;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((ctv.tm_min + DailyMin) >= 60)
|
|
{
|
|
mcuData[i++] = (ctv.tm_hour + DailyHour+1)%24;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = (ctv.tm_hour + DailyHour)%24;
|
|
}
|
|
}
|
|
|
|
|
|
mcuReg[i] = DAILY_REPORT_MINUTE;
|
|
if(SF_REMOTE_CONTROL_DEALY_24H == SysGetFlag(GprsMode))
|
|
{
|
|
if((ctv.tm_min + DailyMin) == 0)
|
|
{
|
|
mcuData[i++] = (ctv.tm_min + DailyMin + 60 - 1)%60;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = (ctv.tm_min + DailyMin - 1)%60;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = (ctv.tm_min + DailyMin)%60;
|
|
}
|
|
|
|
|
|
|
|
if(SysGetFlag(WorkTime1Switch))
|
|
{
|
|
mcuReg[i] = WORKTIME1_SWITCH;
|
|
mcuData[i++] = 0xFF;
|
|
|
|
mcuReg[i] = WORKTIME1_START_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[0].StartTime.Hour;
|
|
mcuReg[i] = WORKTIME1_START_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[0].StartTime.Min;
|
|
|
|
mcuReg[i] = WORKTIME1_STOP_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[0].StopTime.Hour;
|
|
mcuReg[i] = WORKTIME1_STOP_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[0].StopTime.Min;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = WORKTIME1_SWITCH;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME1_START_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME1_START_MINUTE;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME1_STOP_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME1_STOP_MINUTE;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(SysGetFlag(WorkTime2Switch))
|
|
{
|
|
mcuReg[i] = WORKTIME2_SWITCH;
|
|
mcuData[i++] = 0xFF;
|
|
|
|
mcuReg[i] = WORKTIME2_START_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[1].StartTime.Hour;
|
|
mcuReg[i] = WORKTIME2_START_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[1].StartTime.Min;
|
|
|
|
mcuReg[i] = WORKTIME2_STOP_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[1].StopTime.Hour;
|
|
mcuReg[i] = WORKTIME2_STOP_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[1].StopTime.Min;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = WORKTIME2_SWITCH;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME2_START_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME2_START_MINUTE;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME2_STOP_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME2_STOP_MINUTE;
|
|
mcuData[i++] = 0;
|
|
}
|
|
}
|
|
else if(attrId == SF_MCU_CTRL_MODULE_PIR)
|
|
{
|
|
if((SysGetFlag(GpsSwitch))&& (ConfigureModeFlag || paraSyncFlag))
|
|
{
|
|
mcuReg[i] = GPS_POWER_TIMER_CLEAR;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 1;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
|
|
temp = SysGetFlag(PirSensitivity); //sf_mcu_analog_pir_sen_convert(puiPara->PirSensitivity);
|
|
|
|
if(SF_REMOTE_CONTROL_REAL_TIME == SysGetFlag(GprsMode)) //hybrid mode 4G module keep sleep
|
|
{
|
|
temp |= 0x40;
|
|
}
|
|
|
|
if((SysGetFlag(GprsSwitch)) && (val == 1))
|
|
{
|
|
temp |= 0x80;
|
|
}
|
|
|
|
mcuData[i++] = temp;
|
|
printf("[%s:%d] temp:0x%02x GprsSwitch:%lu simCardInsert:%lu\n", __FUNCTION__, __LINE__, temp, SysGetFlag(GprsSwitch), simCardInsert);
|
|
|
|
if(ConfigureModeFlag)
|
|
{
|
|
mcuReg[i] = DIGITAL_PIR_SENSITIVITY;
|
|
mcuData[i++] = digPirLevel[SysGetFlag(PirSensitivity)];//PirDigtSensRegValue[SysGetFlag(PirSensitivity)];
|
|
mcuReg[i] = DIGITAL_PIR_CFG;
|
|
mcuData[i++] = (/*SysGetFlag(DigitPirWindowTime)*/0 << 4) | (PirDigtSensRegValue[SysGetFlag(PirSensitivity)] <= 10 ? 1 : 0);
|
|
}
|
|
}
|
|
else if(attrId == SF_MCU_PARA)
|
|
{
|
|
if((SysGetFlag(GpsSwitch)) && (ConfigureModeFlag || paraSyncFlag))
|
|
{
|
|
mcuReg[i] = GPS_POWER_TIMER_CLEAR;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 1;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
|
|
temp = SysGetFlag(PirSensitivity); //sf_mcu_analog_pir_sen_convert(puiPara->PirSensitivity);
|
|
|
|
if((SF_REMOTE_CONTROL_REAL_TIME == SysGetFlag(GprsMode)) && (gModuleSleep == 1)) //hybrid mode 4G module keep sleep
|
|
{
|
|
temp |= 0x40;
|
|
}
|
|
|
|
if((SysGetFlag(GprsSwitch)) && (simCardInsert))
|
|
{
|
|
temp |= 0x80;
|
|
}
|
|
|
|
mcuData[i++] = temp;
|
|
|
|
printf("[%s:%d] temp:0x%02x GprsSwitch:%lu simCardInsert:%lu\n", __FUNCTION__, __LINE__, temp, SysGetFlag(GprsSwitch), simCardInsert);
|
|
mcuReg[i] = DIGITAL_PIR_SENSITIVITY;
|
|
mcuData[i++] = digPirLevel[SysGetFlag(PirSensitivity)];//PirDigtSensRegValue[SysGetFlag(PirSensitivity)];
|
|
mcuReg[i] = DIGITAL_PIR_CFG;
|
|
mcuData[i++] = (0 << 4) | (PirDigtSensRegValue[SysGetFlag(PirSensitivity)] <= 10 ? 1 : 0);
|
|
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = SysGetFlag(CamArmDiable) << 6 | sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0;
|
|
}
|
|
else if(attrId == SF_MCU_RESET_MODULE)
|
|
{
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = SysGetFlag(CamArmDiable) << 6 | sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0 | 0x10;
|
|
}
|
|
else if(attrId == SF_MCU_SOFT_UPDATE)
|
|
{
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
|
|
if(val == 1)
|
|
{
|
|
mcuData[i++] = SysGetFlag(CamArmDiable) << 6 | sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0 | 0x08;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = SysGetFlag(CamArmDiable) << 6 | sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0;
|
|
}
|
|
}
|
|
else if(attrId == SF_MCU_POWER_RESTART)
|
|
{
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = SysGetFlag(CamArmDiable) << 6 | sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0 | 0x20;
|
|
}
|
|
else if(attrId == SF_MCU_PIR_RESTART)
|
|
{
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = SysGetFlag(CamArmDiable) << 6 | sf_is_usb_flag() << 2 | sf_is_card_full() << 1 | sf_in_card_exist() << 0 | 0x80;
|
|
}
|
|
mcuReg[i] = DSP_WRITE_FLG; //MCU set end
|
|
mcuData[i++] = 1;
|
|
printf("[%s:%d] mcuData[%d]0x%02x\n", __FUNCTION__, __LINE__, (i - 1), mcuData[(i - 1)]);
|
|
#if 0
|
|
|
|
if((attrId == SF_MCU_POWEROFF) /*&& puiPara->DebugSwitch && IS_CARD_EXIST*/)
|
|
{
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
printf("W_addr[%2d]=0x%02x\n", mcuReg[j], mcuData[j]);
|
|
}
|
|
|
|
//sf_debug_save_log();
|
|
}
|
|
#endif
|
|
sf_mcu_write_multi(mcuReg, mcuData, i);
|
|
return SUCCESS;
|
|
}
|
|
//#if 1
|
|
|
|
#elif defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_analog_pir_sen_convert
|
|
Description: Analog PIR Sensitivity Convert
|
|
Input: digPir sensitivity
|
|
Output: N/A
|
|
Return: Analog PIR Sensitivity
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_mcu_analog_pir_sen_convert(UINT8 pirs)
|
|
{
|
|
UINT8 pirlevel = 0;
|
|
|
|
if(pirs > 6)
|
|
pirlevel = 0;
|
|
else if(pirs > 3)
|
|
pirlevel = 1;
|
|
else
|
|
pirlevel = 2;
|
|
|
|
return pirlevel;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_power_on_para_get
|
|
Description: set data to MCU
|
|
Input: attrId:which kind of para want to get
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_mcu_reg_set(MCUParam_t attrId, UINT8 val)
|
|
{
|
|
unsigned char mcuReg[REG_SIZE] = {0};
|
|
unsigned char mcuData[REG_SIZE] = {0};
|
|
//unsigned char regsize =0;
|
|
unsigned char i = 0;
|
|
unsigned char temp = 0;
|
|
//unsigned char dailyReportFlag = 1;
|
|
unsigned char paraSyncFlag = 0;
|
|
unsigned char gpsAlwaysFlag = 0;
|
|
//unsigned char DigPirPulseCount = 0;
|
|
//unsigned char DigPirWindowTime = 0;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//SF_PARA_TIME_S date = { 0 };
|
|
UINT8 PowerOnMode = 0;
|
|
signed int isUsb = 0;
|
|
signed int isCard = 0;
|
|
signed int isCardFull = 0;
|
|
|
|
if(attrId != SF_MCU_CTRL_MODULE_PIR)//AND LDS SECTION_01 loading order.
|
|
{
|
|
isUsb = sf_is_usb_flag();
|
|
isCard = sf_in_card_exist();
|
|
isCardFull = sf_is_card_full();
|
|
PowerOnMode = sf_get_power_on_mode();
|
|
}
|
|
|
|
sf_set_sim_insert(1);//Remove hardware detection SIM card
|
|
printf("Firmware compile time:%s %s VER:%s\n", __DATE__, __TIME__,SF_BASE_VERSION);
|
|
printf("%s:%d DailyReportSwitch=%d %02d:%02d\n",__FUNCTION__,__LINE__, puiPara->DailyReportSwitch, puiPara->DailyReportTime2.Hour, puiPara->DailyReportTime2.Min);
|
|
printf("%s:%d isUsb = %d isCard = %d isCardFull = %d val = %d simCardInsert = %ld start mode = %d\n",__FUNCTION__,__LINE__, isUsb, isCard, isCardFull, val, simCardInsert, PowerOnMode);
|
|
sf_mcu_get_irshtter();
|
|
if (attrId > SF_MCU_PARAM_MAX)
|
|
{
|
|
printf("attrId ERROR!\n");
|
|
return -1;
|
|
}
|
|
|
|
|
|
if(attrId == SF_MCU_POWEROFF)
|
|
{
|
|
//printf("SynMcuSet = %x\n", statisPara->SynMcuSet);
|
|
printf("NeedTimeSyncStartUp = %d\n", puiPara->NeedTimeSyncStartUp);
|
|
if(puiPara->NeedTimeSyncStartUp == 1)
|
|
{
|
|
paraSyncFlag = 1;
|
|
}
|
|
#if 0
|
|
struct tm ctv = {0};
|
|
ctv = hwclock_get_time(TIME_ID_CURRENT);
|
|
printf("%s:%d %d : %d : %d : %d : %d : %d\n", __FUNCTION__, __LINE__,ctv.tm_year, ctv.tm_mon,ctv.tm_mday,ctv.tm_hour,ctv.tm_min,ctv.tm_sec);
|
|
|
|
mcuReg[i] = SF_RTC_YEAR;
|
|
mcuData[i++] = ctv.tm_year - 2000;
|
|
mcuReg[i] = SF_RTC_MONTH;
|
|
mcuData[i++] = ctv.tm_mon;
|
|
mcuReg[i] = SF_RTC_DAY;
|
|
mcuData[i++] = ctv.tm_mday;
|
|
mcuReg[i] = SF_RTC_HOUR;
|
|
mcuData[i++] = ctv.tm_hour;
|
|
mcuReg[i] = SF_RTC_MINUTE;
|
|
mcuData[i++] = ctv.tm_min;
|
|
mcuReg[i] = SF_RTC_SEC;
|
|
mcuData[i++] = ctv.tm_sec;
|
|
#endif
|
|
|
|
if((puiPara->GpsSwitch == 1) && (puiPara->GpsNumber))
|
|
{
|
|
gpsAlwaysFlag=1;
|
|
}
|
|
else
|
|
{
|
|
gpsAlwaysFlag=0;
|
|
}
|
|
|
|
if(puiPara->PirSensitivity)
|
|
temp = 0x01;
|
|
else
|
|
temp = 0x00;
|
|
|
|
if(1 == puiPara->TimelapseSwitch)
|
|
{
|
|
temp |= 0x02;
|
|
}
|
|
|
|
if(1 == puiPara->PirDelaySwitch)
|
|
{
|
|
temp |= 0x04;
|
|
}
|
|
|
|
|
|
printf("[%s:%d]paraSyncFlag=%d\n", __FUNCTION__, __LINE__, paraSyncFlag);
|
|
|
|
if(paraSyncFlag)
|
|
{
|
|
temp |= 0x08;
|
|
}
|
|
|
|
|
|
//if(puiPara->dailyReport)
|
|
if(/*(puiPara->GpsSwitch) && */(1 == paraSyncFlag))
|
|
{
|
|
temp &= ~0x10;
|
|
}
|
|
else if(simCardInsert) //dailyreport alway open
|
|
{
|
|
temp |= 0x10;
|
|
}
|
|
|
|
|
|
if(puiPara->TimeSend1Switch == 1)
|
|
temp |= 0x20;
|
|
|
|
if(puiPara->TimeSend2Switch == 1)
|
|
temp |= 0x40;
|
|
|
|
if(gpsAlwaysFlag && simCardInsert)
|
|
temp |= 0x80;
|
|
|
|
temp |= 0x10;
|
|
|
|
mcuReg[i] = FUNCTION_SWTICH0;
|
|
mcuData[i++] = temp;
|
|
|
|
temp = 0;
|
|
|
|
if(puiPara->TimelapseSwitch)
|
|
{
|
|
mcuReg[i] = TIMELAPSE_HOUR;
|
|
mcuData[i++] = puiPara->TimelapseTime.Hour;
|
|
mcuReg[i] = TIMELAPSE_MINUTE;
|
|
mcuData[i++] = puiPara->TimelapseTime.Min;
|
|
mcuReg[i] = TIMELAPSE_SEC;
|
|
|
|
if((puiPara->TimelapseSwitch) && (puiPara->TimelapseTime.Hour == 0) && (puiPara->TimelapseTime.Min == 0) && (puiPara->TimelapseTime.Sec == 0))
|
|
mcuData[i++] = 5;
|
|
else
|
|
mcuData[i++] = puiPara->TimelapseTime.Sec;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = TIMELAPSE_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = TIMELAPSE_MINUTE;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = TIMELAPSE_SEC;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(puiPara->PirDelaySwitch)
|
|
{
|
|
mcuReg[i] = PIR_DELAY_HOUR;
|
|
mcuData[i++] = puiPara->PirDelayTime.Hour;
|
|
mcuReg[i] = PIR_DELAY_MINUTE;
|
|
mcuData[i++] = puiPara->PirDelayTime.Min;
|
|
mcuReg[i] = PIR_DELAY_SEC;
|
|
mcuData[i++] = puiPara->PirDelayTime.Sec;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = PIR_DELAY_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = PIR_DELAY_MINUTE;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = PIR_DELAY_SEC;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(paraSyncFlag)
|
|
{
|
|
mcuReg[i] = TIME_SYNC_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = TIME_SYNC_MINUTE;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = TIME_SYNC_SEC;
|
|
mcuData[i++] = 30;
|
|
}
|
|
|
|
if(puiPara->DailyReportSwitch)
|
|
{
|
|
mcuReg[i] = DAILY_REPORT_HOUR;
|
|
mcuData[i++] = puiPara->DailyReportTime2.Hour;
|
|
mcuReg[i] = DAILY_REPORT_MINUTE;
|
|
mcuData[i++] = puiPara->DailyReportTime2.Min;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = DAILY_REPORT_HOUR;
|
|
mcuData[i++] =0;
|
|
mcuReg[i] = DAILY_REPORT_MINUTE;
|
|
mcuData[i++] =0;
|
|
}
|
|
mcuReg[i] = DAILY_SEND1_HOUR;
|
|
mcuData[i++] = puiPara->TimeSend1.Hour;
|
|
mcuReg[i] = DAILY_SEND1_MINUTE;
|
|
mcuData[i++] = puiPara->TimeSend1.Min;
|
|
|
|
mcuReg[i] = DAILY_SEND2_HOUR;
|
|
mcuData[i++] = puiPara->TimeSend2.Hour;
|
|
mcuReg[i] = DAILY_SEND2_MINUTE;
|
|
mcuData[i++] = puiPara->TimeSend2.Min;
|
|
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
temp = sf_mcu_analog_pir_sen_convert(puiPara->PirSensitivity);
|
|
//hybrid mode 4G module keep sleep
|
|
if(((puiPara->NetWorkNeedSearch) != 3) && simCardInsert && gModuleSleep)
|
|
{
|
|
//bit 5-bit 6, daily mode 0, hybrid mode 1, instant mode 2
|
|
if(((puiPara->GprsMode) == 1) || (paraSyncFlag))
|
|
{
|
|
temp |= 0x40;
|
|
}
|
|
else
|
|
{
|
|
if (((puiPara->GprsMode) == 2) && isSignalReady && (GPRS_ERRNO == 0))
|
|
temp |= 0x20;
|
|
|
|
//sf_pdp_flg_set(0);
|
|
}
|
|
}
|
|
if((PowerOnMode == PWR_ON_AUTO) || (PowerOnMode == PWR_ON_SETUP) || (PowerOnMode == PWR_ON_GPRS_INIT) || ((PowerOnMode == PWR_ON_DAILY_REPORT) /*&& (drNoResetTimeSync != SF_TRUE)*/))
|
|
{
|
|
temp |= 0x10; /*bit4 rest*/
|
|
}
|
|
|
|
if(((puiPara->GprsSwitch) && (simCardInsert) && ((puiPara->SendType) == 0)) || (paraSyncFlag))
|
|
{
|
|
temp |= 0x80;
|
|
}
|
|
else
|
|
{
|
|
//sf_pdp_flg_set(0);
|
|
}
|
|
|
|
mcuData[i++] = temp;
|
|
|
|
mcuReg[i] = DIGITAL_PIR_SENSITIVITY;
|
|
mcuData[i++] = (puiPara->DigitPirSensitivity);//PirDigtSensRegValue[SysGetFlag(PirSensitivity)];
|
|
mcuReg[i] = DIGITAL_PIR_CFG;
|
|
mcuData[i++] = ((puiPara->DigitPirWindowTime) << 4) | (puiPara->DigitPirCnt);
|
|
//mcuData[i++] = (PirDigtSensRegValue[SysGetFlag(PirSensitivity)] <= 10 ? 1 : 0);
|
|
|
|
//DSP busy/idle
|
|
mcuReg[i] = DSP_BUSY_STATUS;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = isUsb << 2 | isCardFull << 1 | isCard << 0;
|
|
|
|
mcuReg[i] = POWEROFF_TYPE;
|
|
temp = 0;
|
|
|
|
if(simCardInsert && (puiPara->NetWorkNeedSearch)
|
|
&& ((PowerOnMode == PWR_ON_AUTO) || (PowerOnMode == PWR_ON_SETUP) || (PowerOnMode == PWR_ON_DAILY_REPORT)))/* SET->ON, OFF->ON*/
|
|
temp = 1;
|
|
else if(SmsCheck)
|
|
temp = 2;
|
|
|
|
//if (!(sf_get_pir_statu_flag() || (PowerOnMode == PWR_ON_AUTO)))
|
|
temp |= (val == APP_POWER_OFF_BATT_EMPTY) << 6;
|
|
|
|
mcuData[i++] = (val==APP_POWER_OFF_APO)<<7 | temp;
|
|
|
|
//battery recovery
|
|
mcuReg[i] = VBAT_RECOVER_VAL;
|
|
mcuData[i++] = SF_BATT_RECOVERY;
|
|
|
|
if(puiPara->WorkTime1Switch)
|
|
{
|
|
mcuReg[i] = WORKTIME1_SWITCH;
|
|
mcuData[i++] = 0xFF;
|
|
|
|
mcuReg[i] = WORKTIME1_START_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[0].StartTime.Hour;
|
|
mcuReg[i] = WORKTIME1_START_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[0].StartTime.Min;
|
|
|
|
mcuReg[i] = WORKTIME1_STOP_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[0].StopTime.Hour;
|
|
mcuReg[i] = WORKTIME1_STOP_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[0].StopTime.Min;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = WORKTIME1_SWITCH;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME1_START_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME1_START_MINUTE;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME1_STOP_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME1_STOP_MINUTE;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(puiPara->WorkTime2Switch)
|
|
{
|
|
mcuReg[i] = WORKTIME2_SWITCH;
|
|
mcuData[i++] = 0xFF;
|
|
|
|
mcuReg[i] = WORKTIME2_START_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[1].StartTime.Hour;
|
|
mcuReg[i] = WORKTIME2_START_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[1].StartTime.Min;
|
|
|
|
mcuReg[i] = WORKTIME2_STOP_HOUR;
|
|
mcuData[i++] = puiPara->WorkTime[1].StopTime.Hour;
|
|
mcuReg[i] = WORKTIME2_STOP_MINUTE;
|
|
mcuData[i++] = puiPara->WorkTime[1].StopTime.Min;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = WORKTIME2_SWITCH;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME2_START_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME2_START_MINUTE;
|
|
mcuData[i++] = 0;
|
|
|
|
mcuReg[i] = WORKTIME2_STOP_HOUR;
|
|
mcuData[i++] = 0;
|
|
mcuReg[i] = WORKTIME2_STOP_MINUTE;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
if(((puiPara->GpsSwitch) || (puiPara->FristSendDailyAndGps)) && (((sf_get_mode_flag())) || paraSyncFlag))
|
|
{
|
|
mcuReg[i] = GPS_POWER_TIMER_CLEAR;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 1;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 0;
|
|
}
|
|
|
|
temp = 0;
|
|
|
|
if((puiPara->TimeSend3Switch) == 1)
|
|
temp |= 0x01;
|
|
|
|
if((puiPara->TimeSend4Switch) == 1)
|
|
temp |= 0x02;
|
|
|
|
mcuReg[i] = FUNCTION_SWTICH1;
|
|
mcuData[i++] = temp;
|
|
|
|
mcuReg[i] = DAILY_SEND3_HOUR;
|
|
mcuData[i++] = puiPara->TimeSend3.Hour;
|
|
mcuReg[i] = DAILY_SEND3_MINUTE;
|
|
mcuData[i++] = puiPara->TimeSend3.Min;
|
|
|
|
mcuReg[i] = DAILY_SEND4_HOUR;
|
|
mcuData[i++] = puiPara->TimeSend4.Hour;
|
|
mcuReg[i] = DAILY_SEND4_MINUTE;
|
|
mcuData[i++] = puiPara->TimeSend4.Min;
|
|
}else if(attrId == SF_MCU_CTRL_MODULE_PIR){
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
|
|
temp = (puiPara->PirSensitivity);//sf_mcu_analog_pir_sen_convert(SysGetFlag(DigPirSensitivity));
|
|
|
|
if(puiPara->GprsMode)//hybrid mode 4G module keep sleep
|
|
{
|
|
temp |= 0x40;
|
|
}
|
|
|
|
if((puiPara->GprsSwitch) && (val == 1))
|
|
{
|
|
temp |= 0x80;
|
|
}
|
|
else
|
|
{
|
|
//sf_pdp_flg_set(0);
|
|
}
|
|
|
|
mcuData[i++] = temp;
|
|
|
|
if(ConfigureModeFlag)
|
|
{
|
|
mcuReg[i] = DIGITAL_PIR_SENSITIVITY;
|
|
mcuData[i++] = (puiPara->DigitPirSensitivity);//PirDigtSensRegValue[SysGetFlag(PirSensitivity)];
|
|
mcuReg[i] = DIGITAL_PIR_CFG;
|
|
mcuData[i++] = ((puiPara->DigitPirWindowTime) << 4) | (puiPara->DigitPirCnt);
|
|
}
|
|
|
|
if(((puiPara->GpsSwitch) || (puiPara->FristSendDailyAndGps)) && (ConfigureModeFlag || paraSyncFlag))
|
|
{
|
|
mcuReg[i] = GPS_POWER_TIMER_CLEAR;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 1;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 0;
|
|
}
|
|
}else if(attrId == SF_MCU_PARA){
|
|
mcuReg[i] = ANALOG_PIR_SENSITIVITY;
|
|
|
|
temp = (puiPara->PirSensitivity);//sf_mcu_analog_pir_sen_convert(puiPara->PirSensitivity);
|
|
|
|
if((puiPara->GprsMode) && (gModuleSleep == 1))//hybrid mode 4G module keep sleep
|
|
{
|
|
temp |= 0x40;
|
|
}
|
|
|
|
if((puiPara->GprsSwitch) && (simCardInsert))
|
|
{
|
|
temp |= 0x80;
|
|
}
|
|
else
|
|
{
|
|
//sf_pdp_flg_set(0);
|
|
}
|
|
|
|
mcuData[i++] = temp;
|
|
|
|
printf("[%s:%d] temp:0x%02x GprsSwitch:%d simCardInsert:%lu\n", __FUNCTION__, __LINE__, temp, puiPara->GprsSwitch, simCardInsert);
|
|
mcuReg[i] = DIGITAL_PIR_SENSITIVITY;
|
|
mcuData[i++] = (puiPara->DigitPirSensitivity);//PirDigtSensRegValue[SysGetFlag(PirSensitivity)];
|
|
mcuReg[i] = DIGITAL_PIR_CFG;
|
|
mcuData[i++] = ((puiPara->DigitPirWindowTime) << 4) | (puiPara->DigitPirCnt);
|
|
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = (puiPara->CamArmDiable) << 6 | isUsb << 2 | isCardFull << 1 | isCard << 0;
|
|
|
|
if(((puiPara->GpsSwitch) || (puiPara->FristSendDailyAndGps)) && (ConfigureModeFlag || paraSyncFlag))
|
|
{
|
|
mcuReg[i] = GPS_POWER_TIMER_CLEAR;
|
|
mcuData[i++] = 1;
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 1;
|
|
}
|
|
else
|
|
{
|
|
mcuReg[i] = GPS_POWER_CTRL;
|
|
mcuData[i++] = 0;
|
|
}
|
|
}else if(attrId == SF_MCU_RESET_MODULE){
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = (puiPara->CamArmDiable) << 6 | isUsb << 2 | isCardFull << 1 | isCard << 0 | 0x10;
|
|
//sf_pdp_flg_set(0);
|
|
}else if(attrId == SF_MCU_SOFT_UPDATE){
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
|
|
if(val == 1)
|
|
{
|
|
mcuData[i++] = (puiPara->CamArmDiable) << 6 | isUsb << 2 | isCardFull << 1 | isCard << 0 | 0x08;
|
|
}
|
|
else
|
|
{
|
|
mcuData[i++] = (puiPara->CamArmDiable) << 6 | isUsb << 2 | isCardFull << 1 | isCard << 0;
|
|
}
|
|
}else if(attrId == SF_MCU_POWER_RESTART){
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = (puiPara->CamArmDiable) << 6 | isUsb << 2 | isCardFull << 1 | isCard << 0 | 0x20;
|
|
}else if(attrId == SF_MCU_PIR_RESTART){
|
|
mcuReg[i] = SF_SYS_STATUS;
|
|
mcuData[i++] = (puiPara->CamArmDiable) << 6 | isUsb << 2 | isCardFull << 1 | isCard << 0 | 0x80;
|
|
}
|
|
|
|
mcuReg[i] = DSP_WRITE_FLG; //MCU set end
|
|
mcuData[i++] = 1;
|
|
//printf("[%s:%d] mcuData[%d]0x%02x\n", __FUNCTION__, __LINE__, (i - 1), mcuData[(i - 1)]);
|
|
#if 0
|
|
|
|
if((attrId == SF_MCU_POWEROFF) && puiPara->DebugMode && IS_CARD_EXIST)
|
|
{
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
printf("W_addr[%2d]=0x%02x\n",mcuReg[j],mcuData[j]);
|
|
}
|
|
|
|
sf_debug_save_log();
|
|
}
|
|
#endif
|
|
sf_mcu_write_multi(mcuReg, mcuData, i);
|
|
return SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
BOOL sf_get_mode_flag(void)
|
|
{
|
|
//printf("[%s:%d] ConfigureModeFlag:%d\n",__FUNCTION__,__LINE__,ConfigureModeFlag);
|
|
return ConfigureModeFlag;
|
|
}
|
|
|
|
BOOL sf_is_usb_flag(void)
|
|
{
|
|
return gpio_getIntStatus(GPIO_INT_USBPLUGIN);
|
|
}
|
|
|
|
#if 0
|
|
void sf_cmd_camera_restart(UINT8 cameraRestart)
|
|
{
|
|
CameraCmd.cameraRestart = cameraRestart;
|
|
printf("[%s:%d] e cameraRestart:%d\n",__FUNCTION__,__LINE__,CameraCmd.cameraRestart);
|
|
}
|
|
|
|
UINT8 sf_get_camera_restart(void)
|
|
{
|
|
printf("[%s:%d] s cameraRestart:%d\n",__FUNCTION__,__LINE__,CameraCmd.cameraRestart);
|
|
return CameraCmd.cameraRestart;
|
|
}
|
|
|
|
void sf_calculate_daily_report(UINT8*dailyHour, UINT8*dailyMin)
|
|
{
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
UINT16 daily_sum_min = 0;
|
|
UINT16 timelapse_sum_min = 0;
|
|
struct tm mcuTime = {0};
|
|
//Daily report is always ON
|
|
if(puiPara->ReDailyReport)
|
|
{
|
|
mcuTime = hwclock_get_time(TIME_ID_CURRENT);
|
|
if(puiPara->DailyReportTime2.Hour >= mcuTime.tm_hour)
|
|
{
|
|
|
|
daily_sum_min = (puiPara->DailyReportTime2.Hour * 60 + puiPara->DailyReportTime2.Min) - (mcuTime.tm_hour * 60 + mcuTime.tm_min);
|
|
*dailyHour = daily_sum_min / 60;
|
|
*dailyMin = daily_sum_min % 60;
|
|
}
|
|
else
|
|
{
|
|
daily_sum_min = (puiPara->DailyReportTime2.Hour * 60 + puiPara->DailyReportTime2.Min + (24*60)) - (mcuTime.tm_hour * 60 + mcuTime.tm_min);
|
|
*dailyHour = daily_sum_min / 60;
|
|
*dailyMin = daily_sum_min % 60;
|
|
}
|
|
printf("mcuTime.hour:%d,mcuTime.min:%d\n",mcuTime.tm_hour,mcuTime.tm_min);
|
|
printf("ReDailyHour:%d,ReDailyMinute:%d\n",puiPara->DailyReportTime2.Hour,puiPara->DailyReportTime2.Min);
|
|
printf("daily_sum_min:%d\n",daily_sum_min);
|
|
|
|
|
|
}
|
|
else if(puiPara->GprsMode == SF_REMOTE_CONTROL_REAL_TIME)
|
|
{
|
|
|
|
if((!sf_get_mode_flag()) && (sf_get_camera_restart() == 1))
|
|
{
|
|
// PIR mode,if remote control is setted real time,need reboot to connect ACM,use DailyReport.
|
|
*dailyHour = 0;
|
|
*dailyMin = 1;
|
|
}
|
|
else
|
|
{
|
|
// if remote control set real time,check the socket every two hour ,to keep alive
|
|
*dailyHour = 2;
|
|
*dailyMin = 0;
|
|
}
|
|
|
|
}
|
|
else if(puiPara->GpsAntiTheftSwitch == 1)
|
|
{
|
|
if((!sf_get_mode_flag()) && (sf_get_camera_restart() == 1))
|
|
{
|
|
// PIR mode,if gpsTheftPrevention ON, have not update gps in 24H,need to reseach gps then update to acm,use DailyReport.
|
|
*dailyHour = 0;
|
|
*dailyMin = 1;
|
|
}
|
|
else
|
|
{
|
|
*dailyHour = puiPara->DailyReportTime.Hour;
|
|
*dailyMin = puiPara->DailyReportTime.Min;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*dailyHour = puiPara->DailyReportTime.Hour;
|
|
*dailyMin = puiPara->DailyReportTime.Min;
|
|
}
|
|
|
|
printf("%s:%d dailyHour:%d,dailyMin:%d\n", __FUNCTION__, __LINE__,*dailyHour,*dailyMin);
|
|
printf("%s:%d TimerHstartT:%d,TimerMstartT:%d,TimerSstartT:%d\n", __FUNCTION__, __LINE__,puiPara->TimelapseTime.Hour,puiPara->TimelapseTime.Min,puiPara->TimelapseTime.Sec);
|
|
//need check dailyReport & timelapse ?
|
|
if((sf_convert_power_on_mode() == PWR_ON_TIMELAPSE)/* || (sf_get_timelapse_change())*/ || (sf_get_mode_flag()))
|
|
{
|
|
//dailyHour = dailyHour + 60;
|
|
daily_sum_min = (*dailyHour) * 60 + (*dailyMin);// + 60 + dailyMin
|
|
|
|
if(puiPara->TimelapseTime.Sec)
|
|
{
|
|
timelapse_sum_min = (puiPara->TimelapseTime.Hour) * 60 + puiPara->TimelapseTime.Min + 1;
|
|
}
|
|
else
|
|
{
|
|
timelapse_sum_min = (puiPara->TimelapseTime.Hour) * 60 + puiPara->TimelapseTime.Min;
|
|
}
|
|
|
|
if(timelapse_sum_min >= daily_sum_min)
|
|
{
|
|
if((timelapse_sum_min - daily_sum_min) <= 5)
|
|
{
|
|
if((puiPara->ReDailyReport == 1) && (timelapse_sum_min < 5))
|
|
{
|
|
puiPara->ReDailyReport = 2;
|
|
puiPara->DailyReportTime2.Hour = 0;
|
|
puiPara->DailyReportTime2.Min = 0;
|
|
}
|
|
else
|
|
{
|
|
*dailyMin = *dailyMin + 5;
|
|
}
|
|
}
|
|
|
|
}
|
|
// only timelapse < dailyReport+5,daily report = daily report + 5
|
|
|
|
}
|
|
|
|
printf("%s:%d Calculated:dailyHour:%d,dailyMin:%d\n", __FUNCTION__, __LINE__,*dailyHour,*dailyMin);
|
|
|
|
}
|
|
#endif
|
|
|
|
int sf_while_flag(void)
|
|
{
|
|
if((!sf_is_usb_flag()) && (POWEROFF != 1))
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_mcu_get_irshtter
|
|
Description: get IRSHTTER.
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: IRSHTTER
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT16 sf_mcu_get_irshtter(void)
|
|
{
|
|
static BOOL isRefresh = 1;
|
|
UINT8 dataTemp1 = 0, dataTemp2 = 0;
|
|
|
|
UINT8 mcuReg[REG_SIZE] = { 0 };
|
|
UINT8 mcuData[REG_SIZE] = { 0 };
|
|
UINT8 i = 0;
|
|
if(isRefresh){
|
|
isRefresh = 0;
|
|
mcuReg[i++] = LUMINANCE_L;
|
|
mcuReg[i++] = LUMINANCE_H;
|
|
sf_mcu_read_multi(mcuReg, mcuData, i);
|
|
i = 0;
|
|
|
|
dataTemp1= mcuData[i++];
|
|
dataTemp2 = mcuData[i++];
|
|
|
|
IRSHTTER = (dataTemp2 << 8) | dataTemp1;
|
|
}
|
|
|
|
|
|
printf("%s:%d IRSHTTER = %d\n", __FUNCTION__, __LINE__, IRSHTTER);
|
|
|
|
return IRSHTTER;
|
|
}
|
|
|
|
|
|
UINT32 sf_set_pir_sensitivity(UINT8 pirs)
|
|
{
|
|
UINT8 digPirLevel[10] = {200, 38, 30, 24, 18, 16, 10, 9, 8, 7};
|
|
UINT8 digPirCount[10] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
|
|
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(pirs >= 10)
|
|
return FAIL;
|
|
puiPara->PirSensitivity = pirs;
|
|
puiPara->DigitPirSensitivity = digPirLevel[pirs];
|
|
puiPara->DigitPirCnt = digPirCount[pirs];
|
|
puiPara->DigitPirWindowTime = 0;
|
|
|
|
/*if(puiPara->PirSensitivity))
|
|
{
|
|
puiPara->TimelapseSwitch, SF_OFF);
|
|
puiPara->TimelapseTime.Hour = 0;
|
|
puiPara->TimelapseTime.Min = 0;
|
|
puiPara->TimelapseTime.Sec = 0;
|
|
//Save_MenuInfo();
|
|
}*/
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
void sf_set_module_sleep_flag(UINT8 flag)
|
|
{
|
|
gModuleSleep = flag;
|
|
}
|
|
|
|
void sf_file_thumb_cfg_fill(char* filepath,char* fileName, UINT32 size, SF_FILE_TYPE_E enFileType)
|
|
{
|
|
if (pThumbFileCfg == NULL) {
|
|
pThumbFileCfg = malloc(sizeof(SF_SRCFILE_ATTR_S));
|
|
if (pThumbFileCfg == NULL) {
|
|
printf("%s:%d pThumbFileCfg malloc err\n", __FUNCTION__, __LINE__);
|
|
return;
|
|
}
|
|
memset(pThumbFileCfg, 0, sizeof(SF_SRCFILE_ATTR_S));
|
|
printf("%s:%d pThumbFileCfg malloc\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
if(pThumbFileCfg->filecnt >= SF_SRCFILE_MAX)
|
|
{
|
|
pThumbFileCfg->filecnt = 0;
|
|
|
|
}
|
|
snprintf(pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfilePath, sizeof(pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfilePath), "%s", filepath);
|
|
//sprintf(pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfilePath, "%s", filepath);
|
|
snprintf(pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfileName, sizeof(pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfileName), "%s", fileName);
|
|
//sprintf(pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfileName, "%s", fileName);
|
|
printf("sf_file_thumb_cfg_fill:enFileType:%d\n",enFileType);
|
|
pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].enFileTye = enFileType;
|
|
pThumbFileCfg->stfileattr[pThumbFileCfg->filecnt].thumbfileSize = size;
|
|
pThumbFileCfg->filecnt++;
|
|
|
|
|
|
}
|
|
void sf_file_thumb_cfg_set(SF_SRCFILE_ATTR_S *pThumbFileCfgl)
|
|
{
|
|
pThumbFileCfg = pThumbFileCfgl;
|
|
//memcpy(&pThumbFileCfg,pThumbFileCfgl,sizeof(pThumbFileCfg));
|
|
}
|
|
|
|
SF_SRCFILE_ATTR_S* sf_file_thumb_cfg_get(void)
|
|
{
|
|
return pThumbFileCfg;
|
|
}
|
|
void sf_file_thumb_cfg_clear(void)
|
|
{
|
|
pThumbFileCfg->filecnt = 0;
|
|
}
|
|
|
|
void sf_file_thumb_cfg_sava(void)
|
|
{
|
|
printf("%s:%d s\n", __FUNCTION__, __LINE__);
|
|
|
|
|
|
#if 0
|
|
char tmp[64] = {'\0'};
|
|
snprintf(tmp, sizeof(tmp), "%s", SF_SD_THUMB_PATH);
|
|
|
|
if (FileSys_DeleteFile(tmp) != FST_STA_OK)
|
|
{
|
|
printf("%s:%d delete failed\n", __FUNCTION__, __LINE__);
|
|
}
|
|
//FST_FILE fp = FileSys_OpenFile(tmp, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
|
|
|
|
int fd = open(tmp, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
|
|
if (fd == -1)
|
|
{
|
|
printf("%s:%d err\n", __FUNCTION__, __LINE__);
|
|
// 处理文件打开失败的错误
|
|
return ;
|
|
}
|
|
|
|
lseek(fd, 0, SEEK_SET);
|
|
UINT32 size = sizeof(SF_SRCFILE_ATTR_S);
|
|
write(fd, pThumbFileCfg, size);
|
|
close(fd);
|
|
|
|
//FileSys_WriteFile(fp, (UINT8*)pThumbFileCfg, &size, 0, NULL);
|
|
//FileSys_CloseFile(fp);
|
|
free(pThumbFileCfg);
|
|
#endif
|
|
UINT8 fileIndex = 0;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
|
|
if (pThumbFileCfg != NULL) {
|
|
for(fileIndex = 0; fileIndex < pThumbFileCfg->filecnt; fileIndex++)
|
|
{
|
|
if((fileIndex == 0) || (puiPara->SendMulti == 1))
|
|
sf_add_file_name_to_send_list(pThumbFileCfg->stfileattr[fileIndex].thumbfileName);
|
|
printf("%s:%d thumbfileSize:%ld thumbfileName:%s thumbfilePath:%s\n", __FUNCTION__, __LINE__,pThumbFileCfg->stfileattr[fileIndex].thumbfileSize,pThumbFileCfg->stfileattr[fileIndex].thumbfileName,pThumbFileCfg->stfileattr[fileIndex].thumbfilePath);
|
|
}
|
|
printf("%s:%d e Size:%ld\n", __FUNCTION__, __LINE__,pThumbFileCfg->stfileattr[fileIndex].thumbfileSize);
|
|
free(pThumbFileCfg);
|
|
}
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_add_file_name_to_send_list
|
|
Description: add file name to send list
|
|
Input: sendfname
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_add_file_name_to_send_list(char *sendfname)
|
|
{
|
|
char sendListName[64] = {0};
|
|
char buff[SF_SEND_LIST_ITEM_LENGTH+1] = {0};
|
|
int fd = 0;
|
|
struct stat st;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
#if SF_IQ_TEST != ENABLE
|
|
INT32 uiStatus = 0;
|
|
UINT8 ucAttrib = 0;
|
|
uiStatus = FileSys_GetAttrib(PHOTO_THUMB_PATH, &ucAttrib);
|
|
if (uiStatus == FST_STA_OK) {
|
|
if(!(ucAttrib&FST_ATTRIB_HIDDEN)){
|
|
FileSys_SetAttrib(PHOTO_THUMB_PATH, FST_ATTRIB_HIDDEN/* | FST_ATTRIB_SYSTEM*/, TRUE);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if(strlen(sendfname) != SF_SEND_LIST_ITEM_LENGTH-3) //3 ->CamMode \r\n
|
|
{
|
|
printf("%s:%d AddFileNameToSenddist fail: send file name format error\n", __FUNCTION__, __LINE__);
|
|
return;
|
|
}
|
|
|
|
printf("Add %s to send.List\n", sendfname);
|
|
if(0 == puiPara->SendType){
|
|
snprintf(sendListName, sizeof(sendListName), "%s", SF_THUMB_SEND_AUTO);
|
|
if (FileSys_DeleteFile(sendListName) != FST_STA_OK) {
|
|
DBG_IND("Ignore deleting file.\r\n");
|
|
}
|
|
}else {
|
|
snprintf(sendListName, sizeof(sendListName), "%s", SF_THUMB_SEND_LIST);
|
|
}
|
|
if(access(sendListName, F_OK) == 0)
|
|
{
|
|
printf("sendListName:%s\n",sendListName);
|
|
fd = open(sendListName, O_APPEND | O_WRONLY);
|
|
}
|
|
else {
|
|
fd = open(sendListName, O_APPEND | O_WRONLY | O_CREAT);
|
|
}
|
|
if(fd)
|
|
{
|
|
fstat(fd, &st);
|
|
lseek(fd, 0, SEEK_END);
|
|
snprintf(buff, sizeof(buff), "%d%s\r\n", puiPara->CamMode, sendfname);
|
|
|
|
write(fd, buff, SF_SEND_LIST_ITEM_LENGTH);
|
|
close(fd);
|
|
printf("Add Success st_size:%ld\n", st.st_size);
|
|
}
|
|
#if SF_BATTERY_TEST == ENABLE
|
|
char str1[5] = { 0 };
|
|
memcpy(str1, sendfname + 4, 4);
|
|
sf_BatteryInfoSave(str1);
|
|
#endif
|
|
}
|
|
|
|
#if defined __FREERTOS
|
|
|
|
int sf_mod_init(void)
|
|
{
|
|
int rt = 0;
|
|
static int InitFlag = 1;
|
|
|
|
if(InitFlag)
|
|
{
|
|
InitFlag = 0;
|
|
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_68CS_)
|
|
rt = sf_init_mcu();
|
|
|
|
#elif defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_)
|
|
#if HUNTING_MCU_I2C == ENABLE
|
|
rt = sf_init_mcu();
|
|
#else
|
|
rt = sf_commu_mcu_task_start();
|
|
#endif
|
|
#endif
|
|
}
|
|
return rt;
|
|
}
|
|
|
|
void sf_mod_exit(void)
|
|
{
|
|
sf_off_mcu();
|
|
#if HUNTING_MCU_I2C == ENABLE
|
|
sf_i2c_remove_driver(sf_i2c.id);
|
|
#endif
|
|
}
|
|
|
|
#elif defined __KERNEL__
|
|
static int __init sf_init(void)
|
|
{
|
|
int rt;
|
|
|
|
rt = sf_init_mcu();
|
|
|
|
return rt;
|
|
}
|
|
|
|
static void __exit sf_exit(void)
|
|
{
|
|
sf_i2c_remove_driver(sf_i2c.id);
|
|
}
|
|
|
|
module_init(sf_init);
|
|
module_exit(sf_exit);
|
|
|
|
MODULE_DESCRIPTION("SIFAR MCU");
|
|
MODULE_AUTHOR("SiFar.");
|
|
MODULE_LICENSE("GPL");
|
|
#endif
|
|
|