/*---------------------------------------------------------------------------*/
static int
write_chunk_pt(struct rudolph0_conn *c, int offset, int flag,
uint8_t *data, int datalen)
{
PT_BEGIN(&recvnetfilept);
PT_WAIT_UNTIL(&recvnetfilept, receiving_file);
leds_on(LEDS_YELLOW);
leds_on(LEDS_RED);
PT_WAIT_UNTIL(&recvnetfilept, flag == RUDOLPH0_FLAG_NEWFILE);
leds_off(LEDS_RED);
do {
if(datalen > 0) {
shell_output(&recvnetfile_command, data, datalen, "", 0);
/* printf("write_chunk wrote %d bytes at %d\n", datalen, offset);*/
}
PT_YIELD(&recvnetfilept);
} while(flag != RUDOLPH0_FLAG_LASTCHUNK);
shell_output(&recvnetfile_command, data, datalen, "", 0);
/* printf("write_chunk wrote %d bytes at %d\n", datalen, offset);*/
shell_output(&recvnetfile_command, "", 0, "", 0);
leds_off(LEDS_YELLOW);
receiving_file = 0;
process_post(&shell_recvnetfile_process, PROCESS_EVENT_CONTINUE, NULL);
PT_END(&recvnetfilept);
}
static PT_THREAD(handle_connection(void))
{
PT_BEGIN(&s.pt);
s.state = STATE_LISTENING;
do {
PT_WAIT_UNTIL(&s.pt, uip_newdata());
if(uip_newdata() && parse_msg()) {
s.state = STATE_HELLO_RECEIVED;
uip_flags &= (~UIP_NEWDATA);
break;
}
} while(s.state != STATE_HELLO_RECEIVED);
do {
send_request();
PT_WAIT_UNTIL(&s.pt, uip_newdata());
if(uip_newdata()) {
s.state = STATE_NAME_RECEIVED;
uip_flags &= (~UIP_NEWDATA);
break;
}
} while(s.state != STATE_NAME_RECEIVED);
send_response();
s.state = STATE_INIT;
PT_END(&s.pt);
}
bool
Human::run()
{
PT_BEGIN();
while (1)
{
timer.restart(3000);
PT_WAIT_UNTIL(timer.isExpired());
for (i = 0; i < 2; i++)
{
state = WAVE0;
timer.restart(500);
PT_WAIT_UNTIL(timer.isExpired());
state = WAVE1;
timer.restart(500);
PT_WAIT_UNTIL(timer.isExpired());
}
state = STAND;
}
PT_END();
}
int DLGSM::PT_restart(struct pt *pt, char *ret) {
static struct pt child_pt;
static uint32_t timestamp;
static char u;
char iret;
PT_BEGIN(pt);
u = 0;
while (u < 3) {
_gsmserial.flush();
PT_WAIT_THREAD(pt, PT_send_recv_confirm(&child_pt, &iret, "AT\r\n", "OK", 1000));
if (iret > 0) {
PT_WAIT_THREAD(pt, PT_pwr_off(&child_pt, 1));
u = 3;
} else {
PT_WAIT_UNTIL(pt, (millis() - timestamp > 1000));
timestamp = millis();
u++;
if (_DEBUG) Serial.println(u, DEC);
}
}
timestamp = millis();
if (iret == 1)
PT_WAIT_THREAD(pt, PT_pwr_off(&child_pt, 0));
PT_WAIT_UNTIL(pt, (millis() - timestamp) > 6000);
PT_WAIT_THREAD(pt, PT_pwr_on(&child_pt));
PT_WAIT_THREAD(pt, PT_GSM_init(&child_pt, ret));
_error_cnt = 0;
_tout_cnt = 0;
u = 0;
*ret = 1;
PT_END(pt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_dhcp(void))
{
PT_BEGIN(&s.pt);
/* try_again:*/
s.state = STATE_SENDING;
s.ticks = CLOCK_SECOND;
do {
send_discover();
s.timer_init = platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_START, 0 );
PT_WAIT_UNTIL(&s.pt, uip_newdata() || platform_timer_get_diff_us( ELUA_DHCP_TIMER_ID, s.timer_init, platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_READ, 0 ) ) >= s.ticks );
if(uip_newdata() && parse_msg() == DHCPOFFER) {
uip_flags &= ~UIP_NEWDATA;
s.state = STATE_OFFER_RECEIVED;
break;
}
uip_flags &= ~UIP_NEWDATA;
if(s.ticks < CLOCK_SECOND * 60) {
s.ticks *= 2;
} else {
s.ipaddr[0] = 0;
goto dhcp_failed;
}
} while(s.state != STATE_OFFER_RECEIVED);
s.ticks = CLOCK_SECOND;
do {
send_request();
s.timer_init = platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_START, 0 );
PT_WAIT_UNTIL(&s.pt, uip_newdata() || platform_timer_get_diff_us( ELUA_DHCP_TIMER_ID, s.timer_init, platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_READ, 0 ) ) >= s.ticks );
if(uip_newdata() && parse_msg() == DHCPACK) {
uip_flags &= ~UIP_NEWDATA;
s.state = STATE_CONFIG_RECEIVED;
break;
}
uip_flags &= ~UIP_NEWDATA;
if(s.ticks <= CLOCK_SECOND * 10) {
s.ticks += CLOCK_SECOND;
} else {
PT_RESTART(&s.pt);
}
} while(s.state != STATE_CONFIG_RECEIVED);
dhcp_failed:
dhcpc_configured(&s);
/*
* PT_END restarts the thread so we do this instead. Eventually we
* should reacquire expired leases here.
*/
while(1) {
PT_YIELD(&s.pt);
}
PT_END(&s.pt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(temperature_thread(struct pt *pt))
{
PT_BEGIN(pt);
init_adc(5);
disable_digital_buffer(5);
while(1)
{
cli();
temperature_counter = 0;
sei();
PT_WAIT_UNTIL(pt,temperature_counter > 750);
temp_result = 0;
temp_sampl_cnt = 0;
for(temp_sampl_cnt = 0; temp_sampl_cnt < 64; temp_sampl_cnt++)
{
start_conversion();
PT_WAIT_UNTIL(pt,!is_adc_busy());
temp_result += read_adc();
}
dbg(PSTR("> ADC result: %u\r\n"),temp_result >> 6);
}
PT_END(pt);
}
static PT_THREAD( MNT_check_commands(pt_t* pt) )
{
mnt_event_t ev;
u8 swap;
PT_BEGIN(pt);
// as long as there are no command
PT_WAIT_UNTIL(pt, OK == FIFO_get(&MNT.cmds_fifo, &MNT.cmd_fr));
// silently ignore incoming response
if ( MNT.cmd_fr.resp == 1 ) {
DPT_unlock(&MNT.interf);
PT_RESTART(pt);
}
switch (MNT.cmd_fr.cmde) {
case FR_TAKE_OFF:
// generate take-off event
PT_WAIT_UNTIL(pt, (ev = MNT_EV_TAKE_OFF) && OK == FIFO_put(&MNT.ev_fifo, &ev) );
break;
case FR_MINUT_TIME_OUT:
MNT_open_time(&MNT.cmd_fr);
break;
case FR_STATE:
if ( (MNT.cmd_fr.argv[0] == 0x7a) || (MNT.cmd_fr.argv[0] == 0x8b) ) {
//MNT.state = MNT.cmd_fr.argv[1];
}
// don't respond, response will be done by CMN
PT_RESTART(pt);
break;
case FR_APPLI_START:
MNT.started = 1;
// don't respond
PT_RESTART(pt);
break;
default:
// shall never happen
break;
}
// build the response to the current command
swap = MNT.cmd_fr.orig;
MNT.cmd_fr.orig = MNT.cmd_fr.dest;
MNT.cmd_fr.dest = swap;
MNT.cmd_fr.resp = 1;
// enqueue it
PT_WAIT_UNTIL(pt, OK == FIFO_put(&MNT.out_fifo, &MNT.cmd_fr));
PT_RESTART(pt);
PT_END(pt);
}
static u8 init_action(pt_t* pt, void* args)
{
frame_t fr;
PT_BEGIN(pt);
// signal init state
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_STATE, 0, FR_STATE_SET, FR_STATE_INIT)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde cone stop
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_CONE, FR_SERVO_OFF)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde aero stop
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_AERO, FR_SERVO_OFF)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// led alive 0.25s
PT_WAIT_UNTIL(pt, frame_set_3(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_LED_CMD, 0, FR_LED_ALIVE, FR_LED_SET, 25)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
PT_YIELD_WHILE(pt, OK);
PT_END(pt);
}
static u8 braking_action(pt_t* pt, void* args)
{
frame_t fr;
PT_BEGIN(pt);
// signal braking state
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_STATE, 0, FR_STATE_SET, FR_STATE_BRAKING)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde cone stop
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_CONE, FR_SERVO_OFF)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde aero open
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_AERO, FR_SERVO_OPEN)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// time-out 0.1s
MNT.time_out = TIME_get() + 100 * TIME_1_MSEC;
PT_YIELD_WHILE(pt, OK);
PT_END(pt);
}
static u8 parachute_action(pt_t* pt, void* args)
{
frame_t fr;
PT_BEGIN(pt);
// signal parachute state
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_STATE, 0, FR_STATE_SET, FR_STATE_PARACHUTE)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde cone stop
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_CONE, FR_SERVO_OFF)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde aero stop
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_AERO, FR_SERVO_OFF)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// led open 1s
PT_WAIT_UNTIL(pt, frame_set_3(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_LED_CMD, 0, FR_LED_OPEN, FR_LED_SET, 100)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
PT_YIELD_WHILE(pt, OK);
PT_END(pt);
}
static u8 flight_action(pt_t* pt, void* args)
{
frame_t fr;
PT_BEGIN(pt);
// signal flight state
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_STATE, 0, FR_STATE_SET, FR_STATE_FLIGHT)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde cone close
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_CONE, FR_SERVO_CLOSE)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde aero close
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_AERO, FR_SERVO_CLOSE)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// time-out = flight time
MNT.time_out = MNT.open_time * TIME_1_SEC / 10 + TIME_get();
// led alive 0.1s
PT_WAIT_UNTIL(pt, frame_set_3(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_LED_CMD, 0, FR_LED_ALIVE, FR_LED_SET, 10)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
PT_YIELD_WHILE(pt, OK);
PT_END(pt);
}
static u8 waiting_action(pt_t* pt, void* args)
{
frame_t fr;
PT_BEGIN(pt);
// signal waiting state
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_STATE, 0, FR_STATE_SET, FR_STATE_WAITING)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde cone stop
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_CONE, FR_SERVO_OFF)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// led alive 1s
PT_WAIT_UNTIL(pt, frame_set_3(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_LED_CMD, 0, FR_LED_ALIVE, FR_LED_SET, 100)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
PT_YIELD_WHILE(pt, OK);
PT_END(pt);
}
static u8 cone_closed_action(pt_t* pt, void* args)
{
frame_t fr;
PT_BEGIN(pt);
// signal cone closed state
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_STATE, 0, FR_STATE_SET, FR_STATE_CONE_CLOSED)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// cmde cone close
PT_WAIT_UNTIL(pt, frame_set_2(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_MINUT_SERVO_CMD, 0, FR_SERVO_CONE, FR_SERVO_CLOSE)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// time-out 1s
MNT.time_out = TIME_get() + 1 * TIME_1_SEC;
// led alive 0.1s
PT_WAIT_UNTIL(pt, frame_set_3(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_LED_CMD, 0, FR_LED_ALIVE, FR_LED_SET, 10)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
// led open off 0.0s
PT_WAIT_UNTIL(pt, frame_set_3(&fr, DPT_SELF_ADDR, DPT_SELF_ADDR, FR_LED_CMD, 0, FR_LED_OPEN, FR_LED_SET, 0)
&& OK == FIFO_put(&MNT.out_fifo, &fr)
);
PT_YIELD_WHILE(pt, OK);
PT_END(pt);
}
int DLGSM::PT_pwr_off(struct pt *pt, uint8_t force) {
static struct pt child_pt;
static uint32_t ts;
char ret;
PT_BEGIN(pt);
DEBUG_LOG("GSM power off");
pinMode(GSM_PWR, OUTPUT);
if (CONN_get_flag(CONN_PWR) || force) {
digitalWrite(GSM_PWR, LOW);
PT_WAIT_UNTIL(pt, (millis() - ts) > 1000);
ts = millis();
digitalWrite(GSM_PWR, HIGH);
PT_WAIT_UNTIL(pt, (millis() - ts) > 2000);
ts = millis();
digitalWrite(GSM_PWR, LOW);
PT_WAIT_UNTIL(pt, (millis() - ts) > 3000);
CONN_set_flag(CONN_PWR, 0);
CONN_set_flag(CONN_NETWORK, 0);
CONN_set_flag(CONN_SENDING, 0);
CONN_set_flag(CONN_CONNECTED, 0);
PT_WAIT_THREAD(pt, PT_recv(&child_pt, &ret, "DOWN", 15000, 1));
}
_gsmserial.flush();
PT_END(pt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(pingreq_pt(struct pt* pt, struct mqtt_connection* conn))
{
PT_BEGIN(pt);
DBG("MQTT - Sending PINGREQ\r\n");
/* Write Fixed Header */
PT_MQTT_WRITE_BYTE(conn, MQTT_FHDR_MSG_TYPE_PINGREQ);
PT_MQTT_WRITE_BYTE(conn, 0);
send_out_buffer(conn);
PT_WAIT_UNTIL(pt, conn->out_buffer_sent);
/* Start timeout for reply. */
conn->waiting_for_pingresp = 1;
/* Wait for PINGRESP
*
* Note that the timeout disconnect is handle in the timer callback. */
reset_packet(&conn->in_packet);
do {
PT_WAIT_UNTIL(pt, conn->in_packet.packet_received);
} while((conn->in_packet.fhdr & 0xF0) != MQTT_FHDR_MSG_TYPE_PINGRESP);
reset_packet(&conn->in_packet);
conn->waiting_for_pingresp = 0;
PT_END(pt);
}
/*---------------------------------------------------------------------*/
static
PT_THREAD(recv_tcpthread(struct pt *pt))
{
PT_BEGIN(pt);
/* Read the header. */
PT_WAIT_UNTIL(pt, uip_newdata() && uip_datalen() > 0);
if(uip_datalen() < sizeof(struct codeprop_tcphdr)) {
PRINTF(("codeprop: header not found in first tcp segment\n"));
uip_abort();
goto thread_done;
}
s.len = uip_htons(((struct codeprop_tcphdr *)uip_appdata)->len);
s.addr = 0;
uip_appdata += sizeof(struct codeprop_tcphdr);
uip_len -= sizeof(struct codeprop_tcphdr);
xmem_erase(XMEM_ERASE_UNIT_SIZE, EEPROMFS_ADDR_CODEPROP);
/* Read the rest of the data. */
do {
if(uip_len > 0) {
xmem_pwrite(uip_appdata, uip_len, EEPROMFS_ADDR_CODEPROP + s.addr);
s.addr += uip_len;
}
if(s.addr < s.len) {
PT_YIELD_UNTIL(pt, uip_newdata());
}
} while(s.addr < s.len);
/* Kill old program. */
elfloader_unload();
/* Link, load, and start new program. */
int s;
static char msg[30 + 10];
s = elfloader_load(EEPROMFS_ADDR_CODEPROP);
if (s == ELFLOADER_OK)
sprintf(msg, "ok\n");
else
sprintf(msg, "err %d %s\n", s, elfloader_unknown);
/* Return "ok" message. */
do {
s = strlen(msg);
uip_send(msg, s);
PT_WAIT_UNTIL(pt, uip_acked() || uip_rexmit() || uip_closed());
} while(uip_rexmit());
/* Close the connection. */
uip_close();
thread_done:;
PT_END(pt);
}
/**
* @brief Button Task
*
* @note Called every 1 ms
*/
static
PT_THREAD(ButtonProc(struct pt *pt)) {
static uint32_t tstart;
uint32_t b;
PT_BEGIN(pt);
while(1) {
PT_WAIT_UNTIL(pt,JoyStick_Read()&JOY_CENTER);
blinking = ! blinking;
tstart = msTick;
PT_WAIT_UNTIL(pt,((msTick-tstart)>=DEBOUNCE_TIME));
PT_WAIT_UNTIL(pt,!(JoyStick_Read()&JOY_CENTER));
}
PT_END(pt);
}
int DLGSM::PT_recv(struct pt *pt, char *ret, char *conf, int tout, char process) {
static uint32_t ts, startts;
static struct pt linerecv_pt;
PT_BEGIN(pt);
ts = millis();
*ret = 0;
PT_WAIT_UNTIL(pt, _gsmserial.available() || (millis() - ts) > tout);
ts = millis();
if (!_gsmserial.available()) {
*ret = 0;
PT_EXIT(pt);
}
startts = millis();
_gsm_wline = 1;
while (_gsmserial.available() || (millis() - startts) < tout) {
PT_WAIT_THREAD(pt, PT_recvline(&linerecv_pt, ret, _gsm_buff, _gsm_buffsize, tout, process));
if (conf != NULL && strstr(_gsm_buff, conf) != NULL)
*ret = 1;
else if (conf != NULL)
*ret = 0;
}
_gsm_wline = 0;
PT_END(pt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(pingreq_pt(struct pt *pt, struct mqtt_connection *conn))
{
PT_BEGIN(pt);
DBG("MQTT - Sending PINGREQ\n");
/* Write Fixed Header */
PT_MQTT_WRITE_BYTE(conn, MQTT_FHDR_MSG_TYPE_PINGREQ);
PT_MQTT_WRITE_BYTE(conn, 0);
send_out_buffer(conn);
/* Start timeout for reply. */
conn->waiting_for_pingresp = 1;
/* Wait for PINGRESP or timeout */
reset_packet(&conn->in_packet);
timer_set(&conn->t, RESPONSE_WAIT_TIMEOUT);
PT_WAIT_UNTIL(pt, conn->in_packet.packet_received || timer_expired(&conn->t));
reset_packet(&conn->in_packet);
conn->waiting_for_pingresp = 0;
PT_END(pt);
}
/**
* The first protothread function. A protothread function must always
* return an integer, but must never explicitly return - returning is
* performed inside the protothread statements.
*
* The protothread function is driven by the main loop further down in
* the code.
*/
static int
protothread1(struct pt *pt)
{
/* A protothread function must begin with PT_BEGIN() which takes a
pointer to a struct pt. */
PT_BEGIN(pt);
/* We loop forever here. */
while(1) {
/* Wait until the other protothread has set its flag. */
PT_WAIT_UNTIL(pt, protothread2_flag != 0);
printf("Protothread 1 running\n");
/* We then reset the other protothread's flag, and set our own
flag so that the other protothread can run. */
protothread2_flag = 0;
protothread1_flag = 1;
/* And we loop. */
}
/* All protothread functions must end with PT_END() which takes a
pointer to a struct pt. */
PT_END(pt);
}
// === Launching balls =================================================
static PT_THREAD (protothread_launch_balls(struct pt *pt))
{
PT_BEGIN(pt);
while(1){
//make sure we don't put in too many balls
PT_WAIT_UNTIL(pt, current_balls < MAX_BALLS);
while(current_balls < MAX_BALLS) {
PT_YIELD_TIME_msec(200); //5 balls per second
current_balls++; //increase ball count in field
ball *new_ball = (ball*) malloc (sizeof(ball));
new_ball->xc = int2fix16(315);
new_ball->yc = int2fix16(120);
new_ball->vxc = int2fix16(-8 + (rand()>>28));
new_ball->vyc = int2fix16(-8 + (rand()>>27));
new_ball->next = NULL;
new_ball->hit_counter = 0;
if (initial_ball == NULL) { //if chain is empty, this ball is first ball
initial_ball = new_ball;
new_ball->prev = NULL;
}
else {//otherwise, put it at end
end_ball->next = new_ball;
new_ball->prev = end_ball;
}
end_ball = new_ball;
}
}
PT_END(pt);
} // end launch ball thread
/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_input(void))
{
unsigned short i;
char *ptr;
char next;
next = 1;
PT_BEGIN(&s.inpt);
while(1) {
/* Wait until data arrives. */
next = 0;
PT_WAIT_UNTIL(&s.inpt, next && uip_newdata());
CURSOR_OFF();
/* Print it out on the screen. */
ptr = (char *)uip_appdata;
for(i = 0; i < uip_len; ++i) {
cbm_k_bsout(*ptr);
++ptr;
}
CURSOR_ON();
}
PT_END(&s.inpt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_output(void))
{
ctk_arch_key_t c;
char *ptr;
PT_BEGIN(&s.outpt);
while(1) {
PT_WAIT_UNTIL(&s.outpt, (ctk_mode_get() == CTK_MODE_EXTERNAL) &&
kbhit());
ptr = s.outputbuf;
s.len = 0;
while(kbhit() && s.len < sizeof(s.outputbuf)) {
c = cgetc();
*ptr = c;
++ptr;
++s.len;
}
PT_WAIT_THREAD(&s.outpt, send());
}
PT_END(&s.outpt);
}
static int protothreadExplode(struct pt *pt) {
static unsigned long ts = 0;
PT_BEGIN(pt);
while(1) {
PT_WAIT_UNTIL(pt, state == STATE_EXPLODE);
ts = millis();
// countdown before explode
int tDelay = 100;
while (millis() - ts < 3000) {
redInd(true);
piezo(true);
_delay_ms(tDelay);
redInd(false);
piezo(false);
_delay_ms(tDelay);
if (tDelay > 10) tDelay -= 10;
}
// explode
unsigned long data;
data = 0b100000110000000011101000;
for (int i = 1; i < 4; i++) {
redInd(true);
piezo(true);
sendSony(data, 24);
_delay_ms(200);
redInd(false);
piezo(false);
_delay_ms(100);
}
state = STATE_FIND_ME;
}
PT_END(pt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(udp_server_thread(struct pt *pt))
{
PT_BEGIN(pt);
uint16_t payloadlen;
static uint8_t str[64];
while(1)
{
PT_WAIT_UNTIL(pt,check_flag(new_packet,udp_server_flag));
if((buf[IP_PROTO_P]==IP_PROTO_UDP_V) && (buf[UDP_DST_PORT_H_P]==(MYUDPPORT>>8)) && (buf[UDP_DST_PORT_L_P]==(MYUDPPORT&0xff)))
{
/* calculate the udp message length */
payloadlen=buf[UDP_LEN_L_P]-UDP_HEADER_LEN;
/* replace the newline with string terminator */
buf[UDP_DATA_P+payloadlen-1] = '\0';
/* add some explanatory header to it */
sprintf(str,"> udp got: %s\r\n",buf+UDP_DATA_P);
/* send the same message with little modification to the sender */
make_udp_reply_from_request(buf,str,strlen(str),MYUDPPORT);
}
clear_flag(new_packet,udp_server_flag);
}
PT_END(pt);
}
int DLGSM::PT_send_recv(struct pt *pt, char *ret, char *cmd, int tout) {
static uint32_t ts, startts;
static struct pt linerecv_pt;
static char gotsmtg = 0;
PT_BEGIN(pt);
*ret = 0;
gotsmtg = 0;
ts = millis();
GSM_send(cmd);
PT_WAIT_UNTIL(pt, _gsmserial.available() || (millis() - ts) > tout);
ts = millis();
if (!_gsmserial.available()) {
PT_RESTART(pt);
}
startts = millis();
_gsm_wline = 1;
while (_gsmserial.available() || (millis() - startts) < tout) {
PT_WAIT_THREAD(pt, PT_recvline(&linerecv_pt, ret, _gsm_buff, _gsm_buffsize, tout, 1));
if (*ret > gotsmtg)
gotsmtg = *ret;
else if (*ret == 0)
_tout_cnt++;
ts = millis();
}
if (*ret == 0)
*ret = gotsmtg;
_gsm_wline = 0;
PT_END(pt);
}
int DLGSM::PT_send_recv_confirm(struct pt *pt, char *ret, char *cmd, char *conf, int tout) {
static uint32_t ts,startts;
static struct pt linerecv_pt;
PT_BEGIN(pt);
*ret = 0;
ts = millis();
GSM_send(cmd);
PT_WAIT_UNTIL(pt, _gsmserial.available() || (millis() - ts) > tout);
if (!_gsmserial.available()) {
*ret = 0;
PT_EXIT(pt);
}
ts = millis();
startts = millis();
_gsm_wline = 1;
while (_gsmserial.available() || (millis() - startts) < tout) {
PT_WAIT_THREAD(pt, PT_recvline(&linerecv_pt, ret, _gsm_buff, _gsm_buffsize, tout, 1));
ts = millis();
if (*ret == 0)
_tout_cnt++;
if (conf != NULL && strstr(_gsm_buff, conf) != NULL) {
*ret = 1;
PT_EXIT(pt);
} else if (conf != NULL && (strstr(_gsm_buff, "ERROR") != NULL || strstr(_gsm_buff, "FAIL") != NULL)) {
*ret = 2;
_error_cnt++;
PT_EXIT(pt);
} else if (conf != NULL)
*ret = 0;
}
_gsm_wline = 0;
PT_END(pt);
}
IROM bool LedBlink::dispatch(Msg& msg) {
PT_BEGIN()
PT_WAIT_UNTIL(msg.is(0, SIG_INIT));
init();
while (true) {
timeout(_msecInterval);
PT_YIELD_UNTIL(
msg.is(_src, SIG_CONNECTED) || msg.is(_src, SIG_DISCONNECTED)
|| timeout());
switch (msg.signal()) {
case SIG_TICK: {
gpio16_output_set(_isOn);
_isOn = !_isOn;
break;
}
case SIG_CONNECTED: {
_msecInterval = 1000;
break;
}
case SIG_DISCONNECTED: {
_msecInterval = 200;
break;
}
default: {
}
}
}
PT_END();
return false;
}
static PT_THREAD(zmq_sub_send_all(zmq_socket_t *self, zmq_msg_t *msg)) {
// TODO: implement HWM
LOCAL_PT(pt);
PRINTF("> zmq_sub_send_all %d %p\r\n", pt.lc, msg);
PT_BEGIN(&pt);
self->out_conn = list_head(self->channel.connections);
while(self->out_conn != NULL) {
// TODO: check if queue is full (HWM)
if((self->out_conn->validated & CONNECTION_VALIDATED) != CONNECTION_VALIDATED) {
self->out_conn = list_item_next(self->out_conn);
continue;
}
// NB. there is a bug right here.
// When serving several peers, the msg gets added to the out queues of each of those connections.
// The problem is: these queues are implemented with Contiki linked list,
// Which requires to have a 'next' pointer as the first member of the struct.
// When adding the same msg to several connections' queue, the next pointer gets overwritten every time...
zmtp_connection_add_out_msg(self->out_conn, msg);
zmtp_process_post(zmq_socket_output_activity, self->out_conn);
PT_WAIT_UNTIL(&pt, self->out_conn->out_size <= 0);
self->out_conn = list_item_next(self->out_conn);
}
PT_END(&pt);
}
static PT_THREAD(thread_uart(struct pt *pt))
{
PT_BEGIN(pt);
while(1)
{
PT_WAIT_UNTIL(pt, uart_flag);
led_green_blink(10); /* 10 timer ticks = 100 ms */
/* does the local node expects an id
* or do we have to broadcast it? */
if(timer_reached(TIMER_ID_INPUT, ID_INPUT_TIMEOUT_TICKS))
{
send_id_reply(uart_data);
}
else
{
set_node_id(uart_data);
}
uart_flag = 0;
}
PT_END(pt);
}
