Arduino.ru

При компиляции вылетает вот такая ошибка

(.text+0x0): multiple definition of `Udp'

никак не могу понять почему.

сечас работает сборка ethernet с tcp SNMP , есть необходимость настроить UDP NTP

 
#include <Ethernet.h>
#include <EthernetUdp.h>            
#include <Agentuino.h> 
#include <SPI.h> 

 float temp2 = 0;
 float temp3 = 0;
 float temp4 = 0;
 float temp5 = 0;

const char  reg= "C";                                        //C=Temperature in Centigrade, F=Temperature in Farenheight
static byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };  //Mac Address for Arduino Ethernet Shield
static byte ip[] = { 192, 168, 111, 33 };                    //IP Address for Arduino Ethernet Shield
static byte gateway[] = { 192, 168, 111, 1 };
static byte subnet[] = { 255, 255, 255, 0 };

int term2=0;                                                 
int term3=0;                                                 
int term4=0;                                                 
int term5=0;                                                 

unsigned int localPort = 8647;
IPAddress timeServer(132, 163, 4, 101); // NTP-сервер time-a.timefreq.bldrdoc.gov 
const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
EthernetUDP Udp;

const int timeZone PROGMEM = 3;                   // TimeZone
const char sysDescr[] PROGMEM      = "1.3.6.1.2.1.1.1.0";  // System Description
const char sysContact[] PROGMEM    = "1.3.6.1.2.1.1.4.0";  // System Contact
const char sysName[] PROGMEM       = "1.3.6.1.2.1.1.5.0";  // System Name
const char sysLocation[] PROGMEM   = "1.3.6.1.2.1.1.6.0";  // System Location
const char sysServices[] PROGMEM   = "1.3.6.1.2.1.1.7.0";  // System Services

//My Custom OID's

const char temperature2[]       PROGMEM     = "1.3.6.1.3.2016.5.0.2";     //Temperature in Celsius
const char temperature3[]       PROGMEM     = "1.3.6.1.3.2016.5.0.3";     //Temperature in Celsius
const char temperature4[]       PROGMEM     = "1.3.6.1.3.2016.5.0.4";     //Temperature in Celsius
const char temperature5[]       PROGMEM     = "1.3.6.1.3.2016.5.0.5";     //Temperature in Celsius
 
// RFC1213 local values

static char locDescr[]              = "SNMP Temperature monitoring";                 // read-only (static)
static char locContact[50]          = "radio-portal.ru";             
static char locName[20]             = "ServerRoom";                              
static char locLocation[20]         = "Planet Earth";                          
static int32_t locServices          = 2;                                             // read-only (static)

uint32_t prevMillis = millis();
char oid[SNMP_MAX_OID_LEN];
SNMP_API_STAT_CODES api_status;
SNMP_ERR_CODES status;
 

void pduReceived()

{

  SNMP_PDU pdu;
  api_status = Agentuino.requestPdu(&pdu);

  if ((pdu.type == SNMP_PDU_GET || pdu.type == SNMP_PDU_GET_NEXT || pdu.type == SNMP_PDU_SET)
    && pdu.error == SNMP_ERR_NO_ERROR && api_status == SNMP_API_STAT_SUCCESS ) {

    pdu.OID.toString(oid);
  

    if ( strcmp_P(oid, sysDescr ) == 0 ) {
      if ( pdu.type == SNMP_PDU_SET ) {
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = SNMP_ERR_READ_ONLY;
      } else {
        status = pdu.VALUE.encode(SNMP_SYNTAX_OCTETS, locDescr);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      } 
    } else if ( strcmp_P(oid, sysName ) == 0 ) {
      if ( pdu.type == SNMP_PDU_SET ) {
        status = pdu.VALUE.decode(locName, strlen(locName)); 
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      } else {
        status = pdu.VALUE.encode(SNMP_SYNTAX_OCTETS, locName);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } else if ( strcmp_P(oid, sysContact ) == 0 ) {
      if ( pdu.type == SNMP_PDU_SET ) {
        status = pdu.VALUE.decode(locContact, strlen(locContact)); 
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      } else {
        status = pdu.VALUE.encode(SNMP_SYNTAX_OCTETS, locContact);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } else if ( strcmp_P(oid, sysLocation ) == 0 ) {
      if ( pdu.type == SNMP_PDU_SET ) {
        status = pdu.VALUE.decode(locLocation, strlen(locLocation)); 
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      } else {
        status = pdu.VALUE.encode(SNMP_SYNTAX_OCTETS, locLocation);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } else if ( strcmp_P(oid, sysServices) == 0 ) {
      if ( pdu.type == SNMP_PDU_SET ) {
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = SNMP_ERR_READ_ONLY;
      } else {
        status = pdu.VALUE.encode(SNMP_SYNTAX_INT, locServices);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }

    }

    else if ( strcmp_P(oid, temperature2 ) == 0 )
    {
      if ( pdu.type == SNMP_PDU_SET ) 
      {      
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = SNMP_ERR_READ_ONLY;
      } 
      else 
      {
        status = pdu.VALUE.encode(SNMP_SYNTAX_INT, term2);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } 
    

  
        else if ( strcmp_P(oid, temperature3 ) == 0 ) 
    {
      if ( pdu.type == SNMP_PDU_SET ) 
      {      
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = SNMP_ERR_READ_ONLY;
      } 
      else 
      {
        status = pdu.VALUE.encode(SNMP_SYNTAX_INT, term3);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } 
    

        else if ( strcmp_P(oid, temperature4 ) == 0 ) 
    {
      if ( pdu.type == SNMP_PDU_SET ) 
      {      
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = SNMP_ERR_READ_ONLY;
      } 
      else 
      {
        status = pdu.VALUE.encode(SNMP_SYNTAX_INT, term4);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } 
    

            else if ( strcmp_P(oid, temperature5 ) == 0 ) 
    {
      if ( pdu.type == SNMP_PDU_SET ) 
      {      
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = SNMP_ERR_READ_ONLY;
      } 
      else 
      {
        status = pdu.VALUE.encode(SNMP_SYNTAX_INT, term5);
        pdu.type = SNMP_PDU_RESPONSE;
        pdu.error = status;
      }
    } 
    

    else {
      pdu.type = SNMP_PDU_RESPONSE;
      pdu.error = SNMP_ERR_NO_SUCH_NAME;
    }
    Agentuino.responsePdu(&pdu);
  }
   Agentuino.freePdu(&pdu);
}
 

void setup()
{
 Serial.begin(9600);
  Ethernet.begin(mac);                     //Initialize Ethernet Shield
  api_status = Agentuino.begin();              //Begin Snmp agent on Ethernet shield
  if ( api_status == SNMP_API_STAT_SUCCESS ) {
    Agentuino.onPduReceive(pduReceived);
    delay(10);
    return;
  }
  Udp.begin(localPort);
}


void loop()
{ 
 
Agentuino.listen();                                 

float kPinTemp2 = analogRead(2);                    
float kPinTemp3 = analogRead(3);  
float kPinTemp4 = analogRead(4);  
float kPinTemp5 = analogRead(5);  

float terme2=( kPinTemp2/1023.0 )*5.0*1000/10;       
float terme3=( kPinTemp3/1023.0 )*5.0*1000/10; 
float terme4=( kPinTemp4/1023.0 )*5.0*1000/10; 
float terme5=( kPinTemp5/1023.0 )*5.0*1000/10; 

if ( reg  == "F" ) {
float terme2=((terme2 ) * 9.0 / 5.0) + 32.0;      
float terme3=((terme3 ) * 9.0 / 5.0) + 32.0; 
float terme4=((terme4 ) * 9.0 / 5.0) + 32.0;  
float terme5=((terme5 ) * 9.0 / 5.0) + 32.0; 
}

 term2=(int)terme2;                                 
 term3=(int)terme3;
 term4=(int)terme4;
 term5=(int)terme5;

 sendNTPpacket(timeServer); // Отсылаем время-серверу NTP-пакет
 
    // Ждем, чтобы увидеть, доступен ли ответ:
  delay(1000);  
  if ( Udp.parsePacket() ) {  
    // Пакет получен, значит считываем данные оттуда:
    Udp.read(packetBuffer,NTP_PACKET_SIZE);  // считываем содержимое пакета в буфер
 
    // Временная отметка начинается с 40 байта полученного пакета
    // и его длина составляет четыре байта или два слова.
    // Для начала извлекаем два этих слова:
    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  
    // Совмещаем четыре байта (два слова) в длинное целое.
    // Это и будет NTP-временем (секунды начиная с 1 января 1990 года):
    unsigned long secsSince1900 = highWord << 16 | lowWord;  
    Serial.print("Seconds since Jan 1 1900 = " );  //  "Секунды, прошедшие с 1 января 1990 = "
    Serial.println(secsSince1900);      
 
    // Теперь конвертируем NTP-время в обычное время:
    Serial.print("Unix time = ");  //  "Unix-время = "
    // Время Unix стартует с 1 января 1970 года. В секундах это 2208988800:
    const unsigned long seventyYears = 2208988800UL;    
    // Вычитаем 70 лет:
    unsigned long epoch = secsSince1900 - seventyYears;  
    // Выводим на Serial Monitor Unix-время:
    Serial.println(epoch);                              
 
 
    // Выводим на Serial Monitor информацию о часах, минутах и секундах:
    Serial.print("The UTC time is ");       // "Среднее время по Гринвичу = ",  // UTC – это среднее время по Гринвичу (GMT):
    Serial.print((epoch  % 86400L) / 3600); // выводим часы (86400 эквивалентно количеству секунд в день):
    Serial.print(':');  
    if ( ((epoch % 3600) / 60) < 10 ) {
      // У первых десяти минут каждого часа должна спереди стоять цифра «0»:
      Serial.print('0');
    }
    Serial.print((epoch  % 3600) / 60); // выводим минуты (3600 эквивалентно количеству секунд в минуте):
    Serial.print(':');
    if ( (epoch % 60) < 10 ) {
      // У первых десяти секунд каждой минуты спереди должна стоять цифра «0»:
      Serial.print('0');
    }
    Serial.println(epoch %60); // выводим секунды
  }
  // Ждем 10 секунд перед новым запросом о времени:
  delay(10000);
}
 
// Отправляем NTP-запрос к время-серверу по указанному адресу:
unsigned long sendNTPpacket(IPAddress& address)
{
  // Отправляем все байты (вплоть до 0-ого) в буфер:
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Инициализируем значения, необходимые для формирования NTP-запроса
  // (подробнее о пакетах см. в URL выше):
  packetBuffer[0] = 0b11100011;   // LI (leap indicator, т.е. «индикатор перехода»), версия, режим работы
  packetBuffer[1] = 0;     // слой (или тип часов)
  packetBuffer[2] = 6;     // интервал запросов
  packetBuffer[3] = 0xEC;  // точность
  // 8 байтов с нулями, обозначающие базовую задержку и базовую дисперсию
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;
  // После заполнения всех указанных полей
  // вы сможете отправлять пакет с запросом о временной метке:        
  Udp.beginPacket(address, 123); // NTP-запрос идет на порт 123
  Udp.write(packetBuffer,NTP_PACKET_SIZE);
  Udp.endPacket();
}