Ejemplo n.º 1
0
void AgentuinoClass::listen(void) {
    // if bytes are available in receive buffer
    // and pointer to a function (delegate function)
    // isn't null, trigger the function
    Udp.parsePacket();
    if (Udp.available() && _callback != NULL) (*_callback)();
}
Ejemplo n.º 2
0
void uartToUdp()
{
  bool sendIt = false;

  if (Serial.available() > 0)
  {
    uartBuffer[uartCounter] = Serial.read();
    if (uartBuffer[uartCounter] == HDLC_SS_BYTE)
    {
      if (hdlcStart)sendIt = true;
      else
      {
        hdlcStart = true;
        Timer1.start();
      }
    }
    else if (hdlcStart)
    {
      ++uartCounter;
    }
  }

  if (sendIt)
  {
    Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
    Udp.write(uartBuffer, uartCounter);
    Udp.endPacket();
    resetUartBuffer();
  }
}
Ejemplo n.º 3
0
void WakeOnLan::send(byte* mac, byte port, EthernetUDP udp) {

    byte preamble[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
	
    byte i;

    udp.beginPacket(_ip, port);
	
    udp.write(preamble, sizeof preamble);
    
    for (i = 0; i < 16; i++)
	
      udp.write(mac, sizeof mac);
      
    udp.endPacket();

#else // ARDUINO not defined or ARDUINO < 100

void WakeOnLan::send(byte* mac, byte port) {

	byte magic_packet[102] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
	
	for (byte i = 6; i < 102; i++)
	{
		magic_packet[i] = mac[i%6];		
	}
	
	Udp.sendPacket(magic_packet, 102, _ip, port);	

#endif // #if defined(ARDUINO) && ARDUINO >= 100

}
Ejemplo n.º 4
0
SNMP_API_STAT_CODES SNMPClass::begin(const char *getCommName, const char *setCommName, const char *trapCommName, uint16_t port)
{
  //initialize request counter
    requestCounter = 1;
    _extra_data_size = 0;
    _udp_extra_data_packet = false;
    
  // set community name set/get sizes
  _setSize = strlen(setCommName);
  _getSize = strlen(getCommName);
  _trapSize = strlen(trapCommName);
  //
  // validate get/set community name sizes
  if ( _setSize > SNMP_MAX_NAME_LEN + 1 || _getSize > SNMP_MAX_NAME_LEN + 1 || _trapSize > SNMP_MAX_NAME_LEN + 1) {
    return SNMP_API_STAT_NAME_TOO_BIG;
  }
  //
  // set community names
  _getCommName = getCommName;
  _setCommName = setCommName;
  _trapCommName = trapCommName;
  
  // validate session port number
  if ( port == NULL || port == 0 ) port = SNMP_DEFAULT_PORT;
  //
  // init UDP socket
  Udp.stop();
  Udp.begin(port);

  return SNMP_API_STAT_SUCCESS;
}
Ejemplo n.º 5
0
void sendNTPpacket(const byte *address)
/**
 * send an NTP request to the time server at the given address
 */
{
    // set all bytes in the buffer to 0
    memset(pb, 0, NTP_PACKET_SIZE);

    // Initialize values needed to form NTP request
    // (see URL above for details on the packets)
    pb[0] = 0b11100011;   // LI, Version, Mode
    pb[1] = 0;     // Stratum, or type of clock
    pb[2] = 6;     // Polling Interval
    pb[3] = 0xEC;  // Peer Clock Precision
    // 8 bytes of zero for Root Delay & Root Dispersion
    pb[12]  = 49;
    pb[13]  = 0x4E;
    pb[14]  = 49;
    pb[15]  = 52;

    // all NTP fields have been given values, now
    // you can send a packet requesting a timestamp:
    Udp.beginPacket(address, 123); //NTP requests are to port 123
    Udp.write(pb,NTP_PACKET_SIZE);
    Udp.endPacket();
}
time_t getNtpTime()
{
  while (Udp.parsePacket() > 0) ; // discard any previously received packets
  Serial.println("Transmit NTP Request");
  sendNTPpacket(ntp_server);
  uint32_t beginWait = millis();
  while (millis() - beginWait < 2000) {
    int size = Udp.parsePacket();
    if (size >= NTP_PACKET_SIZE) {
      Serial.println("Receive NTP Response");
      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
      unsigned long secsSince1900;
      unsigned long fracSecs;
      // convert four bytes starting at location 40 to a long integer
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      fracSecs =  (unsigned long)packetBuffer[44] << 24;
      fracSecs |= (unsigned long)packetBuffer[45] << 16;
      fracSecs |= (unsigned long)packetBuffer[46] << 8;
      fracSecs |= (unsigned long)packetBuffer[47];
      return ((time_t)(secsSince1900 - 2208988800UL)<<32) + fracSecs;
    }
  }
  Serial.println("No NTP Response :-(");
  return 0; // return 0 if unable to get the time
}
Ejemplo n.º 7
0
int readUdp( char * buf, int size )
{
  if ( ! active ) return 0 ;
  int count = Udp.parsePacket() ;
  if ( count ) Udp.read( buf, size ) ;
  return count ;
}
Ejemplo n.º 8
0
roveEthernet_Error roveEthernet_SendUdpPacket(roveIP destIP, uint16_t destPort, const uint8_t* msg, size_t msgSize)
{
  udpReceiver.beginPacket(destIP, destPort);
  udpReceiver.write(msg, msgSize);
  udpReceiver.endPacket();
  return ROVE_ETHERNET_ERROR_SUCCESS;
}
Ejemplo n.º 9
0
// --------------------------------------------------- Ethernet Send Data -----------------------------------------------------------
void UDP_Send_Data()

{
	Udp.beginPacket(ip_rpi, rpi_port);
	Udp.write(nav.ch, sizeof(nav.data));
	Udp.write(cam.ch, sizeof(cam.pose));
	Udp.write(imu.ch, sizeof(imu.imu_data));
	Udp.endPacket();
}
Ejemplo n.º 10
0
int sendUdp( char * data, int size )
{
  if ( ! active ) return 0 ;
  
  Udp.beginPacket(*timeServerAddress, serverPort);
  byte count = Udp.write((const unsigned char *)data,size);
  Udp.endPacket();
  return (int) count ;
}
Ejemplo n.º 11
0
// This function's purpose is to receive data and prepare it for parsing
void RobotOpenClass::handleData() {
	_packetBufferSize = Udp.parsePacket();
    
    // If there's data, read the packet in
    if (_packetBufferSize > 0) {
		_remotePort = Udp.remotePort();
		_remoteIp = Udp.remoteIP();
		Udp.read(_packetBufferAccessor, 256);
		parsePacket();	// Data is all set, time to parse through it
    }
}
Ejemplo n.º 12
0
void SNMPClass::writePacket(IPAddress address, uint16_t port, char *extra_data)
{
  Udp.beginPacket(address, port);
  Udp.write(_packet+_packetPos+1, _packetSize);
  
  if(extra_data != NULL){
    Udp.write((byte*)extra_data, _extra_data_size);
  }
  
  Udp.endPacket();
}
Ejemplo n.º 13
0
/*
 * Restart our ntp handler.  This is only done as part of restarting the
 * network.  As such, all we want to do is make sure udp is still working.
 * We dont need to issue a time request unless one was already outstanding
 * (not likely)
 */
void restartNtpTime() {

	Udp.stop();

	Udp.begin(8888);

	// If we were already waiting for a response, let's re-issue the request
	if (ntpState == WAITING_FOR_RESPONSE) {
		sendTimeRequest();
	}

}
Ejemplo n.º 14
0
void udpToUart()
{
  int packetSize = Udp.parsePacket();
  if(packetSize)
  {
    // read the packet into packetBufffer
    Udp.read(udpBuffer,MAX_HDLC_FRAME_SIZE);
    Serial.write(HDLC_SS_BYTE);
    Serial.write(udpBuffer, packetSize);
    Serial.write(0x12);
    Serial.write(0x34);
    Serial.write(HDLC_SS_BYTE);
  }
}
Ejemplo n.º 15
0
bool gatewayTransportInit() {
	_w5100_spi_en(true);
	#if defined(MY_GATEWAY_ESP8266)
		#if defined(MY_ESP8266_SSID)
			// Turn off access point
			WiFi.mode (WIFI_STA);
			#if defined(MY_ESP8266_HOSTNAME)
				WiFi.hostname(MY_ESP8266_HOSTNAME);
			#endif
			(void)WiFi.begin(MY_ESP8266_SSID, MY_ESP8266_PASSWORD);
			#ifdef MY_IP_ADDRESS
				WiFi.config(_ethernetGatewayIP, _gatewayIp, _subnetIp);
			#endif
			while (WiFi.status() != WL_CONNECTED)
			{
				delay(500);
				MY_SERIALDEVICE.print(".");
				yield();
			}
			MY_SERIALDEVICE.print(F("IP: "));
			MY_SERIALDEVICE.println(WiFi.localIP());
		#endif

	#else
		#ifdef MY_IP_ADDRESS
			Ethernet.begin(_ethernetGatewayMAC, _ethernetGatewayIP);
		#else
			// Get IP address from DHCP
			if (!Ethernet.begin(_ethernetGatewayMAC)) {
				MY_SERIALDEVICE.print("DHCP FAILURE...");
				_w5100_spi_en(false);
				return false;
			}
		#endif 
		MY_SERIALDEVICE.print(F("IP: "));
		MY_SERIALDEVICE.println(Ethernet.localIP());
		// give the Ethernet interface a second to initialize
		delay(1000);
	#endif

	#ifdef MY_USE_UDP
		_ethernetServer.begin(_ethernetGatewayPort);
	#else
		// we have to use pointers due to the constructor of EthernetServer
		_ethernetServer.begin();
	#endif /* USE_UDP */
	_w5100_spi_en(false);
	return true;
}
Ejemplo n.º 16
0
roveEthernet_Error roveEthernet_GetUdpMsg(roveIP* senderIP, void* buffer, size_t bufferSize)
{
  int packetSize = udpReceiver.parsePacket(); 
  
  if (packetSize > 0) //if there is a packet available
  {
    udpReceiver.read((char*)buffer, bufferSize);
    *senderIP = udpReceiver.remoteIP();
    return ROVE_ETHERNET_ERROR_SUCCESS;
  }
  else
  {
    return ROVE_ETHERNET_ERROR_WOULD_BLOCK;
  }
}
Ejemplo n.º 17
0
void SyncTime_setup() 
{
  Udp.begin(LOCALPORT);
  setSyncProvider(getNtpTime);
  while(timeStatus()== timeNotSet)   
     ; // wait until the time is set by the sync provider
}
Ejemplo n.º 18
0
/*
 * Initialize our ntp client. 
 * 
 * We need ntp time in order to have a valid, up-to-date time
 * in order to create timestamps for the data we collect.  If we dont have
 * valid time, then there's no use returning since we cant collect data
 * without valid time. 
 *
 * Note, however, that now() will still keep track of time - it will just
 * be relative to when we booted.
 */
void initNtpTime() {

	Udp.begin(8888);

	setSyncProvider(0);  // We will take care of synching time ourselves,
					   // so tell time library there's no external time source

	sendTimeRequest();	// send an initial time request to kickstart things
	
	// Wait until our request is completed.  Note that this is initialization,
	// so if we dont have a good time value, we cant collect data because
	// we wont be able to create valid timestamps.
	int retryCount = 500;
	while (ntpState == WAITING_FOR_RESPONSE) {
		delay(500);
		serviceNtpTime();
		if (--retryCount <=0) {
			// We've been trying for a while to get the time.  Let's try
			// restarting in case the network didnt come up right last time.
			retryCount = 500;
			startEthernet();  // Let's try restarting the ethernet
			restartNtpTime();
		}
	}

	if (bootTime == 0) {
	bootTime = now();
	}

  
}
void setup_ntp(){
  // setup NTP sync service
  Udp.begin(ntp_port);
  Serial.println(F("Waiting for NTP sync"));
  setSyncInterval(600); // initial one 10 minutes to take care of most of the drift
  setSyncProvider(getNtpTime);
}
Ejemplo n.º 20
0
/*
 * Perform housekeeping needed to keep ntp time up to date.
 *
 * This essentially involves occasionally re-syncing our
 * time with a time server so our internal clock doesnt
 * drift too far.
 *
 */
void serviceNtpTime() {
  
	switch (ntpState) {
		case NTP_IN_SYNC :   
			// Check to see if we need to re-sync
			if ((ntpLastSyncTime + SYNC_INTERVAL) < now()) {
				sendTimeRequest();
			}
			break;
		case WAITING_FOR_RESPONSE :
			// See if we've received a response to a sync request yet
			if ( Udp.parsePacket() ) {
				ntpLastSyncTime = parseNtpPacket();
				setTime(ntpLastSyncTime);
				ntpState = NTP_IN_SYNC;
				Serial.print("Updated time: ");
				Serial.println(now());
			} else if ((lastNtpRequestTime + MAX_WAIT_INTERVAL) < now()) {
				// We've been waiting a while now and we're probably not going
				// to get a response, so let's try the next server in the list
				Serial.println("No ntp response");
				sendTimeRequest();
			}
			break;
	}
  
}
unsigned long getNtpTime()
{
	// We need to call the begin to reset the socket.
	// Because localClient.connect() may occupy the same socket.
	EthernetUDP theUDP;
	theUDP.begin(localPort);

	Serial.println("Sending time sync request to NTP server.");
	sendNTPpacket(timeServer); // send an NTP packet to a time server

	unsigned long startMillis = millis();
	int tryCounter = 1;
	while( millis() - startMillis < 1000)  // wait up to one second for the response
	{  // wait to see if a reply is available
		if ( theUDP.available() )
		{
			theUDP.readPacket(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer

			//the timestamp starts at byte 40 of the received packet and is four bytes,
			// or two words, long. First, esxtract the two words:
			unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
			unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
			// combine the four bytes (two words) into a long integer
			// this is NTP time (seconds since Jan 1 1900):
			unsigned long secsSince1900 = highWord << 16 | lowWord;
			// now convert NTP time into Arduino Time format:
			// Time starts on Jan 1 1970. In seconds, that's 2208988800:
			const unsigned long seventyYears = 2208988800UL;
			// subtract seventy years:
			unsigned long epoch = secsSince1900 - seventyYears;

			Serial.println("Time sync successfully.");

			return epoch;
		}

		Serial.print("No date data available. Try counter: .");
		Serial.println(tryCounter++);
		delay(100);
	}

	Serial.println("Time sync failed.");

	return 0;   // return 0 if unable to get the time
}
Ejemplo n.º 22
0
void setup() {
  // start the Ethernet and UDP:
  Ethernet.begin(mac,ip);
  Udp.begin(localPort);
  pinMode(13,OUTPUT);
  pinMode(12,OUTPUT);
  pinMode(11,OUTPUT);
  pinMode(10,OUTPUT);
}
Ejemplo n.º 23
0
void SyslogClass::logger(uint8_t facility, uint8_t severity, const char tag[], const char message[]) {
        String Pri;

        Pri="<";
        Pri+=(8 * facility + severity);
        Pri+=">";
  
        char UDPBufferPri[Pri.length()+1];
        Pri.toCharArray(UDPBufferPri,Pri.length()+1);

        SyslogUdp.beginPacket(ip_syslogserver, SYSLOG_DEFAULT_PORT);

        SyslogUdp.write(UDPBufferPri);
        SyslogUdp.write(tag);
        SyslogUdp.write(" ");
        SyslogUdp.write(message);
        SyslogUdp.endPacket();
}
Ejemplo n.º 24
0
void setup()
{
  Serial.begin(9600);
  // start the Ethernet and UDP:
  Ethernet.begin(mac,ip);
  Udp.begin(localPort);

  Timer1.initialize(TIMER_PERIOD);
  Timer1.attachInterrupt(TimerLoop);
  Timer1.stop();
}
void UdpController::Loop()
{
    unsigned long currentMillis = millis();
    int packetSize = Udp.parsePacket();

    if (packetSize && packetSize == 3)
    {
        Udp.read(Buffer, UDP_TX_PACKET_MAX_SIZE);

        if (Buffer[0] == 0x28 && Buffer[1] == 0x06)
        {
            _traffic->SetMode((LightMode)Buffer[2]);
            _lastUpdateMillis = currentMillis;
        }
    }

    if ((currentMillis - _lastUpdateMillis) > UpdateIntervalMillis)
    {
        _traffic->ShowInconclusive();
    }
}
Ejemplo n.º 26
0
bool SetupUdpClient ( void )
{
    bool success = false;

#ifdef INTERFACE_ETHERNET
#ifdef ETHERNET_UDPCLIENT
    success = (bool)Udp.begin(localPort);
#endif //ETHERNET_UDPCLIENT
#endif // INTERFACE_ETHERNET

    return success;
}
Ejemplo n.º 27
0
boolean SNMPClass::listen(void)
{
  // if bytes are available in receive buffer
  // and pointer to a function (delegate function)
  // isn't null, trigger the function
  
  if(Udp.parsePacket() > 1024){
    _udp_extra_data_packet = true;
  }else{
    _udp_extra_data_packet = false;
  }
  
  if (Udp.available()){
    if(_callback != NULL){
      (*_callback)();
    }else{
      return true;
    }
  }
  
  return false;
}
void UdpController::Setup()
{
    if (Ethernet.begin(MacAddress) == 0)
    {
        _traffic->ShowError();
        for(;;);
    }

    Udp.begin(Port);

    _traffic->ShowInconclusive();
    _lastUpdateMillis = millis();
}
Ejemplo n.º 29
0
unsigned long getNtpTime()
{
  sendNTPpacket(timeServer); // send an NTP packet to a time server

    // wait to see if a reply is available
  delay(1000);  
  if ( Udp.parsePacket() ) {  
    // We've received a packet, read the data from it
    Udp.read(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer

    //the timestamp starts at byte 40 of the received packet and is four bytes,
    // or two words, long. First, esxtract the two words:

    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  
    // combine the four bytes (two words) into a long integer
    // this is NTP time (seconds since Jan 1 1900):
    unsigned long secsSince1900 = highWord << 16 | lowWord;  
    #ifdef LOGGING
    Serial.print("Seconds since Jan 1 1900 = " );
    Serial.println(secsSince1900);               
    #endif

    // now convert NTP time into everyday time:
    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
    const unsigned long seventyYears = 2208988800UL;     
    // subtract seventy years:
    unsigned long epoch = secsSince1900 - seventyYears;  
    // print Unix time:
    #ifdef LOGGING
    Serial.print(UNIX_TIME);
    Serial.println(epoch);                               
    #endif
    return epoch;
  }
   
  return 0; // return 0 if unable to get the time
}
Ejemplo n.º 30
0
/*
 * Send an NTP request to get the current time.
 *
 * This code was lifted from sample code that was part of an
 * arduino ntp libary.
 */
time_t parseNtpPacket() {
  
  Udp.read(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer

  unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
  unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  

  unsigned long ntpTime = highWord << 16 | lowWord;  

  return (ntpTime - 2208988800UL);  // NTP time is based on 01-Jan-1900, but
									// we want Unix time which is seconds 
									// since 01-Jan-1970
  
}