int
settime_new(todr_chip_handle_t tch, volatile struct timeval *tvp)
{
/* Stop the clock */
rtc_write(RTC_CONTROL,rtc_read(RTC_CONTROL) & ~RTC_START);
#ifdef RTC_DEBUG
printf("Setting RTC to 0x%08x. Regs before:\n",tvp->tv_sec);
rtc_print();
#endif
rtc_write(RTC_CNTR0, (tvp->tv_sec >> 24) & 0xff);
rtc_write(RTC_CNTR1, (tvp->tv_sec >> 16) & 0xff);
rtc_write(RTC_CNTR2, (tvp->tv_sec >> 8) & 0xff);
rtc_write(RTC_CNTR3, (tvp->tv_sec) & 0xff);
#ifdef RTC_DEBUG
printf("Regs after:\n",secs);
rtc_print();
#endif
/* restart the clock */
rtc_write(RTC_CONTROL,rtc_read(RTC_CONTROL) | RTC_START);
return 0;
}
int thk_silent_time_and_pictures(void *param){
#if (SCH_TASKDEPLOYMENT_VERBOSE>=1)
con_printf("\n[thk_silent_time_and_pictures] Mandatory inactivity time...\r\n");
rtc_print(NULL);
#endif
//1) Silencio el TRX
#if (SCH_TRX_ONBOARD==1)
#if (SCH_TASKDEPLOYMENT_VERBOSE>=2)
con_printf(" * Turning off TX\r\b");
#endif
int trx_mode = 2; //TODO: Implement trx_setmode
trx_set_operation_mode( (void *)&trx_mode );
#endif
//2) tomo foto
pay_init_camera(NULL);
//int arg = CAM_MODE_VERBOSE;
int arg = CAM_MODE_BOTH;
pay_take_camera(&arg);
pay_stop_camera(NULL);
//parar ciclo de Payload
//int cam_state = SRP_PAY_XXX_STATE_INACTIVE;
PAY_xxx_State cam_state = pay_xxx_state_inactive;
pay_set_state_camera(&cam_state);
//3) duermo el SUCHAI por 30min
#if (SCH_TASKDEPLOYMENT_VERBOSE>=1)
con_printf(" * System halted at ");
rtc_print(NULL);
#endif
int mode= *( (int *)param );
if(mode) /* RealTIme */
{
// const unsigned int time_out = (0xFFFF) / portTICK_RATE_MS; /* 65,535[s]*/
const unsigned int time_out = (0xFFFF); /* 65,535[s]*/
unsigned int indx2;
for(indx2=0; indx2<THK_SILENT_TIME_MIN-1; indx2++)
{
//vTaskDelay(time_out);
__delay_ms(time_out);
ClrWdt()
}
con_printf(" * 65[s] remaining ...\r\n");
//vTaskDelay(time_out);
__delay_ms(time_out);
ClrWdt()
}
else /* NO RealTIme */
{
/*
* NB: This code should probably be converted to a _true_ device, then this
* initialization could happen in attach. The printf could get fixed then,
* too.
*/
void
rtc_init(void)
{
static struct todr_chip_handle tch;
u_char val;
scr2 = (u_int *)IIOV(NEXT_P_SCR2);
val = rtc_read(RTC_STATUS);
new_clock = (val & RTC_NEW_CLOCK) ? 1 : 0;
printf("Looks like a %s clock chip.\n",
(new_clock?
"MCS1850 (new style)":
"MC68HC68T1 (old style)"));
#ifdef RTC_DEBUG
rtc_print();
#endif
if (new_clock) {
tch.todr_gettime = gettime_new;
tch.todr_settime = settime_new;
tch.todr_gettime_ymdhms = NULL;
tch.todr_settime_ymdhms = NULL;
} else {
tch.todr_gettime_ymdhms = gettime_old;
tch.todr_settime_ymdhms = settime_old;
tch.todr_gettime = NULL;
tch.todr_settime = NULL;
}
tch.todr_setwen = NULL;
todr_attach(&tch);
}
int
settime_old(todr_chip_handle_t tcr, struct clock_ymdhms *dt)
{
u_char h;
/* Stop the clock */
rtc_write(RTC_CONTROL,rtc_read(RTC_CONTROL) & ~RTC_START);
#ifdef RTC_DEBUG
printf("Setting RTC to 0x%08x. Regs before:\n",secs);
rtc_print();
#endif
rtc_write(RTC_SEC,TOBCD(dt->dt_sec));
rtc_write(RTC_MIN,TOBCD(dt->dt_min));
h = rtc_read(RTC_HRS);
if (h & 0x80) { /* time is am/pm format */
if (dt->dt_hour == 0) {
rtc_write(RTC_HRS,TOBCD(12)|0x80);
} else if (dt->dt_hour < 12) { /* am */
rtc_write(RTC_HRS,TOBCD(dt->dt_hour)|0x80);
} else if (dt->dt_hour == 12) {
rtc_write(RTC_HRS,TOBCD(12)|0x80|0x20);
} else /* pm */
rtc_write(RTC_HRS,TOBCD(dt->dt_hour-12)|0x80|0x20);
} else { /* time is 24 hour format */
rtc_write(RTC_HRS,TOBCD(dt->dt_hour));
}
rtc_write(RTC_DAY,TOBCD(dt->dt_wday));
rtc_write(RTC_DATE,TOBCD(dt->dt_day));
rtc_write(RTC_MON,TOBCD(dt->dt_mon));
rtc_write(RTC_YR,TOBCD(dt->dt_year%100));
#ifdef RTC_DEBUG
printf("Regs after:\n",secs);
rtc_print();
#endif
/* restart the clock */
rtc_write(RTC_CONTROL,rtc_read(RTC_CONTROL) | RTC_START);
return 0;
}
void
rtc_attach(struct device *parent, struct device *self, void *aux)
{
struct rtc_softc *sc = (struct rtc_softc *)self;
struct mainbus_attach_args *maa = aux;
printf(": Dallas Semiconductor DS17485\n");
sc->sc_tag = maa->mb_bt;
if (bus_space_map(sc->sc_tag, maa->mb_addr, PMPPC_RTC_SIZE, 0,
&sc->sc_handle)) {
printf("%s: can't map i/o space\n", self->dv_xname);
return;
}
rtc_sc = sc;
#ifdef DEBUG
rtc_print();
#endif
}
void rtc_realtime_display(void)
{
int counter = 0;
unsigned long usec = 0;
rtc_enable(true);
rtc_ticktime_enable(true);
while( counter < 5) {
if(usec != BCDSEC) {
usec = BCDSEC;
rtc_print();
counter++;
}
}
rtc_ticktime_enable(false);
rtc_enable(false);
}
int main(void)
{
int fd,ret,i;
char test_buf[128];
char *func_buf;
struct stat fbuf;
struct aw_pm_info pm_info;
struct aw_pm_arg pm_arg;
printf("This test code is mainly for pm\n");
#if TEST_POWER_MODE==TEST_SYS_STANDBY
/*****************************************
config standby info
******************************************/
fd = open(PMU_DEV_PATH,O_RDWR);
if(fd==-1){
printf("can not open pm device\n");
exit(-19);
}
ioctl(fd,AW_PMU_VALID,&ret);
if(!ret){
/****************************************
read standby.bin
******************************************/
int tfd;
ret = stat(STANDBY_BIN_PATH,&fbuf);
if(ret<0)
exit(-19);
func_buf = (char *)malloc(fbuf.st_size);
if(!func_buf)
exit (-12);
tfd = open(STANDBY_BIN_PATH,O_RDONLY);
if(tfd==-1){
printf("open standby.bin fail\n");
exit(-19);
}
ret = read(tfd,func_buf,fbuf.st_size);
close(tfd);
/********set pmu**********/
memset(&pm_info,0,sizeof(struct aw_pm_info));
pm_info.func_addr = func_buf;
pm_info.func_size = fbuf.st_size;
pm_info.arg.wakeup_mode = TEST_WAKE_MODE;
#if 0
switch(pm_info.arg.wakeup_mode){
case RTC_DC_MODE:{
rtc_date_t rtc_date;
rtc_time_t rtc_time;
rtc_date.year = 2010;
rtc_date.month = 4;
rtc_date.day = 23;
rtc_date.wday = 5;
rtc_time.hour = 10;
rtc_time.min = TEST_DEFAULT_MIN;
rtc_time.sec =TEST_DEFAULT_SEC;
tm_set_rtc(&rtc_date,&rtc_time); //set rtc time
sleep(1);
tm_get_rtc(&rtc_date,&rtc_time);
printf("time %d:%d:%d\n",rtc_time.hour,rtc_time.min,rtc_time.sec);
rtc_time.sec += 10;
pm_info.arg.param[0] = AM_PMU_MK_DATE(rtc_date.year, rtc_date.month, rtc_date.day); //alarm date
pm_info.arg.param[1] = AM_PMU_MK_TIME(rtc_time.hour,rtc_time.min,rtc_time.sec); // alarm time
break;
}
case EXT_DC_MODE:
printf("Hey guys, this mode has not been implemented yet!");
break;
case KEYE_DC_MODE:
pm_info.arg.param[0] = 3; //count times
pm_info.arg.param[1] = 6; //key number
break;
case IRE_DC_MODE:
pm_info.arg.param[0] = 1; //valid code number
/*irkey code*/
pm_info.arg.param[1] = 0x12;//0xc0;//0x12;
pm_info.arg.param[2] = 0;
pm_info.arg.param[3] = 0;
pm_info.arg.param[4] = 0;
break;
case KEY_NDC_MODE:
pm_info.arg.param[0] = 60; //gpio num
break;
default:
break;
}
#endif
ioctl(fd,AW_PMU_SET,&pm_info);
}
close(fd);
/*****************************************
enter standby
*******************************************/
fd = open(SYS_PM_STAT_PATH, O_RDWR);
if(fd==-1){
printf("cant open power state\n");
exit(-19);
}
/*read status*/
ret = read(fd,test_buf,128);
if(ret>0){
test_buf[ret] = '\0';
printf("power state:%s\n",test_buf);
memcpy(test_buf,"mem",3);
write(fd,test_buf,3);
}else{
printf("read failed :%d\n",ret);
}
close(fd);
#elif TEST_POWER_MODE==TEST_SYS_POWER
rtc_date_t rtc_date;
rtc_time_t rtc_time;
fd = open(PMU_DEV_PATH,O_RDWR);
if(fd==-1){
printf("can not open pmu device\n");
exit(-19);
}
pm_arg.wakeup_mode = TEST_POFF_MODE;
rtc_date.year = 2010;
rtc_date.month = 4;
rtc_date.day = 23;
rtc_date.wday = 5;
rtc_time.hour = 10;
rtc_time.min = TEST_DEFAULT_MIN;
rtc_time.sec =TEST_DEFAULT_SEC;
tm_set_rtc(&rtc_date,&rtc_time); //set rtc time
sleep(1);
tm_get_rtc(&rtc_date,&rtc_time);
printf("time %d:%d:%d\n",rtc_time.hour,rtc_time.min,rtc_time.sec);
rtc_time.sec += 10;
pm_arg.param[0] = AM_PMU_MK_DATE(rtc_date.year, rtc_date.month, rtc_date.day); //on alarm date
pm_arg.param[1] = AM_PMU_MK_TIME(rtc_time.hour,rtc_time.min,rtc_time.sec); // on alarm time
if(pm_arg.wakeup_mode == PM_GEN_MODE)
pm_arg.param[2] = RTC_ALARM_GPO_LOW;
else
pm_arg.param[2] = RTC_ALARM_PW_MAX-4;
rtc_time.sec += 10;
pm_arg.param[3] = AM_PMU_MK_DATE(rtc_date.year, rtc_date.month, rtc_date.day); //off alarm date
pm_arg.param[4] = AM_PMU_MK_TIME(rtc_time.hour,rtc_time.min,rtc_time.sec); // off alarm time
ioctl(fd,AM_PMU_POFF,&pm_arg);
close(fd);
while(1){
sleep(1);
tm_get_rtc(&rtc_date,&rtc_time);
rtc_print(&rtc_date,&rtc_time);
if(rtc_time.min-TEST_DEFAULT_MIN>0)
break;
}
#elif TEST_POWER_MODE==TEST_SYS_DPOWER
fd = open(PMU_DEV_PATH,O_RDWR);
if(fd==-1){
printf("can not open pmu device\n");
exit(-19);
}
for(i=0;i<0xffff;i++){
printf("enter low\n");
ioctl(fd,AM_PMU_PLOW,NULL);
sleep(1);
printf("enter high\n");
ioctl(fd,AM_PMU_PHIGH,NULL);
sleep(1);
}
close(fd);
#elif TEST_POWER_MODE==TEST_PM_NL
struct sockaddr_nl local; //local {user space}
struct sockaddr_nl kpeer; //peer {kernel space}
struct nl_msg message,kmsg;
int k_peer_len,rcv_len;
struct in_addr addr;
sock_fd = socket(AF_NETLINK,SOCK_RAW,PM_NETLINK_TEST);
if(sock_fd<0){
perror("create socket error!\n");
exit(-errno);
}
memset(&local,0,sizeof(local));
local.nl_family = AF_NETLINK;
local.nl_pid = getpid();
local.nl_groups = 0;
if(bind(sock_fd,(struct sockaddr *)&local,sizeof(local)) != 0){
perror("bind error\n");
exit(-1);
}
memset(&kpeer,0,sizeof(kpeer));
kpeer.nl_family = AF_NETLINK;
kpeer.nl_pid = 0;
kpeer.nl_groups = 0; //not in multicast
memset(&message,0,sizeof(message));
message.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(message.data));
message.hdr.nlmsg_flags = 0;
message.hdr.nlmsg_type = 0xAB;
message.hdr.nlmsg_pid = local.nl_pid;
message.data[0]=0xdd;
//send to kernel
printf("%d send msg to kernel\n",local.nl_pid);
sendto(sock_fd,&message,message.hdr.nlmsg_len,0,(struct sockaddr *)&kpeer,sizeof(kpeer));
while(1){
k_peer_len = sizeof(struct sockaddr_nl);
rcv_len = recvfrom(sock_fd,&kmsg,sizeof(kmsg),0,(struct sockaddr *)&kpeer,(socklen_t *)&k_peer_len);
printf("rec msg from kernel:%d,ret=%d\n",kmsg.data[0],rcv_len);
break;
}
#endif
exit(0);
}
/**
* Deploys satellite antennas
* @param param 1 realime, 0 debug time
* @return 1 success, 0 fails
*/
int thk_deploy_antenna(void *param)
{
#if (SCH_TASKDEPLOYMENT_VERBOSE>=1)
printf("\n[thk_deploy_antenna] Deploying TRX Antenna... \r\n");
//rtc_print(NULL);
#endif
//Realtime=1 DebugTime=0
unsigned int delay_dep_time, delay_rest_dep_time, delay_recheck_dep_time;
int mode= *( (int *)param );
if(mode)
{
// delay_dep_time = (THK_DEPLOY_TIME) / portTICK_RATE_MS;
// delay_rest_dep_time = (THK_REST_DEPLOY_TIME) / portTICK_RATE_MS;
// delay_recheck_dep_time = (THK_RECHECK_TIME) / portTICK_RATE_MS;
delay_dep_time = (THK_DEPLOY_TIME);
delay_rest_dep_time = (THK_REST_DEPLOY_TIME);
delay_recheck_dep_time = (THK_RECHECK_TIME);
}
else
{
// delay_dep_time = (600) / portTICK_RATE_MS;
// delay_rest_dep_time = (400) / portTICK_RATE_MS;
// delay_recheck_dep_time = (200) / portTICK_RATE_MS;
delay_dep_time = (600);
delay_rest_dep_time = (400);
delay_recheck_dep_time = (200);
}
//intentos quemando el nylon
int tries_indx = 0;
#if(SCH_ANTENNA_ONBOARD == 1)
{
for(tries_indx=1; tries_indx<=THK_MAX_TRIES_ANT_DEPLOY; tries_indx++)
{
#if (SCH_TASKDEPLOYMENT_VERBOSE>=2)
printf(" [Deploying] Attempt #%d\r\n", tries_indx);
#endif
PPC_ANT12_SWITCH=1;
PPC_ANT1_SWITCH=1;
PPC_ANT2_SWITCH=0;
//PPC_ANT1_SWITCH=0;
//PPC_ANT2_SWITCH=1;
// vTaskDelay(delay_dep_time); /* tiempo de intento ANT1 */
// vTaskDelay(delay_dep_time); /* tiempo de intento ANT1 */
__delay_ms(delay_dep_time);
ClrWdt();
__delay_ms(delay_dep_time);
PPC_ANT12_SWITCH=0;
PPC_ANT1_SWITCH=0;
PPC_ANT2_SWITCH=0;
// vTaskDelay(delay_rest_dep_time); /* tiempo de descanso */
__delay_ms(delay_rest_dep_time);
ClrWdt();
PPC_ANT12_SWITCH=1;
PPC_ANT1_SWITCH=0;
PPC_ANT2_SWITCH=1;
//PPC_ANT1_SWITCH=1;
//PPC_ANT2_SWITCH=0;
// vTaskDelay(delay_dep_time); /* tiempo de intento ANT2 */
// vTaskDelay(delay_dep_time); /* tiempo de intento ANT2 */
__delay_ms(delay_dep_time);
ClrWdt();
__delay_ms(delay_dep_time);
PPC_ANT12_SWITCH=0;
PPC_ANT1_SWITCH=0;
PPC_ANT2_SWITCH=0;
// vTaskDelay(delay_rest_dep_time); /* tiempo de descanso */
__delay_ms(delay_rest_dep_time);
ClrWdt();
if( thk_get_AntSwitch_isOpen(&delay_recheck_dep_time) == 1 )
{
thk_deployment_registration(&tries_indx);
#if (SCH_TASKDEPLOYMENT_VERBOSE>=1)
printf(" ANTENNA DEPLOYED SUCCESSFULLY [%d TRIES]\r\n", tries_indx);
rtc_print(NULL);
#endif
return 1;
}
}
}
#endif
//after the for() tries_indx == THK_MAX_TRIES_ANT_DEPLOY+1
tries_indx = THK_MAX_TRIES_ANT_DEPLOY+1; //por si acaso
thk_deployment_registration(&tries_indx);
#if (SCH_TASKDEPLOYMENT_VERBOSE>=2)
printf(" ANTENNA DEPLOY FAIL [%d TRIES]\r\n", THK_MAX_TRIES_ANT_DEPLOY);
rtc_print(NULL);
#endif
return 0;
}
//
//int thk_set_dep_ant_deployed(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_ant_deployed;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_ant_tries(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_ant_tries;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_year(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_year;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_month(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_month;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_week_day(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_week_day;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_day_number(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_day_number;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_hours(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_hours;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_minutes(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_minutes;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//int thk_set_dep_seconds(void* param){
// MemEEPROM_Vars mem_eeprom_var = mem_dep_seconds;
// int value = *((int*)param);
// writeIntEEPROM1(mem_eeprom_var, value);
// return 1; //se asume operacion exitosa
//}
//------------------------------------------------------------------------------
int thk_suchai_deployment(void *param)
{
printf("[thk_suchai_deployment] Suchai deployment routine..\r\n");
int delay_min = *( (int*)param );
// portTickType xLastWakeTime = xTaskGetTickCount();
// portTickType delay_60s = 60000; //Task period in [ms]
// portTickType delay_tick_60s = delay_60s / portTICK_RATE_MS; //Task period in ticks
unsigned long initial_tick_10ms = xTaskGetTickCount(); //get initial tick-time
//unsigned long silent_time_10ms = (180000); // 30 minutes = 1800 sec = 180000 [10ms]
unsigned long silent_time_10ms = delay_min*60*100; // time_s*100 [ms] = time_ms
unsigned long final_tick_10ms = initial_tick_10ms + silent_time_10ms;
printf("[thk_suchai_deployment] initial_tick_10ms = %lu | final_tick_10ms = %lu \r\n", initial_tick_10ms, final_tick_10ms);
// print rtc time
rtc_print(NULL);
//take picture
#if(SCH_PAY_CAM_nMEMFLASH_ONBOARD==1 )
#if(SCH_THK_SILENT_REALTIME==1)
pay_takePhoto_camera(NULL); //takes 10min to complete
#else
printf(" Jumping pay_takePhoto_camera(NULL) call, it takes 10min to complete ..\r\n");
#endif
#endif
// print rtc time
rtc_print(NULL);
unsigned int elapsed_mins = 0;
while(TRUE){
unsigned long int cu_tick_10ms = xTaskGetTickCount();
if( cu_tick_10ms >= final_tick_10ms || elapsed_mins>35 ){
printf("[thk_suchai_deployment] Waiting timeout, cu_tick_10ms = %lu, elapsed_mins = %d\r\n", cu_tick_10ms, elapsed_mins);
break;
}
printf("[thk_suchai_deployment] Waiting for timeout, cu_tick_10ms = %lu, elapsed_mins = %d\r\n", cu_tick_10ms, elapsed_mins);
//vTaskDelayUntil(&xLastWakeTime, delay_tick_60s); //Suspend task 60 sec
ClrWdt();
__delay_ms(60000); //delay 60sec
elapsed_mins++;
}
// print rtc time
rtc_print(NULL);
/* Deploy Antena */
#if (SCH_ANTENNA_ONBOARD==1)
int rt_mode = SCH_THK_ANT_DEP_REALTIME; /* 1=Real Time, 0=Debug Time */
thk_deploy_antenna(&rt_mode);
#endif
// print rtc time
rtc_print(NULL);
ClrWdt();
__delay_ms(60000); //delay 60sec to avoid drain-out the EPS
/* Ceploy langmuir should NOT be here, but there is no way
* to check deployment, so its included here */
#if (SCH_ANTENNA_ONBOARD==1 && SCH_PAY_LANGMUIR_ONBOARD==1)
if( sta_get_stateVar(sta_pay_lagmuirProbe_isDeployed)==0 ){
int rt_mode = SCH_THK_ANT_DEP_REALTIME; /* 1=Real Time, 0=Debug Time */
pay_deploy_langmuirProbe(rt_mode); //realtime mode
//set var lang dep = 1
}
#endif
//other "only once"-tasks
//..
return 1;
}
