void kernel_footprint(void) { init(); // generate code for process struct Process *p = proc_new(proc1_main, 0, sizeof(proc1_stack), proc1_stack); proc_setPri(p, 5); proc_yield(); // generate code for msg Msg msg; msg_initPort(&in_port, event_createSignal(p, SIG_USER1)); msg_put(&in_port, &msg); msg_peek(&in_port); Msg *msg_re = msg_get(&in_port); msg_reply(msg_re); // generate code for signals sig_send(p, SIG_USER0); // generate code for msg Semaphore sem; sem_init(&sem); sem_obtain(&sem); sem_release(&sem); sig_wait(SIG_USER0); }
ssize_t DevPty::handle_write(struct anvil_write_msg *msg, anvil_msginfo_t *msg_info, size_t nbyte, off_t offset) { //anvil_syslog(0, "Ptm::handle_write()\n"); // Put the bytes in the ring buffer uint8_t buf[WRITE_BUF_SIZE+1]; size_t still_to_write = nbyte; size_t total_written = 0; while (still_to_write) { size_t peek_amount = std::min(still_to_write, (size_t)WRITE_BUF_SIZE); if (peek_amount <= 0) { break; } msg_peek(msg_info->pid, msg_info->tid, buf, peek_amount, total_written + sizeof(struct anvil_write_msg)); still_to_write -= peek_amount; total_written += peek_amount; for (int i=0; i<peek_amount; ++i) { //anvil_syslog(0, "Ptm %c (%02x)\n", isprint(buf[i])?buf[i]:'-', buf[i]); get_pts()->push_char(buf[i]); } } msg_reply(msg_info->pid, msg_info->tid, total_written, NULL, 0); return total_written; }
static int do_open(void *msg, anvil_msginfo_t *msg_info) { struct anvil_open_msg *openmsg; char name[1024]; file_struct *pfile; int found; fcb_t *fcb; #if 0 openmsg = (struct anvil_open_msg *)msg; if (openmsg->pathlen > 1023) { msg_reply(msg_info->pid, msg_info->tid, ENAMETOOLONG, NULL, 0); return -1; } msg_peek(msg_info->pid, msg_info->tid, name, openmsg->pathlen, sizeof(struct anvil_open_msg)); name[openmsg->pathlen] = 0; anvil_syslog(0, "INITRD: do_open file <%s>\n", name); pfile = (file_struct *)dlist_peek_head(&filelist); found = 0; while (pfile) { if (!strcmp(pfile->filename, name)) { anvil_syslog(0, "*** INITRD: Found file %s\n", pfile->filename); found = 1; break; /* Break so that pfile is valid */ } pfile = (file_struct *)dlist_peek_next(&filelist, (dlist_item_t *)pfile); } if (!found) { anvil_syslog(0, "INITRD: do_open couldn't find %s\n", name); msg_reply(msg_info->pid, msg_info->tid, ENOENT, NULL, 0); return -1; } fcb = (fcb_t *)malloc(sizeof(fcb_t)); fcb->fs = pfile; fcb->pos = 0; fcb->data = pfile->addr; //anvil_syslog(0, "INITRD: do_open file <%s> fcb=%016lx\n", name, fcb); msg_port_allow(msg_info->pid, msg_info->tid, (void *)fcb, NULL); msg_reply(msg_info->pid, msg_info->tid, 0, NULL, 0); #endif return 0; }
static void mqtt_socket_sent(void *arg) { NODE_DBG("enter mqtt_socket_sent.\n"); struct espconn *pesp_conn = arg; if(pesp_conn == NULL) return; lmqtt_userdata *mud = (lmqtt_userdata *)pesp_conn->reverse; if(mud == NULL) return; if(!mud->connected) return; // call mqtt_sent() mud->event_timeout = 0; mud->keep_alive_tick = 0; if(mud->connState == MQTT_CONNECT_SENDING){ mud->connState = MQTT_CONNECT_SENT; // MQTT_CONNECT not queued. return; } NODE_DBG("sent1, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q))); // qos = 0, publish and forgot. msg_queue_t *node = msg_peek(&(mud->mqtt_state.pending_msg_q)); if(node && node->msg_type == MQTT_MSG_TYPE_PUBLISH && node->publish_qos == 0) { msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); if(mud->cb_puback_ref == LUA_NOREF) return; if(mud->self_ref == LUA_NOREF) return; if(mud->L == NULL) return; lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->cb_puback_ref); lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->self_ref); // pass the userdata to callback func in lua lua_call(mud->L, 1, 0); } else if(node && node->msg_type == MQTT_MSG_TYPE_PUBACK && node->publish_qos == 1) { msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); } else if(node && node->msg_type == MQTT_MSG_TYPE_PUBCOMP) { msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); } else if(node && node->msg_type == MQTT_MSG_TYPE_PINGREQ) { msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); } NODE_DBG("sent2, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q))); NODE_DBG("leave mqtt_socket_sent.\n"); }
int DevPty::handle_ioctl(struct anvil_ioctl_msg *msg, anvil_msginfo_t *msg_info) { //anvil_syslog(0, "Ask::TtyDevice::handle_ioctl %08x %08x %08x\n", msg->request, msg->flags, msg->size); switch (msg->request) { case TIOCSWINSZ: { //anvil_syslog(0, "DevPty::handle_ioctl setwinsz()\n"); struct winsize ws; msg_peek(msg_info->pid, msg_info->tid, &ws, sizeof(ws), sizeof(struct anvil_ioctl_msg)); m_pts.set_size(ws.ws_col, ws.ws_row); msg_reply(msg_info->pid, msg_info->tid, 0, NULL, 0); break; } default: msg_reply(msg_info->pid, msg_info->tid, -EINVAL, NULL, 0); //anvil_syslog(0, "DevPty::handle_default\n"); break; } return 0; }
void main() { bool keyboard_report_ready = false; bool consumer_report_ready = false; uint8_t prev_keycode = KC_NO; __xdata uint8_t recv_buffer[RECV_BUFF_SIZE]; __xdata uint8_t bytes_received; P0DIR = 0x00; // all outputs P0ALT = 0x00; // all GPIO default behavior LED_off(); usbInit(); //dbgInit(); rf_dngl_init(); reset_keyboard_report(); for (;;) { usbPoll(); // handles USB interrupts //dbgPoll(); // send chars from the uart TX buffer // try to read the recv buffer bytes_received = rf_dngl_recv(recv_buffer, RECV_BUFF_SIZE); if (bytes_received) { // we have new data, so what is it? if (recv_buffer[0] == MT_KEY_STATE) { process_key_state_msg(recv_buffer, bytes_received); consumer_report_ready = true; keyboard_report_ready = true; } else if (recv_buffer[0] == MT_TEXT) { process_text_msg(recv_buffer, bytes_received); } } if (!keyboard_report_ready && !msg_empty()) { // get the next char from the stored text message uint8_t c = msg_peek(); uint8_t new_keycode = get_keycode_for_char(c); reset_keyboard_report(); // if the keycode is different than the previous // otherwise just send an empty report to simulate key went up if (new_keycode != prev_keycode || new_keycode == KC_NO) { usb_keyboard_report.keys[0] = new_keycode; usb_keyboard_report.modifiers = get_modifiers_for_char(c); msg_pop(); // remove char from the buffer } else { new_keycode = KC_NO; } keyboard_report_ready = true; prev_keycode = new_keycode; // remember for later } // send the report if the endpoint is not busy if ((in1cs & 0x02) == 0 && (keyboard_report_ready || usbHasIdleElapsed())) { // copy the keyboard report into the endpoint buffer in1buf[0] = usb_keyboard_report.modifiers; in1buf[1] = 0; in1buf[2] = usb_keyboard_report.keys[0]; in1buf[3] = usb_keyboard_report.keys[1]; in1buf[4] = usb_keyboard_report.keys[2]; in1buf[5] = usb_keyboard_report.keys[3]; in1buf[6] = usb_keyboard_report.keys[4]; in1buf[7] = usb_keyboard_report.keys[5]; // send the data on it's way in1bc = 8; keyboard_report_ready = false; } // send the consumer report if the endpoint is not busy if ((in2cs & 0x02) == 0 && (consumer_report_ready || usbHasIdleElapsed())) { in2buf[0] = usb_consumer_report; in2bc = 1; consumer_report_ready = false; } } }
void mqtt_socket_timer(void *arg) { NODE_DBG("enter mqtt_socket_timer.\n"); lmqtt_userdata *mud = (lmqtt_userdata*) arg; if(mud == NULL) return; if(mud->pesp_conn == NULL){ NODE_DBG("mud->pesp_conn is NULL.\n"); os_timer_disarm(&mud->mqttTimer); return; } NODE_DBG("timer, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q))); if(mud->event_timeout > 0){ NODE_DBG("event_timeout: %d.\n", mud->event_timeout); mud->event_timeout --; if(mud->event_timeout > 0){ return; } else { NODE_DBG("event timeout. \n"); if(mud->connState == MQTT_DATA) msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); // should remove the head of the queue and re-send with DUP = 1 // Not implemented yet. } } if(mud->connState == MQTT_INIT){ // socket connect time out. NODE_DBG("Can not connect to broker.\n"); // Never goes here. } else if(mud->connState == MQTT_CONNECT_SENDING){ // MQTT_CONNECT send time out. NODE_DBG("sSend MQTT_CONNECT failed.\n"); mud->connState = MQTT_INIT; if(mud->secure) espconn_secure_disconnect(mud->pesp_conn); else espconn_disconnect(mud->pesp_conn); mud->keep_alive_tick = 0; // not need count anymore } else if(mud->connState == MQTT_CONNECT_SENT){ // wait for CONACK time out. NODE_DBG("MQTT_CONNECT failed.\n"); } else if(mud->connState == MQTT_DATA){ msg_queue_t *pending_msg = msg_peek(&(mud->mqtt_state.pending_msg_q)); if(pending_msg){ mud->event_timeout = MQTT_SEND_TIMEOUT; if(mud->secure) espconn_secure_sent(mud->pesp_conn, pending_msg->msg.data, pending_msg->msg.length); else espconn_sent(mud->pesp_conn, pending_msg->msg.data, pending_msg->msg.length); mud->keep_alive_tick = 0; NODE_DBG("id: %d - qos: %d, length: %d\n", pending_msg->msg_id, pending_msg->publish_qos, pending_msg->msg.length); } else { // no queued event. mud->keep_alive_tick ++; if(mud->keep_alive_tick > mud->mqtt_state.connect_info->keepalive){ mud->event_timeout = MQTT_SEND_TIMEOUT; uint8_t temp_buffer[MQTT_BUF_SIZE]; mqtt_msg_init(&mud->mqtt_state.mqtt_connection, temp_buffer, MQTT_BUF_SIZE); NODE_DBG("\r\nMQTT: Send keepalive packet\r\n"); mqtt_message_t* temp_msg = mqtt_msg_pingreq(&mud->mqtt_state.mqtt_connection); msg_queue_t *node = msg_enqueue( &(mud->mqtt_state.pending_msg_q), temp_msg, 0, MQTT_MSG_TYPE_PINGREQ, (int)mqtt_get_qos(temp_msg->data) ); // only one message in queue, send immediately. if(mud->secure) espconn_secure_sent(mud->pesp_conn, temp_msg->data, temp_msg->length); else espconn_sent(mud->pesp_conn, temp_msg->data, temp_msg->length); mud->keep_alive_tick = 0; } } } NODE_DBG("leave mqtt_socket_timer.\n"); }
static void mqtt_socket_received(void *arg, char *pdata, unsigned short len) { NODE_DBG("enter mqtt_socket_received.\n"); uint8_t msg_type; uint8_t msg_qos; uint16_t msg_id; msg_queue_t *node = NULL; int length = (int)len; // uint8_t in_buffer[MQTT_BUF_SIZE]; uint8_t *in_buffer = (uint8_t *)pdata; struct espconn *pesp_conn = arg; if(pesp_conn == NULL) return; lmqtt_userdata *mud = (lmqtt_userdata *)pesp_conn->reverse; if(mud == NULL) return; READPACKET: if(length > MQTT_BUF_SIZE || length <= 0) return; // c_memcpy(in_buffer, pdata, length); uint8_t temp_buffer[MQTT_BUF_SIZE]; mqtt_msg_init(&mud->mqtt_state.mqtt_connection, temp_buffer, MQTT_BUF_SIZE); mqtt_message_t *temp_msg = NULL; switch(mud->connState){ case MQTT_CONNECT_SENDING: case MQTT_CONNECT_SENT: if(mqtt_get_type(in_buffer) != MQTT_MSG_TYPE_CONNACK){ NODE_DBG("MQTT: Invalid packet\r\n"); mud->connState = MQTT_INIT; if(mud->secure) espconn_secure_disconnect(pesp_conn); else espconn_disconnect(pesp_conn); } else { mud->connState = MQTT_DATA; NODE_DBG("MQTT: Connected\r\n"); if(mud->cb_connect_ref == LUA_NOREF) break; if(mud->self_ref == LUA_NOREF) break; if(mud->L == NULL) break; lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->cb_connect_ref); lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->self_ref); // pass the userdata(client) to callback func in lua lua_call(mud->L, 1, 0); break; } break; case MQTT_DATA: mud->mqtt_state.message_length_read = length; mud->mqtt_state.message_length = mqtt_get_total_length(in_buffer, mud->mqtt_state.message_length_read); msg_type = mqtt_get_type(in_buffer); msg_qos = mqtt_get_qos(in_buffer); msg_id = mqtt_get_id(in_buffer, mud->mqtt_state.message_length); msg_queue_t *pending_msg = msg_peek(&(mud->mqtt_state.pending_msg_q)); NODE_DBG("MQTT_DATA: type: %d, qos: %d, msg_id: %d, pending_id: %d\r\n", msg_type, msg_qos, msg_id, (pending_msg)?pending_msg->msg_id:0); switch(msg_type) { case MQTT_MSG_TYPE_SUBACK: if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_SUBSCRIBE && pending_msg->msg_id == msg_id){ NODE_DBG("MQTT: Subscribe successful\r\n"); msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); if (mud->cb_suback_ref == LUA_NOREF) break; if (mud->self_ref == LUA_NOREF) break; if(mud->L == NULL) break; lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->cb_suback_ref); lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->self_ref); lua_call(mud->L, 1, 0); } break; case MQTT_MSG_TYPE_UNSUBACK: if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE && pending_msg->msg_id == msg_id){ NODE_DBG("MQTT: UnSubscribe successful\r\n"); msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); } break; case MQTT_MSG_TYPE_PUBLISH: if(msg_qos == 1){ temp_msg = mqtt_msg_puback(&mud->mqtt_state.mqtt_connection, msg_id); node = msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg, msg_id, MQTT_MSG_TYPE_PUBACK, (int)mqtt_get_qos(temp_msg->data) ); } else if(msg_qos == 2){ temp_msg = mqtt_msg_pubrec(&mud->mqtt_state.mqtt_connection, msg_id); node = msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg, msg_id, MQTT_MSG_TYPE_PUBREC, (int)mqtt_get_qos(temp_msg->data) ); } if(msg_qos == 1 || msg_qos == 2){ NODE_DBG("MQTT: Queue response QoS: %d\r\n", msg_qos); } deliver_publish(mud, in_buffer, mud->mqtt_state.message_length); break; case MQTT_MSG_TYPE_PUBACK: if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBLISH && pending_msg->msg_id == msg_id){ NODE_DBG("MQTT: Publish with QoS = 1 successful\r\n"); msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); if(mud->cb_puback_ref == LUA_NOREF) break; if(mud->self_ref == LUA_NOREF) break; if(mud->L == NULL) break; lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->cb_puback_ref); lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->self_ref); // pass the userdata to callback func in lua lua_call(mud->L, 1, 0); } break; case MQTT_MSG_TYPE_PUBREC: if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBLISH && pending_msg->msg_id == msg_id){ NODE_DBG("MQTT: Publish with QoS = 2 Received PUBREC\r\n"); // Note: actrually, should not destroy the msg until PUBCOMP is received. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); temp_msg = mqtt_msg_pubrel(&mud->mqtt_state.mqtt_connection, msg_id); node = msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg, msg_id, MQTT_MSG_TYPE_PUBREL, (int)mqtt_get_qos(temp_msg->data) ); NODE_DBG("MQTT: Response PUBREL\r\n"); } break; case MQTT_MSG_TYPE_PUBREL: if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBREC && pending_msg->msg_id == msg_id){ msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); temp_msg = mqtt_msg_pubcomp(&mud->mqtt_state.mqtt_connection, msg_id); node = msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg, msg_id, MQTT_MSG_TYPE_PUBCOMP, (int)mqtt_get_qos(temp_msg->data) ); NODE_DBG("MQTT: Response PUBCOMP\r\n"); } break; case MQTT_MSG_TYPE_PUBCOMP: if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBREL && pending_msg->msg_id == msg_id){ NODE_DBG("MQTT: Publish with QoS = 2 successful\r\n"); msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q))); if(mud->cb_puback_ref == LUA_NOREF) break; if(mud->self_ref == LUA_NOREF) break; if(mud->L == NULL) break; lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->cb_puback_ref); lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->self_ref); // pass the userdata to callback func in lua lua_call(mud->L, 1, 0); } break; case MQTT_MSG_TYPE_PINGREQ: temp_msg = mqtt_msg_pingresp(&mud->mqtt_state.mqtt_connection); node = msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg, msg_id, MQTT_MSG_TYPE_PINGRESP, (int)mqtt_get_qos(temp_msg->data) ); NODE_DBG("MQTT: Response PINGRESP\r\n"); break; case MQTT_MSG_TYPE_PINGRESP: // Ignore NODE_DBG("MQTT: PINGRESP received\r\n"); break; } // NOTE: this is done down here and not in the switch case above // because the PSOCK_READBUF_LEN() won't work inside a switch // statement due to the way protothreads resume. if(msg_type == MQTT_MSG_TYPE_PUBLISH) { length = mud->mqtt_state.message_length_read; if(mud->mqtt_state.message_length < mud->mqtt_state.message_length_read) { length -= mud->mqtt_state.message_length; in_buffer += mud->mqtt_state.message_length; NODE_DBG("Get another published message\r\n"); goto READPACKET; } } break; } if(node && (1==msg_size(&(mud->mqtt_state.pending_msg_q))) && mud->event_timeout == 0){ mud->event_timeout = MQTT_SEND_TIMEOUT; NODE_DBG("Sent: %d\n", node->msg.length); if( mud->secure ) espconn_secure_sent( pesp_conn, node->msg.data, node->msg.length ); else espconn_sent( pesp_conn, node->msg.data, node->msg.length ); } mud->keep_alive_tick = 0; NODE_DBG("receive, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q))); NODE_DBG("leave mqtt_socket_received.\n"); return; }