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; }