void t7(int pi) { int c, oc, id; printf("Watchdog tests.\n"); /* type of edge shouldn't matter for watchdogs */ id = callback(pi, GPIO, FALLING_EDGE, t7cbf); set_watchdog(pi, GPIO, 50); /* 50 ms, 20 per second */ time_sleep(0.5); oc = t7_count; time_sleep(2); c = t7_count - oc; CHECK(7, 1, c, 39, 5, "set watchdog on count"); set_watchdog(pi, GPIO, 0); /* 0 switches watchdog off */ time_sleep(0.5); oc = t7_count; time_sleep(2); c = t7_count - oc; CHECK(7, 2, c, 0, 1, "set watchdog off count"); callback_cancel(id); }
void t6() { int tp, t, p; printf("Trigger tests.\n"); gpio_write(GPIO, PI_LOW); tp = 0; callback(GPIO, EITHER_EDGE, t6cbf); time_sleep(0.2); for (t=0; t<5; t++) { time_sleep(0.1); p = 10 + (t*10); tp += p; gpio_trigger(GPIO, p, 1); } time_sleep(0.5); CHECK(6, 1, t6_count, 5, 0, "gpio trigger count"); CHECK(6, 2, t6_on, tp, 25, "gpio trigger pulse length"); }
void t2() { int f, r, rr, oc; printf("PWM dutycycle/range/frequency tests.\n"); set_PWM_range(GPIO, 255); set_PWM_frequency(GPIO, 0); f = get_PWM_frequency(GPIO); CHECK(2, 1, f, 10, 0, "set PWM range, set/get PWM frequency"); callback(GPIO, EITHER_EDGE, t2cb); set_PWM_dutycycle(GPIO, 0); time_sleep(0.5); /* allow old notifications to flush */ oc = t2_count; time_sleep(2); f = t2_count - oc; CHECK(2, 2, f, 0, 0, "set PWM dutycycle, callback"); set_PWM_dutycycle(GPIO, 128); oc = t2_count; time_sleep(2); f = t2_count - oc; CHECK(2, 3, f, 40, 5, "set PWM dutycycle, callback"); set_PWM_frequency(GPIO, 100); f = get_PWM_frequency(GPIO); CHECK(2, 4, f, 100, 0, "set/get PWM frequency"); oc = t2_count; time_sleep(2); f = t2_count - oc; CHECK(2, 5, f, 400, 1, "callback"); set_PWM_frequency(GPIO, 1000); f = get_PWM_frequency(GPIO); CHECK(2, 6, f, 1000, 0, "set/get PWM frequency"); oc = t2_count; time_sleep(2); f = t2_count - oc; CHECK(2, 7, f, 4000, 1, "callback"); r = get_PWM_range(GPIO); CHECK(2, 8, r, 255, 0, "get PWM range"); rr = get_PWM_real_range(GPIO); CHECK(2, 9, rr, 200, 0, "get PWM real range"); set_PWM_range(GPIO, 2000); r = get_PWM_range(GPIO); CHECK(2, 10, r, 2000, 0, "set/get PWM range"); rr = get_PWM_real_range(GPIO); CHECK(2, 11, rr, 200, 0, "get PWM real range"); set_PWM_dutycycle(GPIO, 0); }
void t3(int pi) { int pw[3]={500, 1500, 2500}; int dc[4]={20, 40, 60, 80}; int f, rr, v; float on, off; int t, id; printf("PWM/Servo pulse accuracy tests.\n"); id = callback(pi, GPIO, EITHER_EDGE, t3cbf); for (t=0; t<3; t++) { set_servo_pulsewidth(pi, GPIO, pw[t]); v = get_servo_pulsewidth(pi, GPIO); CHECK(3, t+t+1, v, pw[t], 0, "get servo pulsewidth"); time_sleep(1); t3_reset = 1; time_sleep(4); on = t3_on; off = t3_off; CHECK(3, t+t+2, (1000.0*(on+off))/on, 20000000.0/pw[t], 1, "set servo pulsewidth"); } set_servo_pulsewidth(pi, GPIO, 0); set_PWM_frequency(pi, GPIO, 1000); f = get_PWM_frequency(pi, GPIO); CHECK(3, 7, f, 1000, 0, "set/get PWM frequency"); rr = set_PWM_range(pi, GPIO, 100); CHECK(3, 8, rr, 200, 0, "set PWM range"); for (t=0; t<4; t++) { set_PWM_dutycycle(pi, GPIO, dc[t]); v = get_PWM_dutycycle(pi, GPIO); CHECK(3, t+t+9, v, dc[t], 0, "get PWM dutycycle"); time_sleep(1); t3_reset = 1; time_sleep(2); on = t3_on; off = t3_off; CHECK(3, t+t+10, (1000.0*on)/(on+off), 10.0*dc[t], 1, "set PWM dutycycle"); } set_PWM_dutycycle(pi, GPIO, 0); callback_cancel(id); }
void t3() { int pw[3]={500, 1500, 2500}; int dc[4]={20, 40, 60, 80}; int f, rr; float on, off; int t; printf("PWM/Servo pulse accuracy tests.\n"); callback(GPIO, EITHER_EDGE, t3cbf); for (t=0; t<3; t++) { set_servo_pulsewidth(GPIO, pw[t]); time_sleep(1); t3_reset = 1; time_sleep(4); on = t3_on; off = t3_off; CHECK(3, 1+t, (1000.0*(on+off))/on, 20000000.0/pw[t], 1, "set servo pulsewidth"); } set_servo_pulsewidth(GPIO, 0); set_PWM_frequency(GPIO, 1000); f = get_PWM_frequency(GPIO); CHECK(3, 4, f, 1000, 0, "set/get PWM frequency"); rr = set_PWM_range(GPIO, 100); CHECK(3, 5, rr, 200, 0, "set PWM range"); for (t=0; t<4; t++) { set_PWM_dutycycle(GPIO, dc[t]); time_sleep(1); t3_reset = 1; time_sleep(2); on = t3_on; off = t3_off; CHECK(3, 6+t, (1000.0*on)/(on+off), 10.0*dc[t], 1, "set PWM dutycycle"); } set_PWM_dutycycle(GPIO, 0); }
/* Get the number of cmd available and version num */ char cmdGet(void){ if(cmdGeneric(0x00)){ unsigned char len = uart_read(); unsigned char ver = uart_read(); unsigned char * buff = (unsigned char *) malloc(sizeof(unsigned char) * (len+1)); uart_reads(buff, len); buff[len] = '\0'; for(int i=0; i<len; i++){ if(0x44 == buff[i]){ extendedErase = 1; } } time_sleep(0.1); int ok = wait_for_ask(); /* if(ok){mdebug(0, "cmd get ok\n");} else {mdebug(0, "cmd get failed\n");} */ return ver; } else{ /* TODO: what to do if receive nack? */ handle_error(NACK_ERROR); return 0; } }
void tc(int pi) { int h, x, b, e; char buf[128]; printf("SPI tests."); /* this test requires a MCP3202 on SPI channel 1 */ h = spi_open(pi, 1, 50000, 0); CHECK(12, 1, h, 0, 0, "spi open"); for (x=0; x<5; x++) { sprintf(buf, "\x01\x80"); b = spi_xfer(pi, h, buf, buf, 3); CHECK(12, 2, b, 3, 0, "spi xfer"); if (b == 3) { time_sleep(1.0); printf("%d ", ((buf[1]&0x0F)*256)|buf[2]); } } e = spi_close(pi, h); CHECK(12, 99, e, 0, 0, "spi close"); }
/* Wait for nack or ack response */ int wait_for_ask(void){ /* wait for ask */ time_sleep(0.2); //need this in here :( unsigned char ask = uart_read(); /* TODO: what to do if timeout? */ if(uart_timeout()){ /* Timeout handler here */ handle_error(TIMEOUT_ERROR); return 0; } else{ if(ask == 0x79){ /* ACK */ return 1; } else{ if(ask == 0x1F){ /* NACK */ /* TODO: how are we going to handle nack? */ handle_error(NACK_ERROR); return 0; } else{ /* Unknown response */ /* TODO: how are we going to handle unknown response */ handle_error(UNKNOWN_ERROR); return 0; } } } return 0; /* should not get here */ }
/* Generic cmd routine - use this for high level cmds */ int cmdGeneric(unsigned char c){ unsigned char cmd[2]; cmd[0] = c; cmd[1] = c ^ 0xFF; uart_write(cmd, 2); /* Control cmd byte */ time_sleep(0.01); return wait_for_ask(); }
void SetMTX2Frequency(char *FrequencyString) { float _mtx2comp; int _mtx2int; long _mtx2fractional; char _mtx2command[17]; int fd; double Frequency; int i, pulses, wave_id; char *str; if (strlen(FrequencyString) < 3) { // Convert channel number to frequency Frequency = strtol(FrequencyString, NULL, 16) * 0.003125 + 434.05; printf("Channel %s\n", FrequencyString); } else { Frequency = atof(FrequencyString); printf("Frequency %s\n", FrequencyString); } printf("MTX2 Frequency to be set to %8.4fMHz\n", Frequency); _mtx2comp=(Frequency+0.0015)/6.5; _mtx2int=_mtx2comp; _mtx2fractional = ((_mtx2comp-_mtx2int)+1) * 524288; snprintf(_mtx2command,17,"@PRG_%02X%06lX\r",_mtx2int-1, _mtx2fractional); printf("MTX2 command is %s\n", _mtx2command); if (gpioInitialise() < 0) { printf("pigpio initialisation failed.\n"); return; } gpioSetMode(NTX2B_ENABLE_BCM, PI_OUTPUT); gpioWaveAddNew(); gpioWaveAddSerial(NTX2B_ENABLE_BCM, 9600, 8, 2, 0, strlen(_mtx2command), _mtx2command); wave_id = gpioWaveCreate(); if (wave_id >= 0) { gpioWaveTxSend(wave_id, 0); while (gpioWaveTxBusy()) { time_sleep(0.1); } } gpioTerminate(); }
static void view_idle(void) { if(V.redraw) { V.redraw = false; glutPostRedisplay(); } time_sleep(0.1f); }
/* * sleep() * Suspend execution the given amount of time */ uint sleep(uint secs) { struct time t; time_get(&t); t.t_sec += secs; time_sleep(&t); return(0); }
/* * usleep() * Like sleep, but in microseconds */ __usleep(uint usecs) { struct time t; time_get(&t); t.t_usec += usecs; while (t.t_usec > 1000000) { t.t_sec += 1; t.t_usec -= 1000000; } time_sleep(&t); return(0); }
void t7() { int c, oc; printf("Watchdog tests.\n"); /* type of edge shouldn't matter for watchdogs */ callback(GPIO, FALLING_EDGE, t7cbf); set_watchdog(GPIO, 10); /* 10 ms, 100 per second */ time_sleep(0.5); oc = t7_count; time_sleep(2); c = t7_count - oc; CHECK(7, 1, c, 200, 1, "set watchdog on count"); set_watchdog(GPIO, 0); /* 0 switches watchdog off */ time_sleep(0.5); oc = t7_count; time_sleep(2); c = t7_count - oc; CHECK(7, 2, c, 0, 1, "set watchdog off count"); }
int initChip(void){ /* Set boot */ uart_set_rts(0); reset(); unsigned char cmd[] = {0x7F}; uart_write(cmd, 1); /* tell bootloader to startup */ time_sleep(0.1); //need this for some reason int ok = wait_for_ask(); if(ok){ mdebug(0, "init success"); } else{ mdebug(0, "init failed"); } return ok; }
int wait_for_edge(unsigned user_gpio, unsigned edge, double timeout) { int triggered = 0; int id; double due; if (timeout <= 0.0) return 0; due = time_time() + timeout; id = callback_ex(user_gpio, edge, _wfe, &triggered); while (!triggered && (time_time() < due)) time_sleep(0.1); callback_cancel(id); return triggered; }
int getCM(int Sensor) { int trig = Trigs[Sensor]; int echo = Echos[Sensor]; //Send Trig pulse gpioWrite(trig, PI_HIGH); time_sleep(0.00001); gpioWrite(trig, PI_LOW); //Wait for Echo start while(gpioRead(echo) == PI_LOW); //Wait for Echos end long startTime = micros(); while(gpioRead(echo) == PI_HIGH && micros() - startTime < 5800 ); long travelTime = micros() - startTime; //Get distance in cm int distance = travelTime / 58; return distance; }
int wait_for_edge(int pi, unsigned user_gpio, unsigned edge, double timeout) { int triggered = 0; int id; double due; if ((pi < 0) || (pi >= MAX_PI) || !gPiInUse[pi]) return pigif_unconnected_pi; if (timeout <= 0.0) return 0; due = time_time() + timeout; id = callback_ex(pi, user_gpio, edge, _wfe, &triggered); while (!triggered && (time_time() < due)) time_sleep(0.05); callback_cancel(id); return triggered; }
// returns 1 if child exited, else 0 static int wait_for_child_gone() { struct timeval beg_time = time_now(); struct timeval sleep_time = {0, 1000}; int status; int timeout = 0; while(!timeout) { pid_t pid = gdb_pid(); pid_t wpid = waitpid(pid, &status, WNOHANG); if(wpid == pid) // child done break; // wait a little time_sleep(&sleep_time); struct timeval now_time = time_now(); struct timeval wait_time = time_sub(&now_time, &beg_time); if(time_greater(&wait_time, &wait_timeout)) timeout = 1; } if(timeout) return 0; return 1; }
void cmdExtendedEraseMemory(void){ if(cmdGeneric(0x44)){ mdebug(10, "*** Extended Erase memory command"); /* Global mass erase */ unsigned char cmd[] = {0xFF}; uart_write(cmd, 1); uart_write(cmd, 1); /* Checksum */ cmd[0] = 0x00; uart_write(cmd, 1); int tmp = get_uart_timeout(); //set_uart_timeout(30); time_sleep(10); //can take 30 sec /* Extended erase (0x44), can take ten seconds or more */ wait_for_ask(); set_uart_timeout(tmp); /* set back to default */ mdebug(10, " Extended Erase memory done"); } else{ /* TODO: handle nack */ handle_error(NACK_ERROR); } }
void tw2_stack_review (void) { unsigned int i=0; char *ps; NODE2* sb; sb = StackTW->bottom; if (!sb) { printf ("** 번역된 문장이 없습니다.\n"); return; } while (true) { if (!StackTW->bottom) StackTW->bottom = sb; //계속 반복 ps = (char*)stack_bottom (StackTW, FLAG_VIEW); printf ("%s\n", ps); time_sleep (str_len (ps) / 10); //문장길이에 따라서 대기 if (!(++i%8) && tw1_qn_answer ("* Would you like to see more? [Y/n] ", FLAG_YES) == FLAG_NO) break; } StackTW->bottom = sb; }
int main(int argc, char *argv[]) { char *recv_buf = (char *)malloc(MAX); char addr_buf[MAX]; socklen_t len; struct sockaddr_in server_addr; struct sockaddr_in client_addr; memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htons(INADDR_ANY); server_addr.sin_port = htons(PORT); int client_socket; int server_socket = socket(AF_INET, SOCK_STREAM, 0); if (server_socket == -1) { perror("Failed to create socket\n"); exit(1); } if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) { perror("Failed to bind\n"); exit(2); } if (listen(server_socket, 10) == -1) { perror("Failed to listen\n"); exit(3); } printf("waiting...\n"); //通过socket获取客户的请求 while (1) { if ((client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &len)) == -1) { perror("Failed to accept\n"); exit(4); } printf("Client %s connencting by %d port.\n", inet_ntoa(client_addr.sin_addr), htons(client_addr.sin_port)); //创建子进程来处理客户的请求 pid_t pid; pid = fork(); switch (pid) { case -1: perror("Fork failed\n"); exit(6); case 0: { int length = recv(client_socket, recv_buf, MAX, 0); if (length < 0) { perror("Failed to recv\n"); exit(5); } char *client_str = recv_buf; char *client_command = strsep(&client_str, ","); //client_command返回客户的请求“1”,“2”或“3” printf("client command is %s\n", client_command); //客户请求天气信息的处理(client_command = 1) if (strcmp(client_command, "1") == 0) { char *client_str23 = client_str; //client_str = "beijing,10:20:01" char *city_name = strsep(&client_str23, ","); //city_name = "beijing" char* client_time = client_str23; //client_str3 ="10:20:01" printf("city_name %s , %s\n", city_name, client_time); char *client_time_hour = strsep(&client_time, ":"); //hour = 10 char *client_time_min = strsep(&client_time, ":"); //minute = 20 char *client_time_sec = client_time; //second = 01 int tm_sleep = time_sleep(atoi(client_time_hour),atoi(client_time_min), atoi(client_time_sec)); char* com = (char *)malloc(30); strcpy(com, "./weather "); strcat(com, city_name); //利用函数time_sleep()的返回值来为客户定时显示天气信息 usleep(1000000*tm_sleep); system(com); free(com); } //客户请求微博信息的处理(client_command = 2) if (strcmp(client_command, "2") == 0) { char *nickname = client_str; printf("nickname: %s\n", nickname); char *com = (char *)malloc(30); strcpy(com, "./send_weibo.py "); strcat(com, nickname); system(com); free(com); } //客户请求新闻信息的处理(client_command = 3) if (strcmp(client_command, "3") == 0) { //system("python GetNews.py"); execlp("/home/yang/C++/test_client/GetNews.py","GetNews.py",(char*)0); } break; } } } exit(0); }
void t9(int pi) { int s, oc, c, e, id; uint32_t p[10]; printf("Script store/run/status/stop/delete tests.\n"); gpio_write(pi, GPIO, 0); /* need known state */ /* 100 loops per second p0 number of loops p1 GPIO */ char *script="\ ld p9 p0\ tag 0\ w p1 1\ mils 5\ w p1 0\ mils 5\ dcr p9\ jp 0"; id = callback(pi, GPIO, RISING_EDGE, t9cbf); s = store_script(pi, script); /* Wait for script to finish initing. */ while (1) { time_sleep(0.1); e = script_status(pi, s, p); if (e != PI_SCRIPT_INITING) break; } oc = t9_count; p[0] = 99; p[1] = GPIO; run_script(pi, s, 2, p); time_sleep(2); c = t9_count - oc; CHECK(9, 1, c, 100, 0, "store/run script"); oc = t9_count; p[0] = 200; p[1] = GPIO; run_script(pi, s, 2, p); while (1) { time_sleep(0.1); e = script_status(pi, s, p); if (e != PI_SCRIPT_RUNNING) break; } c = t9_count - oc; time_sleep(0.1); CHECK(9, 2, c, 201, 0, "run script/script status"); oc = t9_count; p[0] = 2000; p[1] = GPIO; run_script(pi, s, 2, p); while (1) { time_sleep(0.1); e = script_status(pi, s, p); if (e != PI_SCRIPT_RUNNING) break; if (p[9] < 1600) stop_script(pi, s); } c = t9_count - oc; time_sleep(0.1); CHECK(9, 3, c, 410, 10, "run/stop script/script status"); e = delete_script(pi, s); CHECK(9, 4, e, 0, 0, "delete script"); callback_cancel(id); }
void ta(int pi) { int h, b, e; char *TEXT; char text[2048]; printf("Serial link tests.\n"); /* this test needs RXD and TXD to be connected */ h = serial_open(pi, "/dev/ttyAMA0", 57600, 0); CHECK(10, 1, h, 0, 0, "serial open"); time_sleep(0.1); /* allow time for transmission */ b = serial_read(pi, h, text, sizeof(text)); /* flush buffer */ b = serial_data_available(pi, h); CHECK(10, 2, b, 0, 0, "serial data available"); TEXT = "\ To be, or not to be, that is the question-\ Whether 'tis Nobler in the mind to suffer\ The Slings and Arrows of outrageous Fortune,\ Or to take Arms against a Sea of troubles,\ "; e = serial_write(pi, h, TEXT, strlen(TEXT)); CHECK(10, 3, e, 0, 0, "serial write"); e = serial_write_byte(pi, h, 0xAA); e = serial_write_byte(pi, h, 0x55); e = serial_write_byte(pi, h, 0x00); e = serial_write_byte(pi, h, 0xFF); CHECK(10, 4, e, 0, 0, "serial write byte"); time_sleep(0.1); /* allow time for transmission */ b = serial_data_available(pi, h); CHECK(10, 5, b, strlen(TEXT)+4, 0, "serial data available"); b = serial_read(pi, h, text, strlen(TEXT)); CHECK(10, 6, b, strlen(TEXT), 0, "serial read"); if (b >= 0) text[b] = 0; CHECK(10, 7, strcmp(TEXT, text), 0, 0, "serial read"); b = serial_read_byte(pi, h); CHECK(10, 8, b, 0xAA, 0, "serial read byte"); b = serial_read_byte(pi, h); CHECK(10, 9, b, 0x55, 0, "serial read byte"); b = serial_read_byte(pi, h); CHECK(10, 10, b, 0x00, 0, "serial read byte"); b = serial_read_byte(pi, h); CHECK(10, 11, b, 0xFF, 0, "serial read byte"); b = serial_data_available(pi, h); CHECK(10, 12, b, 0, 0, "serial data availabe"); e = serial_close(pi, h); CHECK(10, 13, e, 0, 0, "serial close"); }
void reset(void){ uart_set_dtr(0); time_sleep(0.1); uart_set_dtr(1); time_sleep(0.5); }
void t4() { int h, e, f, n, s, b, l, seq_ok, toggle_ok; gpioReport_t r; char p[32]; printf("Pipe notification tests.\n"); set_PWM_frequency(GPIO, 0); set_PWM_dutycycle(GPIO, 0); set_PWM_range(GPIO, 100); h = notify_open(); e = notify_begin(h, (1<<4)); CHECK(4, 1, e, 0, 0, "notify open/begin"); time_sleep(1); sprintf(p, "/dev/pigpio%d", h); f = open(p, O_RDONLY); set_PWM_dutycycle(GPIO, 50); time_sleep(4); set_PWM_dutycycle(GPIO, 0); e = notify_pause(h); CHECK(4, 2, e, 0, 0, "notify pause"); e = notify_close(h); CHECK(4, 3, e, 0, 0, "notify close"); n = 0; s = 0; l = 0; seq_ok = 1; toggle_ok = 1; while (1) { b = read(f, &r, 12); if (b == 12) { if (s != r.seqno) seq_ok = 0; if (n) if (l != (r.level&(1<<4))) toggle_ok = 0; if (r.level&(1<<4)) l = 0; else l = (1<<4); s++; n++; // printf("%d %d %d %X\n", r.seqno, r.flags, r.tick, r.level); } else break; } close(f); CHECK(4, 4, seq_ok, 1, 0, "sequence numbers ok"); CHECK(4, 5, toggle_ok, 1, 0, "gpio toggled ok"); CHECK(4, 6, n, 80, 10, "number of notifications"); }
void t5() { int BAUD=4800; char *TEXT= "\n\ Now is the winter of our discontent\n\ Made glorious summer by this sun of York;\n\ And all the clouds that lour'd upon our house\n\ In the deep bosom of the ocean buried.\n\ Now are our brows bound with victorious wreaths;\n\ Our bruised arms hung up for monuments;\n\ Our stern alarums changed to merry meetings,\n\ Our dreadful marches to delightful measures.\n\ Grim-visaged war hath smooth'd his wrinkled front;\n\ And now, instead of mounting barded steeds\n\ To fright the souls of fearful adversaries,\n\ He capers nimbly in a lady's chamber\n\ To the lascivious pleasing of a lute.\n\ "; gpioPulse_t wf[] = { {1<<GPIO, 0, 10000}, {0, 1<<GPIO, 30000}, {1<<GPIO, 0, 60000}, {0, 1<<GPIO, 100000}, }; int e, oc, c; char text[2048]; printf("Waveforms & serial read/write tests.\n"); callback(GPIO, FALLING_EDGE, t5cbf); set_mode(GPIO, PI_OUTPUT); e = wave_clear(); CHECK(5, 1, e, 0, 0, "callback, set mode, wave clear"); e = wave_add_generic(4, wf); CHECK(5, 2, e, 4, 0, "pulse, wave add generic"); e = wave_tx_repeat(); CHECK(5, 3, e, 9, 0, "wave tx repeat"); oc = t5_count; time_sleep(5); c = t5_count - oc; CHECK(5, 4, c, 50, 1, "callback"); e = wave_tx_stop(); CHECK(5, 5, e, 0, 0, "wave tx stop"); e = serial_read_open(GPIO, BAUD); CHECK(5, 6, e, 0, 0, "serial read open"); wave_clear(); e = wave_add_serial(GPIO, BAUD, 5000000, strlen(TEXT), TEXT); CHECK(5, 7, e, 3405, 0, "wave clear, wave add serial"); e = wave_tx_start(); CHECK(5, 8, e, 6811, 0, "wave tx start"); oc = t5_count; time_sleep(3); c = t5_count - oc; CHECK(5, 9, c, 0, 0, "callback"); oc = t5_count; while (wave_tx_busy()) time_sleep(0.1); time_sleep(0.1); c = t5_count - oc; CHECK(5, 10, c, 1702, 0, "wave tx busy, callback"); c = serial_read(GPIO, text, sizeof(text)-1); if (c > 0) text[c] = 0; /* null terminate string */ CHECK(5, 11, strcmp(TEXT, text), 0, 0, "wave tx busy, serial read"); e = serial_read_close(GPIO); CHECK(5, 12, e, 0, 0, "serial read close"); c = wave_get_micros(); CHECK(5, 13, c, 6158704, 0, "wave get micros"); c = wave_get_high_micros(); CHECK(5, 14, c, 6158704, 0, "wave get high micros"); c = wave_get_max_micros(); CHECK(5, 15, c, 1800000000, 0, "wave get max micros"); c = wave_get_pulses(); CHECK(5, 16, c, 3405, 0, "wave get pulses"); c = wave_get_high_pulses(); CHECK(5, 17, c, 3405, 0, "wave get high pulses"); c = wave_get_max_pulses(); CHECK(5, 18, c, 12000, 0, "wave get max pulses"); c = wave_get_cbs(); CHECK(5, 19, c, 6810, 0, "wave get cbs"); c = wave_get_high_cbs(); CHECK(5, 20, c, 6810, 0, "wave get high cbs"); c = wave_get_max_cbs(); CHECK(5, 21, c, 25016, 0, "wave get max cbs"); }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Render loop ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void Session::run_render() { reset_time = start_time = time_dt(); paused_time = 0.0; bool bStarted = false; params.image_stat.uiCurSamples = 0; if(params.interactive) progress.set_start_time(start_time); bool is_done = false; while(!progress.get_cancel()) { if(!params.interactive) { // If no work left and in background mode, we can stop immediately if(is_done) { update_status_time(); progress.set_status(string(pass_name) + " finished"); break; } } //if(!params.interactive) else { // If in interactive mode, and we are either paused or done for now, // wait for pause condition notify to wake up again thread_scoped_lock pause_lock(pause_mutex); if(pause || is_done) { update_status_time(pause, is_done); while(true) { if(pause) server->pauseRender(true); double pause_start = time_dt(); pause_cond.wait(pause_lock); paused_time += time_dt() - pause_start; progress.set_start_time(start_time + paused_time); update_status_time(pause, is_done); progress.set_update(); if(!pause) { server->pauseRender(false); break; } } } //if(pause || is_ready) if(progress.get_cancel()) break; } //if(!params.interactive), else if(!is_done) { time_sleep(0.01); // Update scene on the render-server - send all changed objects if(!bStarted || params.interactive) update_scene_to_server(frame_idx, total_frames); if(!bStarted) { server->startRender(params.interactive, params.width, params.height, params.interactive ? ::OctaneEngine::OctaneClient::IMAGE_8BIT : (params.hdr_tonemapped ? ::OctaneEngine::OctaneClient::IMAGE_FLOAT_TONEMAPPED : ::OctaneEngine::OctaneClient::IMAGE_FLOAT), params.out_of_core_enabled, params.out_of_core_mem_limit, params.out_of_core_gpu_headroom); //FIXME: Perhaps the wrong place for it... bStarted = true; } if(!server->getServerErrorMessage().empty()) { progress.set_cancel("ERROR! Check console for detailed error messages."); server->clearServerErrorMessage(); } if(progress.get_cancel()) break; // Buffers mutex is locked entirely while rendering each // sample, and released/reacquired on each iteration to allow // reset and draw in between thread_scoped_lock buffers_lock(render_buffer_mutex); // Update status and timing //update_status_time(); update_render_buffer(); if(!server->getServerErrorMessage().empty()) { progress.set_cancel("ERROR! Check console for detailed error messages."); server->clearServerErrorMessage(); } // Update status and timing update_status_time(); progress.set_update(); } //if(!is_done) else { thread_scoped_lock buffers_lock(render_buffer_mutex); update_render_buffer(); // Update status and timing update_status_time(); } is_done = !params.interactive && (params.image_stat.uiCurSamples >= params.samples); } //while(!progress.get_cancel()) } //run_render()
void pwrmgr_update() { bool idle = false; LOOPR(PWR_ACTIVE_COUNT, i) { if(active[i] == PWR_STATE_BSY) // Something busy, no sleep stuff return; else if(active[i] == PWR_STATE_IDLE) idle = true; } bool buttonsActive = buttons_isActive(); if(idle || buttonsActive) { if(systemState == SYS_CRTANIM && buttonsActive) // Cancel CRT anim if a button is pressed { display_startCRTAnim(DISPLAY_CRTANIM_OPEN); systemState = SYS_AWAKE; } else // Idle sleep mode { debugPin_sleepIdle(HIGH); sleep_mode(); debugPin_sleepIdle(LOW); } } else { if(systemState == SYS_AWAKE) // Begin CRT anim { systemState = SYS_CRTANIM; display_startCRTAnim(DISPLAY_CRTANIM_CLOSE); } else if(systemState == SYS_CRTANIM) { // Shutdown if(userState == USER_ACTIVE) userSleep(); systemState = SYS_SLEEP; set_sleep_mode(SLEEP_MODE_PWR_DOWN); time_sleep(); debugPin_sleepPowerDown(HIGH); // need to make sure no interrupts fired here! cli(); sleep_enable(); sleep_bod_disable(); sei(); sleep_cpu(); sleep_disable(); debugPin_sleepPowerDown(LOW); systemState = SYS_AWAKE; if(time_wake() != RTCWAKE_SYSTEM) // Woken by button press, USB plugged in or by RTC user alarm userWake(); set_sleep_mode(SLEEP_MODE_IDLE); } } }
void t9() { int s, oc, c, e; uint32_t p[10]; printf("Script store/run/status/stop/delete tests.\n"); gpio_write(GPIO, 0); /* need known state */ /* 100 loops per second p0 number of loops p1 GPIO */ char *script="\ lda p0\ sta v0\ tag 0\ w p1 1\ mils 5\ w p1 0\ mils 5\ dcr v0\ lda v0\ sta p9\ jp 0"; callback(GPIO, RISING_EDGE, t9cbf); s = store_script(script); oc = t9_count; p[0] = 99; p[1] = GPIO; run_script(s, 2, p); time_sleep(2); c = t9_count - oc; CHECK(9, 1, c, 100, 0, "store/run script"); oc = t9_count; p[0] = 200; p[1] = GPIO; run_script(s, 2, p); while (1) { e = script_status(s, p); if (e != PI_SCRIPT_RUNNING) break; time_sleep(0.5); } c = t9_count - oc; time_sleep(0.1); CHECK(9, 2, c, 201, 0, "run script/script status"); oc = t9_count; p[0] = 2000; p[1] = GPIO; run_script(s, 2, p); while (1) { e = script_status(s, p); if (e != PI_SCRIPT_RUNNING) break; if (p[9] < 1900) stop_script(s); time_sleep(0.1); } c = t9_count - oc; time_sleep(0.1); CHECK(9, 3, c, 110, 10, "run/stop script/script status"); e = delete_script(s); CHECK(9, 4, e, 0, 0, "delete script"); }