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