problemas con puerto UDP

Buenas gente, soy nuevo en el mundo de la programación. estoy creando una interfaz que actúa cuando se activan unos reles N.C.
Mi problema es que cuando veo los paquetes con un snifer (wireshark) me dice que “destination port: 0” cuando supuestamente puse 5005, mi primer paso es verlo en whireshark para levantar los datos que mando con un software en phyton, pero desde ya leer el paquete que llega me esta fallando, si lo leo pero en el “puerto 0”

Ojala me puedan dar una mano, saludos y gracias.

Parte del código es el siguiente:

//cargan las funcionalidades ethernet y libreria UDP
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>

// configuramos la MAC address y la IP:
byte mac = {0x90, 0xA2, 0xDA, 0x0F, 0x98, 0x93};
IPAddress ip(192, 168, 0, 2);

// habilitamos el puerto 5005 para “hablar”
unsigned int localPort = 5005;

// sentencia que permite enviar y recibir paquetes UDP
EthernetUDP Udp;

//aqui se podra variar el numero de veces que se tendra que repetir un evento para enviar UDP, esto ayuda a evitar falsas alarmas:
int repetir_evento = 5;//
///////////////////////////////////////////////////////////////////
//lecturas_positivas (x,y) ------> x = nro de modem, y = nro evento
///////////////////////////////////////////////////////////////////
int lecturas_positivas31 = 0;
int lecturas_positivas32 = 0;
int lecturas_positivas33 = 0;
int lecturas_positivas34 = 0;

//variables que hacen corresponder el nro. de modem con el pin de salida en el arduino
int modem3 = 2;

void setup() {
//se inicia la comunicacion ethernet y UDP:
Ethernet.begin(mac,ip);
Udp.begin(localPort);

Serial.begin(9600);//SE ESTABLECE QUE VA A VER LECTURA SERIAL,
//EN EL PROYECTO FINAL COMO USAREMOS ETHERNET SHIELD SE CAMBIARAN
//LOS PINES O Y 1 COMO OUTPUTS YA QUE NO USAREMOS SERIAL.

pinMode(0, OUTPUT);//SE DECLARAN LOS PINES COMO SALIDAS, LOS
pinMode(1, OUTPUT);//CUALES “SELECCIONARAN” EL MODEM A LEER.
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);//LOS PINES 10 A 13 SE RESERVAN PARA LA COMUNICACION POR ETHERNET FUTURA.
pinMode(14, INPUT);// POR COMODIDAD EN LA PLACA SE DECLARAN ESTOS PINES COMO INPUTS QUE VENDRIAN A INYECTAR
pinMode(15, INPUT);// LOS ESTADOS DE LOS EVENTOS “HIGH” O “LOW”.
pinMode(16, INPUT);// LOS MISMOS SON E/S ANALOGICAS PERO AL DECLARARLAS CON PinMode() SE USAN COMO
pinMode(17, INPUT);// E/S DIGITALES.
pinMode(18, OUTPUT);
pinMode(19, OUTPUT);
}
void loop(){
////////////////////////////////////////////////////////////////
//modem 3 - salida 2 en arduino (ver declaracion de variables)//
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
digitalWrite (modem3, HIGH);//

//para el evento 1 “unit fault”
if (digitalRead(14) == 1){//si la entrada digital pin14 esta en “high”
Serial.println ("Unit Fault " + String(3) + " " + String(lecturas_positivas31));//imprimir por serial el primer evento + nro de modem + valor de lecturas positivas
// ** ** **
if (lecturas_positivas31 < repetir_evento)//si el evento esta en alto y no paso la cantidad de veces necesarias
// **
{lecturas_positivas31 ++;}//si el nro de lecturas positivas es menor que las requeridas para activar la alarma y el evento esta activado, incrementar nro de lecturas

else {Udp.parsePacket();
Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());//comienza la conexion UDP
Udp.write(byte(B00000000) + Udp.write(“texto”));//el byte se ve en cod ascii y en dec? texto ok
Udp.endPacket();}}//termina la escritura de datos UDP
// **
else{lecturas_positivas31 = 0;}//si la entrada esta en “low” resetear lectura_positiva
delay(200);

//para el evento 2 “Tx Traffic”
if (digitalRead(15) == 1){//si la entrada digital pin14 esta en “high”
Serial.println ("Tx Traffic " + String(3) + " " + String(lecturas_positivas32));//imprimir por serial el segundo evento + nro de modem + valor de lecturas positivas
// ** ** **
if (lecturas_positivas32 < repetir_evento)
{lecturas_positivas32 ++;}//si el nro de lecturas positivas es menor que las requeridas para activar la alarma y el evento esta activado, incrementar nro de lecturas
else {Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());//comienza la conexion UDP
Udp.write(byte(B00000000) + Udp.write(“texto”));//el byte se ve en cod ascii y en dec? texto ok
Udp.endPacket();}}//termina la escritura de datos UDP
// **
else{lecturas_positivas32 = 0;}//si la entrada esta en “low” resetear lectura_positiva
delay(200);

//para el evento 3 “Rx Traffic”
if (digitalRead(16) == 1){//si la entrada digital pin14 esta en “high”
Serial.println ("Rx Traffic " + String(3) + " " + String(lecturas_positivas33));//imprimir por serial el tercer evento + nro de modem + valor de lecturas positivas
// ** ** **
if (lecturas_positivas33 < repetir_evento)
{lecturas_positivas33 ++;}//si el nro de lecturas positivas es menor que las requeridas para activar la alarma y el evento esta activado, incrementar nro de lecturas
else {Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());//comienza la conexion UDP
Udp.write(byte(B00000000) + Udp.write(“texto”));//el byte se ve en cod ascii y en dec? texto ok
Udp.endPacket();}}//termina la escritura de datos UDP
// **
else{lecturas_positivas33 = 0;}//si la entrada esta en “low” resetear lectura_positiva
delay(200);

Hola. Una cosa es el puerto por el que escuchas, que en este caso es el 5005, y otra es el puerto al que llamas. Prueba a ver a cambiar Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());

por const int PUERTOREMOTO=5005 Udp.beginPacket(Udp.remoteIP(), PUERTOREMOTO);

Saludos

hola, gracias por la respuesta.

sigo viendo los paquetes con el wireshark pero me los manda al “puerto 0”

probe cambiar por:

// habilitamos el puerto 8888 para “hablar”
unsigned int localPort = 5005;
const int PUERTOREMOTO = 5005;

en void loop:

//para el evento 1 “unit fault”
if (digitalRead(14) == 1){//si la entrada digital pin14 esta en “high”
Serial.println ("Unit Fault " + String(3) + " " + String(lecturas_positivas31));//imprimir por serial el primer evento + nro de modem + valor de lecturas positivas
// ** ** **
if (lecturas_positivas31 < repetir_evento)//si el evento esta en alto y no paso la cantidad de veces necesarias
// **
{lecturas_positivas31 ++;}//si el nro de lecturas positivas es menor que las requeridas para activar la alarma y el evento esta activado, incrementar nro de lecturas

else {Udp.parsePacket();

Udp.beginPacket(Udp.remoteIP(), PUERTOREMOTO);//comienza la conexion UDP
Udp.write(byte(B00000000) + Udp.write(“texto”));//el byte se ve en cod ascii y en dec? texto ok
Udp.endPacket();}}//termina la escritura de datos UDP
// **
else{lecturas_positivas31 = 0;}//si la entrada esta en “low” resetear lectura_positiva
delay(200);

A ver. Te hablo sin conocer a fondo el protocolo UDP, sino examinando someramente las funciones que incluye la librería. Udp.parsePacket() realiza un análisis de un supuesto paquete UDP recibido. ¿Estás enviando en tus pruebas algún paquete UDP a Arduino? Si no es así, no tiene sentido de momento que uses ni Udp.remoteIP() ni Udp.remotePort(), pues estos datos se supone que se extraen de ese supuesto paquete recibido (la dirección y puerto del remitente de ese paquete), y si no se ha recibido nada, ambos tendrán un valor indefinido (probablemente cero). Ambos valores te servirán en un futuro para saber a quién responder cuando recibas un paquete UDP; pero si de momento no te estás comunicando con Arduino, prueba sencillamente a enviar paquetes UDP a ver si wireshark los detecta:

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

// configuramos la MAC address y la IP:
byte mac[] = {
      0x90, 0xA2, 0xDA, 0x0F, 0x98, 0x93};
IPAddress ip(192, 168, 0, 2);

unsigned int localPort = 5005;     
EthernetUDP Udp;

void setup() {
      //se inicia la comunicacion ethernet y UDP:
      Ethernet.begin(mac,ip);
      Udp.begin(localPort);
}
void loop(){
      Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
      Udp.write(byte(B00000000) + Udp.write("texto"));
      Udp.endPacket();
      delay(2000);
}

Prueba y me cuentas (de momento yo no tengo experiencia con la librería UDP, pero analizándola supongo que vayan por ahí los tiros).

si... en principio quiero enviar paquetes unidireccionalmente... con recibirlos en la PC estaría bien, y de echo los recibo, tanto con el ultimo programa que mandaste como con el anterior "original".

El tema que en whireshark los veo como "destination port:0" y pretendo levantar los paquetitos UDP con un programita en Phyton que en principio imprime "recibido" cuando hay presencia de paquetes simplemente, el tema que no me imprime nada y creo que viene por ese lado de puertos que no estoy entendiendo mucho.

programa en Phyton: import socket

UDP_IP = "192.168.0.2" #no tengo claro pero supongo que con ip de host donde corre UDP_PORT = 5005 #verificar que sea el mismo en el arduino

sock = socket.socket(socket.AF_INET, # crea un soket INET de socket.SOCK_DGRAM) # UDP para enviar datagramas sock.bind((UDP_IP, UDP_PORT))

while True: data, addr = sock.recvfrom(1024) #se crea buffer de 1024 bytes print ("mensaje recibido"), data

Perdón por el fallo.
Es lo que ocurre cuando se va con prisas y no se relee lo que se escribe :~
Me preocupé de quitar todo lo innecesario del código y al final dejé lo importante como estaba.

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

// configuramos la MAC address y la IP:
byte mac[] = {
      0x90, 0xA2, 0xDA, 0x0F, 0x98, 0x93};
IPAddress ip(192, 168, 0, 2);
unsigned int localPort=5005;

IPAddress IPREMOTA(192, 168, 0, 1); //aquí iría la IP del PC
unsigned int PUERTOREMOTO= 5005;     

EthernetUDP Udp;

void setup() {
      //se inicia la comunicacion ethernet y UDP:
      Ethernet.begin(mac,ip);
      Udp.begin(localPort);
}
void loop(){
      Udp.beginPacket(IPREMOTA, PUERTOREMOTO);
      Udp.write(byte(B00000000) + Udp.write("texto"));
      Udp.endPacket();
      delay(2000);
}

Prueba de nuevo a ver si hay algún cambio en wireshark.
Saludos.

(PULGAR PARA ARRIBA)

Excelente... me estaba faltando la IP de destino entonces (que intente ponerla y no me había salido),

Muchas gracias por tu tiempo, ya me estaba calentando...

Salute!

Me alegro. Si la comunicación va a ser, como decías, unidireccional, tal vez hasta sobre el Udp.begin (prueba a ver). Cambia el título del hilo y añádele "[SOLUCIONADO]" por si resulta de utilidad para otros. Saludos

Buenas tardes, estoy tratando de hacer una rutina que guarde la lectura de sensor de temperatuda dth11 en una sd.card, a la vez ese datos lo mande por UDP a un destino. Pueden apoyar con la duda?