/**************************************************************************** * * Name: packet_send * Function: send a packet * variable: pPacket -- packet information point * ****************************************************************************/ UINT32 packet_send(PPACKET pPacket) { //create packet head buffer; unsigned char packet_head[PACKET_HEAD_LEN]; unsigned char szCRC[4]; MakePacketHeadBuffer(pPacket, packet_head); //send packet header if(PACKET_HEAD_LEN != com_send(packet_head, PACKET_HEAD_LEN)) { return ERROR_SENDPACKETHEAD; } UINT32 nLength = pPacket->packet_length; if(0 != pPacket->blank_flag && PACKET_DATA == pPacket->packet_type) nLength = 4; if(nLength != com_send(pPacket->data_buffer, nLength)) { return ERROR_SENDPACKETDATA; } UINT32 nCRC = MG_Table_Driven_CRC(0xFFFFFFFF, pPacket->data_buffer, nLength); store_long(szCRC, nCRC); if(4 != com_send(szCRC, 4)) { return ERROR_SENDPACKETCRC; } return SUCCESS; }
/** @brief Sends one byte of data over the serial line * * @param iface Interface to send byte on * @param cmd Data to send */ static inline void send_byte_command(uint8_t iface, uint8_t cmd) { send.data[0] = cmd; send.size = 1; if(iface == IFACE_SERIAL) com_send(IFACE_SERIAL, &send); else if(iface == IFACE_RADIO) com_send(IFACE_RADIO, &send); }
void ps(char *st) { unsigned char len=strlen(st); delay(100); com_send(len); while (len--) com_send(*st++); }
void quit_got_signal(int sig) { char si[8] = "SIGINT", st[9] = "SIGTERM", *p = si; if (sig == SIGTERM) p = st; debug_out("%s captured... exiting gracefully...\n", p); log_command(LOG_SERVICES, NULL, "", "Service shutdown (caught %s)", p); com_send(irc, "%s Q :Service shutdown\n", conf->cs->numeric); com_send(irc, "%s WA :caught %s - service shutdown\n", conf->os->numeric, p); com_send(irc, "%s SQ %s %lu :caught %s - service shutdown\n", conf->os->numeric, conf->host, conf->starttime, p); exit(1); }
void ICACHE_FLASH_ATTR save_wifi2_configuration(const int8_t cid, const SaveWifi2Configuration *data) { SaveWifi2ConfigurationReturn sw2cr; /* * When mesh mode is enabled client and AP mode must be disbaled. * If a situation is detected where mesh mode is enabled along with client/AP * mode then disable mesh mode. * * This situation can occur if a brickv older than version 2.3.7 is being used * to configure a master and WIFI extension 2 with newer firmware which already * had mesh enabled or if the user is calling these APIs and isn't disabling * mesh mode and is enabling either or both of client/AP mode. */ if(configuration_current.mesh_enable) { if(configuration_current.client_enable || configuration_current.ap_enable) { configuration_current.mesh_enable = false; } } sw2cr.header = data->header; sw2cr.header.length = sizeof(SaveWifi2ConfigurationReturn); sw2cr.result = configuration_save_to_eeprom(); com_send(&sw2cr, sizeof(SaveWifi2ConfigurationReturn), cid); }
void ICACHE_FLASH_ATTR get_wifi2_mesh_ap_status(const int8_t cid, const GetWifi2MeshAPStatus *data) { uint8_t mac[6]; struct ip_info info_ipv4; struct softap_config config_ap; os_bzero(&gw2masr.header, sizeof(gw2masr.header)); gw2masr.header = data->header; gw2masr.header.length = sizeof(GetWifi2MeshAPStatusReturn); if((wifi_softap_get_config(&config_ap)) && (wifi_get_ip_info(SOFTAP_IF, &info_ipv4)) \ && (wifi_get_macaddr(SOFTAP_IF, mac))) { os_bzero(gw2masr.ssid, sizeof(gw2masr.ssid)); os_memcpy(gw2masr.ssid, config_ap.ssid, sizeof(config_ap.ssid)); os_bzero(gw2masr.ip, sizeof(gw2masr.ip)); os_memcpy(gw2masr.ip, (uint8_t *)&info_ipv4.ip.addr, sizeof(info_ipv4.ip.addr)); os_bzero(gw2masr.sub, sizeof(gw2masr.sub)); os_memcpy(gw2masr.sub, (uint8_t *)&info_ipv4.netmask.addr, sizeof(info_ipv4.ip.addr)); os_bzero(gw2masr.gw, sizeof(gw2masr.gw)); os_memcpy(gw2masr.gw, (uint8_t *)&info_ipv4.gw.addr, sizeof(info_ipv4.ip.addr)); os_bzero(gw2masr.mac, sizeof(gw2masr.mac)); os_memcpy(gw2masr.mac, mac, sizeof(mac)); } com_send(&gw2masr, sizeof(GetWifi2MeshAPStatusReturn), cid); }
void ICACHE_FLASH_ATTR get_wifi2_mesh_station_status(const int8_t cid, const GetWifi2MeshStationStatus *data) { uint8_t mac[6]; char *hostname_ptr; struct ip_info info_ipv4; struct station_config *config_st; os_bzero(&gw2mssr.header, sizeof(gw2mssr.header)); gw2mssr.header = data->header; gw2mssr.header.length = sizeof(GetWifi2MeshStationStatusReturn); if((wifi_get_ip_info(STATION_IF, &info_ipv4)) && (wifi_get_macaddr(STATION_IF, mac))) { hostname_ptr = wifi_station_get_hostname(); os_bzero(gw2mssr.hostname, sizeof(gw2mssr.hostname)); os_memcpy(gw2mssr.hostname, hostname_ptr, sizeof(gw2mssr.hostname)); os_bzero(gw2mssr.ip, sizeof(gw2mssr.ip)); os_memcpy(gw2mssr.ip, (uint8_t *)&info_ipv4.ip.addr, sizeof(info_ipv4.ip.addr)); os_bzero(gw2mssr.sub, sizeof(gw2mssr.sub)); os_memcpy(gw2mssr.sub, (uint8_t *)&info_ipv4.netmask.addr, sizeof(info_ipv4.netmask.addr)); os_bzero(gw2mssr.gw, sizeof(gw2mssr.gw)); os_memcpy(gw2mssr.gw, (uint8_t *)&info_ipv4.gw.addr, sizeof(info_ipv4.gw.addr)); os_bzero(gw2mssr.mac, sizeof(gw2mssr.mac)); os_memcpy(gw2mssr.mac, mac, sizeof(mac)); } com_send(&gw2mssr, sizeof(GetWifi2MeshStationStatusReturn), cid); }
void remote_control() { uint8_t i; comBuf *recvd; com_mode(IFACE_SERIAL, IF_LISTEN); //tell the uart we want to listen while(1) { /* IF_ZERO(&set); //reset the set of interfaces IF_SET(IFACE_TERMINAL, &set); //add stdin to set IF_SET(IFACE_SERIAL, &set); //add serial to set IF_SET(IFACE_UDP, &set); //become a server com_select(&set,COM_BLOCK); //wait for a device to respond */ // if(IF_ISSET(IFACE_SERIAL,&set)){ //something on serial line // recvd = com_recv(IFACE_SERIAL); //retrieve data from serial // com_send(IFACE_TERMINAL, recvd); //send data to terminal //TODO: forward traffic over the network // com_free_buf(recvd); // fflush (stdout); //show the string incase no \n // else if(IF_ISSET(IFACE_TERMINAL,&set)){//user typed something recvd = com_recv(IFACE_TERMINAL); //get the data com_send(IFACE_UDP,recvd); com_free_buf(recvd); // if(!command_parse(local_commands,recvd->data)){//local command? // send_to_nymph(recvd->data); //} } }
void ext_flash_read() { uint32_t address = 0; //uint8_t data [534]; //uint8_t data[80]; uint16_t i; comBuf pkt; for (i = 0; i < sizeof (data); i++) { data[i] = '0'; } dev_ioctl (DEV_ATMEL_FLASH, DEV_SEEK, address); dev_read (DEV_ATMEL_FLASH, data, sizeof (data)); //printf ("%s", (char *)data); pkt.size = 3; pkt.data[0] = 245; for (i = 0; i < sizeof (data); i++) { //printf ("%c", data[i]); *((uint16_t *)&pkt.data[1]) = data[i]; com_send (IFACE_SERIAL, &pkt); } //printf('\n'); }
/*! measureUS retrieves ultrasonic measure from a given transceiver. * * \param argc number of argument * \param argv first param (argv[0]) is the us number to read from (1 to 5). * * \return A value : * - 0 if success * - <0 if any error * */ int GetUS( int argc, string * argv) { char Buffer[MAXBUFFERSIZE],buf[MAXBUFFERSIZE]; int i; if(kh3_measure_us((char *)Buffer, atoi(argv[0]), dsPic)) { sprintf(buf,"g,%d",(Buffer[1] | Buffer[2]<<8)); for(i=0;i<5;i++) { sprintf(buf+strlen(buf),",%d,%d,%ld",(Buffer[3+8*i] | Buffer[4+8*i]<<8),(Buffer[5+8*i] | Buffer[6+8*i]<<8),(long int)(Buffer[7+8*i] | Buffer[8+8*i]<<8 | Buffer[9+8*i]<<16 | Buffer[10+8*i]<<24)); } sprintf(buf+strlen(buf),",%d\r\n",(Buffer[43] | Buffer[44]<<8)); com_send(buf, strlen(buf)); return 0; } return -1; }
void sink_thread(){ comBuf *recv_pkt; //give us a packet pointer com_mode(IFACE_RADIO, IF_LISTEN); send_pkt.size =1; send_pkt.data[0] = 99; com_send(IFACE_RADIO, &send_pkt); // printf("before entering the while loop\n"); while(1) { recv_pkt = com_recv(IFACE_RADIO); //blocking recv a packet printf("Src = %C Seq = %C Type = %C Size = %C TS = %l TCNT = %C RSSI = %l\n", recv_pkt->data[0], recv_pkt->data[1], recv_pkt->data[2], recv_pkt->size, recv_pkt->ts, recv_pkt->tcnt, recv_pkt->signal); com_free_buf(recv_pkt); //free the recv'd packet to the pool mos_led_toggle(0); } }
/*! set led * * \param argc number of argument * \param argv first param (argv[0]) is led index * second param (argv[1]) is led state to set * * \return A value : * - 0 if success * - <0 if any error */ int SetLED(int argc,string * argv) { int rc; char buf[MAXBUFFERSIZE]; /* Frame format : { Size, Command, Terminator } * where the command can be more than 1 byte */ char cmd[5] = { 4, 'K', 0, 0, 0}; cmd[2] = (char)atoi(argv[0]); cmd[3] = (char)atoi(argv[1]); if(dsPic) { kh3_sendcommand( dsPic , cmd ); rc = kh3_getcommand( dsPic, buf ); sprintf(buf,"k\r\n"); com_send(buf, strlen(buf)); #ifdef DEBUG printf("\nSetLED : number %d state %d",cmd[2],cmd[3]); #endif return rc; } return 0; }
/*! ambIR retrieves ambiant ir measure using kb_khepera3.c library. * * \param narg number of argument * \param larg argument array * * \return A value : * - 0 if success * - <0 if any error */ int ReadAmbSensors(int narg, string *larg) { char Buffer[MAXBUFFERSIZE]; char BufferOut[MAXBUFFERSIZE]; int sensor,i; sprintf(BufferOut,"o"); if(kh3_ambiant_ir((char *)Buffer, dsPic)) { for (i=0;i<11;i++) { sensor=(Buffer[i*2+1] | Buffer[i*2+2]<<8); sprintf(BufferOut+strlen(BufferOut),",%d",sensor); } sprintf(BufferOut+strlen(BufferOut),",%lu\r\n",((Buffer[23] | Buffer[24]<<8 ) | ( Buffer[25] | Buffer[26]<<8)<<16)); com_send(BufferOut, strlen(BufferOut)); #ifdef DEBUG printf("\nReadAmbSensors : %s\n",BufferOut); #endif return 0; } return -1; }
void Err(void) { printf(ERR); // bioscom(_COM_SEND,255,port); com_send(0xff); buf_init(); }
void ICACHE_FLASH_ATTR com_return_setter(const int8_t cid, const void *data) { if(((MessageHeader*)data)->return_expected) { MessageHeader ret = *((MessageHeader*)data); ret.length = sizeof(MessageHeader); com_send(&ret, sizeof(MessageHeader), cid); } }
/*! Configure PID * * \param argc number of argument * \param argv first param (argv[0]) is 0 speed control or 1 position control * second param (argv[1]) is the Kp parameter * third param (argv[2]) is the Ki parameter * forth param (argv[3]) is the Kd parameter * * \return A value : * - 0 if success * - <0 if any error */ int ConfigPID( int argc, string *argv) { char Buffer[MAXBUFFERSIZE]; if(mot1!=0 && mot2!=0) { // remove 16 bit indicator argv[0][0]=' '; argv[1][0]=' '; argv[2][0]=' '; argv[3][0]=' '; if (atoi(argv[0])) { // position control kmot_ConfigurePID( mot1,kMotRegPos,atoi(argv[1]),atoi(argv[3]),atoi(argv[2])); // kp kd ki kmot_ConfigurePID( mot2,kMotRegPos,atoi(argv[1]),atoi(argv[3]),atoi(argv[2])); // kp kd ki } else { // speed control kmot_ConfigurePID( mot1,kMotRegSpeed,atoi(argv[1]),atoi(argv[3]),atoi(argv[2])); // kp kd ki kmot_ConfigurePID( mot2,kMotRegSpeed,atoi(argv[1]),atoi(argv[3]),atoi(argv[2])); // kp kd ki } sprintf(Buffer,"h\r\n"); com_send(Buffer, strlen(Buffer)); return 0; } return -1; }
uint16_t dev_write_DEV_MICA2_GPS(const void* buffer, uint16_t len) { //while ( !(UCSR1A & (1 << RXC1))); gps_disable_bits(GPS_TX_ADDR); gps_enable_bits(GPS_RX_ADDR); // com_mode(IFACE_SERIAL2, IF_LISTEN); com_ioctl(IFACE_SERIAL2, UART_IOCTL_RAW_MODE0); // com_ioctl(IFACE_SERIAL2, UART_IOCTL_BAUD_RATE, B4800); comBuf b; memcpy(b.data, buffer, len); b.size = len; com_send(IFACE_SERIAL2, &b); UART1_WAIT_FOR_TXC(); gps_disable_bits(GPS_RX_ADDR); gps_enable_bits(GPS_TX_ADDR); return DEV_OK; }
void test_recv(void) { comBuf to_send; str_to_packet(&to_send,"hi mom\n"); com_send(IFACE_TERMINAL, &to_send); str_to_packet(&to_send,"type something to test (it should echo)\n"); com_send(IFACE_TERMINAL, &to_send); packet = com_recv(IFACE_TERMINAL); if(packet != NULL) { com_send(IFACE_TERMINAL,packet); com_free_buf(packet); } }
/*! GetMotPos get the motor position. * * \param argc number of argument * \param argv first param (argv[0]) is the motor1 position. * second param (argv[1]) is the motor2 position. * * \return A value : * - 0 if success * - <0 if any error */ int ReadPos( int argc, string *argv) { char Buffer[MAXBUFFERSIZE]; int left,right; if(mot1!=0 && mot2!=0) { left = kmot_GetMeasure( mot1 , kMotMesPos ); right = kmot_GetMeasure( mot2 , kMotMesPos ); #ifdef DEBUG printf("\nReadPos : left %d right %d",left,right); #endif sprintf(Buffer,"r,%d,%d\r\n",left,right); com_send(Buffer, strlen(Buffer)); return 0; } return -1; }
/*! SetSpeed configures the motor controller speed in the engine control unit. * * \param argc number of argument * \param argv first param (argv[0]) is the motor1 speed. * 2nd second param (argv[1]) is the motor2 speed. * * \return A value : * - 0 if success * - <0 if any error */ int SetSpeed( int argc, string *argv) { char Buffer[MAXBUFFERSIZE]; if(mot1!=0 && mot2!=0) { // remove 32 bit indicator argv[0][0]=' '; argv[1][0]=' '; #ifdef DEBUG printf("\nSetSpeed : argv[0] %s %d argv[1] %s %d",argv[0],atoi(argv[0]),argv[1],atoi(argv[1])); #endif kmot_SetPoint( mot1 , kMotRegSpeed , atol(argv[0])); kmot_SetPoint( mot2 , kMotRegSpeed , atol(argv[1])); sprintf(Buffer,"d\r\n"); com_send(Buffer, strlen(Buffer)); return 0; } return -1; }
// Send data(Commands) to URG int urg_sendTag(const char* tag) { char send_message[LineLength]; wsprintf(send_message, "%s\n", tag); int send_size = strlen(send_message); com_send(send_message, send_size); return send_size; }
void ICACHE_FLASH_ATTR get_wifi2_client_hostname(const int8_t cid, const GetWifi2ClientHostname *data) { GetWifi2ClientHostnameReturn gw2chr; gw2chr.header = data->header; gw2chr.header.length = sizeof(GetWifi2ClientHostnameReturn); os_memcpy(gw2chr.hostname, configuration_current.client_hostname, CONFIGURATION_HOSTNAME_MAX_LENGTH); com_send(&gw2chr, sizeof(GetWifi2ClientHostnameReturn), cid); }
void ICACHE_FLASH_ATTR is_wifi2_status_led_enabled(const int8_t cid, const IsWifi2StatusLEDEnabled *data) { IsWifi2StatusLEDEnabledReturn iw2sleder; iw2sleder.header = data->header; iw2sleder.header.length = sizeof(IsWifi2StatusLEDEnabledReturn); iw2sleder.enabled = wifi2_status_led_enabled; com_send(&iw2sleder, sizeof(IsWifi2StatusLEDEnabledReturn), cid); }
void ICACHE_FLASH_ATTR get_wifi2_authentication_secret(const int8_t cid, const GetWifi2AuthenticationSecret *data) { GetWifi2AuthenticationSecretReturn gw2asr; gw2asr.header = data->header; gw2asr.header.length = sizeof(GetWifi2AuthenticationSecretReturn); os_memcpy(gw2asr.secret, configuration_current.general_authentication_secret, CONFIGURATION_SECRET_MAX_LENGTH); com_send(&gw2asr, sizeof(GetWifi2AuthenticationSecretReturn), cid); }
static uint8_t dvdrp_send_route_advert(dvdrp_route *route, uint8_t htl) { dvdrp_advert_pkt *advert_pkt = (dvdrp_advert_pkt*)&(local_pkt.data[0]); dvdrp_filter_list *f_list; dvdrp_filter *cur_f; dvdrp_constraint_list *c_list; uint8_t num_c, num_f, constraint_size, orig_size; orig_size = local_pkt.size = 0; advert_pkt->header.pkt_type = DVDRP_ADVERT_PKT; advert_pkt->header.htl = htl; advert_pkt->receiver_id = route->receiver_id; advert_pkt->prev_hop = node_id; advert_pkt->seq_num = route->seq; advert_pkt->bv_pos = route->bv_pos; advert_pkt->min_delay = route->min_delay; local_pkt.size = 13; //bytes up to this point, inc. pred.num_filters f_list = route->pred; num_f = 0; cur_f = &advert_pkt->pred.filters[0]; while(f_list) { c_list = f_list->constraints; constraint_size = num_c = 0; while(c_list) { cur_f->constraints[num_c].name = c_list->name; cur_f->constraints[num_c].value = c_list->value; cur_f->constraints[num_c++].compare_type = c_list->compare_type; c_list = c_list->next; constraint_size += sizeof(dvdrp_constraint); // printf("c\n"); } cur_f->num_constraints = num_c; constraint_size += sizeof(uint8_t); cur_f += constraint_size; local_pkt.size += constraint_size; f_list = f_list->next; num_f++; // printf("f\n"); } advert_pkt->pred.num_filters = num_f; local_pkt.data[local_pkt.size++] = local_pkt.size - orig_size; /* Add the proto ID to the end of the packet. */ local_pkt.data[local_pkt.size++] = DVDRP_PROTO_ID; // print_packet(&local_pkt); com_send(IFACE_RADIO, &local_pkt); // printf("Sent advert.\n"); return local_pkt.size; }
void ICACHE_FLASH_ATTR get_wifi2_ap_password(const int8_t cid, const GetWifi2APPassword *data) { GetWifi2APPasswordReturn gw2appr; gw2appr.header = data->header; gw2appr.header.length = sizeof(GetWifi2APPasswordReturn); os_memcpy(gw2appr.password, configuration_current.ap_password, CONFIGURATION_PASSWORD_MAX_LENGTH); com_send(&gw2appr, sizeof(GetWifi2APPasswordReturn), cid); }
void send_packet(uint8_t packet_id) { static uint8_t inited = 0; uint16_t temp; uint16_t hum; if (!inited) { inited = 1; dev_open(DEV_MSP_HUMIDITY); if (dev_mode(DEV_MSP_HUMIDITY, DEV_MODE_ON) == DEV_FAILURE) { no_sensor = 1; } } mos_mutex_lock(&send_mutex); if (no_sensor) { temp = rand(); hum = rand(); } else { dev_read(DEV_MSP_TEMPERATURE, &temp, sizeof(temp)); dev_read(DEV_MSP_HUMIDITY, &hum, sizeof(hum)); } buf.size = 13; buf.data[0] = packet_id; buf_insert_WORD(buf.data, 1, mos_node_id_get()); buf_insert_WORD(buf.data, 3, temp); buf_insert_WORD(buf.data, 5, hum); if (no_sensor) { buf_insert_WORD(buf.data, 7, rand()); buf_insert_WORD(buf.data, 9, rand()); } else { buf_insert_WORD(buf.data, 7, adc_get_conversion16(4)); buf_insert_WORD(buf.data, 9, adc_get_conversion16(5)); } buf_insert_WORD(buf.data, 11, crc_compute(buf.data, 11)); com_send(IFACE_RADIO, &buf); mos_mutex_unlock(&send_mutex); }
void ICACHE_FLASH_ATTR get_wifi2_firmware_version(const int8_t cid, const GetWifi2FirmwareVersion *data) { GetWifi2FirmwareVersionReturn gw2fvr; gw2fvr.header = data->header; gw2fvr.header.length = sizeof(GetWifi2FirmwareVersionReturn); gw2fvr.version_fw[0] = FIRMWARE_VERSION_MAJOR; gw2fvr.version_fw[1] = FIRMWARE_VERSION_MINOR; gw2fvr.version_fw[2] = FIRMWARE_VERSION_REVISION; com_send(&gw2fvr, sizeof(GetWifi2FirmwareVersionReturn), cid); }
void sendFinished(deluge_app* app, comBuf* pkt, uint8_t port) { /*deluge_foot_command* command = (deluge_foot_command*)pkt->data; command->seq = ++seqNo; command->command = DELUGE_COMMAND_FINISHED; command->to = -1; command->id = mos_node_id_get(); command->type = DELUGE_PACKET_COMMAND; pkt->size = sizeof(deluge_foot_command); net_send(pkt, DELUGE_PROTO_ID, port, port);*/ logHeader(&spkt, DELUGE_COMMAND_FINISHED); com_send(IFACE_SERIAL, &spkt); }
void tx_thread(void) { while(1) { send_buf.size = read_sensors(&send_buf); com_send(IFACE_RADIO, &send_buf); printf("[TX] sent %d bytes\n", send_buf.size); mos_led_toggle(0); mos_thread_sleep(5000); } }