Example #1
0
/****************************************************************************
 *
 *  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;
}
Example #2
0
/** @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);
}
Example #3
0
File: recv.c Project: eswartz/emul
void	ps(char *st)
{
	unsigned char len=strlen(st);

	delay(100);

	com_send(len);
	while (len--)
		com_send(*st++);

}
Example #4
0
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');
}
Example #10
0
/*! 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;
	
}
Example #11
0
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);
   }
}
Example #12
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;
}	
Example #13
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;	
}
Example #14
0
File: recv.c Project: eswartz/emul
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);
	}
}
Example #16
0
/*! 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;	
}
Example #17
0
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;
   
}
Example #18
0
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);
    }
}
Example #19
0
/*! 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;
}
Example #20
0
/*! 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;
}
Example #21
0
// 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);
}
Example #25
0
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);
}
Example #27
0
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);
}
Example #29
0
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);
}
Example #30
0
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);
   }
}