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