Hola a todos,
Tengo una consulta que hacer al foro, recién pude adquirir el modulo w5500 lo probé con uno de los tantos programitas que hay en la red y funciona bien, la micro SD también funciona bien, las pruebas lo hice cada modulo por separado uso el mega pro 2560. El problema esta cuando quiero trabajar con estos dos módulos, mi consulta es:
Si las librerías de cada uno de estos dos módulos se encargan de activar/desactivar (o seleccionar) los respectivos SS o es que uno mismo lo tiene que hacer en el código, uso
W5500: pin 10 como SS
microSD: pin 4 como SS
El manejo lo hacen las librerías, solo tienes que indicar los pines a cada una
Por ej. con
Ethernet.init(10);
configuras el CS (o SS) en el pin 10 para la w5500.
Y con
SD.begin(4);
el CS (o SS) en el pin 4 para la SD.
Saludos
Estimado gatul,
Agradezco tu respuesta no se que estoy haciendo mal porque no me esta funcionando, el codigo es simple:
- Lee un sensor de T° y envia por el serial
- También envía la T° lo envía por LAN
- Si el selector esta en LOW graba la T° en la SD.
El problema que tengo es que no envía nada por LAN.
Si hay lectura de T°, si presiono el selector si graba en memoria SD.
Gracias..
#include <SPI.h> // libreria interfaz SPI (micro SD)
#include <SD.h> // incluye libreria para tarjetas SD
#include <Ethernet.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#define pin53 53 // necesario para mega 2560
#define SSpin 10 // pin 10 para shield
#define SDpin 4 // pin 4 para SD
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // MAC
IPAddress ip(192,168,1,69); // Esta direccion IP EthernetServer server(80);
void setup() {
Ethernet.begin(mac, ip); // inicializa la conexión Ethernet
Ethernet.init(SSpin); // esto ultimo recien lo puse
server.begin(); // inicializa el servidor
Serial.begin(9600);
pinMode(SELECTOR, INPUT);
pinMode(LED, OUTPUT);
pinMode(pin53, OUTPUT); //
pinMode(SSpin, OUTPUT);
pinMode(SDpin, OUTPUT);
if (! SD.begin (SDpin)){ // inicialización de la tarjeta SD
serial.print("No se encuentra micro SD");
oled.display();
delay(1000);
return; // se sale del setup ()
}
} // fin del setup
void loop() {
sensors1.requestTemperatures(); // envia comandos
T[1] = sensors1.getTempC(sensor5); // toma de lactura
Serial.println(T[0], 1);
//Ethernet
EthernetClient cliente = server.available(); // Inicializa client
if (cliente) {
boolean currentLineIsBlank = true;
while (cliente.connected()) { // entra al while
if (cliente.available()) { // si el cliente esta habilitado
char c = cliente.read();
if (c == '\n' && currentLineIsBlank) {
cliente.println("HTTP/1.1 200 OK");
cliente.println("Content-Type: text/html"); r
cliente.println("Connection: close");
cliente.println("Refresh: 3"); // refresca 3 seg
cliente.println();
cliente.println("<!DOCTYPE HTML>");
cliente.println("<html>");
cliente.println("<HEAD>");
cliente.println("<TITLE>Ethernet Sensor</TITLE>");
cliente.println("</HEAD>");
cliente.println("<BODY BGCOLOR='#3375FF'>");
cliente.println("<hr />");
cliente.println("<br />");
cliente.println(" <H2STYLE='COLOR:WHITE;'>Monitorea Temp g celsius</H2>");
cliente.println("<br />");
cliente.print("<H2 STYLE='COLOR:WHITE;'> Congeladora : ");
cliente.print(T[0], 1); // envia lectura de T
cliente.println("<br />"); // salto de linea
cliente.println("<br />"); // salto de linea */
cliente.println("<br />");
cliente.println("</html>");
break;
}
if (c == '\n') {
currentLineIsBlank = true;
}
else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(20); // Da tiempo al Servidor
cliente.stop(); // cierra la conexion
}
//microSD solo escribe si esta en bajo
if (digitalRead(SELECTOR) == LOW){
digitalWrite(LED, HIGH);
tiempoFinal = millis();
if (tiempoFinal - tiempoInicial >= 600000){ // escribe cada minuto
archivoSD = SD.open ("datatemp.txt", FILE_WRITE);
if (archivoSD) {
archivoSD.println(T[0], 1); // escribe T en SD
Serial.println("escritura correcta");
archivoSD.close(); // cierre de archivo
}
tiempoInicial = millis();
tiempoFinal = 0;
delay(100);
}
}
} // fin del loop
Prueba algun ejemplo de la librería para ver si el problema es de la w5500
Hola a todos,
Aquí sigo intentando con mi problema, tengo otra consulta yo estoy usando la librería Ethernet.h, sin embargo en otros ejemplos que revisado en internet usan la librería Ethernet2.h (aun no lo he descargado en mi IDE).
Hay alguna diferencia? Tendrá algo que ver?
Estoy usando esta placa W5500
Entiendo que estás intentando montar un server y conectarte remotamente al arduino para obtener la lectura de Tº.
Para ello lo que necesitas es definir qué puerto TCP usará.
Por ejemplo si desde un PC quieres acceder por HTTP (que es lo que parece que intentas hacer) deberás definir en el arduino el puerto 80.
Veo que tienes esta línea:
server.begin(); // inicializa el servidor
pero ¿¿¿dónde tienes definido 'server'???
debería ser algo así:
EthernetServer server(80);
Saludos.
Hola DanX3,
Si cuando el selector esta en bajo escribe la T° en la SD.
Decidí anular el termómetro y reemplazarlo con la variable valor que se incrementa con cada ciclo, claro esta esta variable se envia a la red y se graba cuando selector esta en bajo; hice esto solo con la finalidad d hacer mas sencillo el código hasta solucionar.
Pego aquí el código completo
#include <SPI.h>
#include <Ethernet.h>
#include <SD.h> // incluye libreria para tarjetas SD
#define pin53 53 // Slave Select en pin digital
#define SDpin 4
#define SSpin 10
File archivoSD;
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,169); // Esta direccion IP debe ser cambiada obligatoriamente
// dependiendo de la subred de su Area Local y es la que
// usara para conectarse por el Navegador.
byte LED = 25, SELECTOR = 30;
int valor = 0;
float tiempoFinal, tiempoInicial = 0;
EthernetServer server(80); // Puerto 80 por defecto para HTTP
void setup() {
Serial.begin(9600);
pinMode(pin53, OUTPUT);
pinMode(SSpin, OUTPUT);
pinMode(SDpin, OUTPUT);
digitalWrite(SSpin, HIGH);
digitalWrite(SDpin, HIGH);
Ethernet.begin(mac, ip); //inicializa la conexión Ethernet y el servidor
Ethernet.init(SSpin);
server.begin();
if (! SD.begin (SDpin)){ // inicialización de la tarjeta SD
Serial.print("No hay micro SD"); // escribe en pantalla el texto
delay(3000);
return; // se sale del setup () para finalizar el programa
}
pinMode(LED, OUTPUT);
pinMode(SELECTOR, INPUT);
} // fin del setup
void loop() {
digitalWrite(LED, LOW);
delay(200);
valor++;
Serial.println(valor);
EthernetClient cliente = server.available(); // Inicializa cliente como servidor ethernet
if (cliente) {
boolean currentLineIsBlank = true;
while (cliente.connected()) {
if (cliente.available()) {
char c = cliente.read();
if (c == '\n' && currentLineIsBlank) {
cliente.println("HTTP/1.1 200 OK");
cliente.println("Content-Type: text/html"); // Envia el encabezado en codigo HTML estandar
cliente.println("Connection: close");
cliente.println("Refresh: 3"); // refresca la pagina automaticamente cada 3 segundos
cliente.println();
cliente.println("<!DOCTYPE HTML>");
cliente.println("<html>");
cliente.println("<HEAD>");
cliente.println("<TITLE>Ethernet Monitor</TITLE>");
cliente.println("</HEAD>");
cliente.println("<BODY>");
cliente.println("<hr />");
cliente.println("<H1>Arduino Monitor</H1>");
cliente.println("<br />");
cliente.println("<H2>Monitorea Valor</H2>");
cliente.println("<br />");
cliente.println("Lectura Analoga Ethernet");
cliente.println("<br />");
cliente.println("<br />");
cliente.print("Valor: ");
cliente.println(valor);
cliente.println("<br />");
cliente.println("elprofegarcia.com");
cliente.println("</html>");
break;
}
if (c == '\n') {
currentLineIsBlank = true;
}
else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(15); // Da tiempo al Servidor para que reciba los datos 15ms
cliente.stop(); // cierra la conexion
delay(200);
}
if (digitalRead(SELECTOR) == LOW){
digitalWrite(LED, HIGH);
tiempoFinal = millis();
if (tiempoFinal - tiempoInicial >= 10000){ // 20 seg
archivoSD = SD.open ("datatemp.txt", FILE_WRITE); // apertura para read/w
if (archivoSD) {
archivoSD.println(valor); // escribe en SD el valor de sensor 0
Serial.println("escritura correcta");
archivoSD.close(); // cierre de archivo
}
tiempoInicial = millis();
tiempoFinal = 0;
delay(100);
}
//digitalWrite(LED, LOW);
} // fin de la escritura SD */
}
En este código esta pasando que no envía nada por red LAN, si selector esta en bajo si escribe en la micro SD; si quito la alimentación de la micro SD si envía por la red LAN.
Puedes poner este código:
#include <SPI.h>
#include <Ethernet.h>
#define SSpin 10
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,169);
EthernetServer server(80); // Puerto 80 por defecto para HTTP
String peticionWeb =""; //cadena donde se guarda la petición web (url invocada)
void setup()
{
pinMode(SSpin, OUTPUT);
digitalWrite(SSpin, HIGH);
Ethernet.begin(mac, ip); //inicializa la conexión Ethernet y el servidor
Ethernet.init(SSpin);
server.begin();
}
void loop()
{
EthernetClient cliente = server.available(); // Inicializa cliente como servidor ethernet
if (cliente)
{
peticionWeb = cliente.readStringUntil('\r');
if ((peticionWeb.indexOf("index.html"))
{
cliente.println("HTTP/1.1 200 OK");
cliente.println("Content-Type: text/html");
cliente.println("");
cliente.println("<!DOCTYPE HTML><HTML><HEAD><TITLE>Ethernet Monitor</TITLE></HEAD><BODY><H1>");
cliente.println("Arduino Monitor");
cliente.println("</H1></BODY></HTML>");
}
}
}
¿Y desde un PC miras si puedes abrir http://192.168.1.169/index.html ?
¿Puedes paras fotos de las conexiones?
Saludos.
Hola DanX3,
Hice lo que me pediste y no abre nada con http://192.168.1.169/index.html, vuelvo a cargar mi programita y funciona bien claro esta con las observaciones mencionadas.
buscando en la web me di con este foro...
Incompatibilidad módulos ethernet w5500 mini y lector de micro sd | Foros de Electrónica
Voy a comprar este modulo SD, pero en realidad quiero usar la micro SD porque es mas pequeño.
Hola a todos,
Aquí retomando este pequeño proyecto, conseguí el modulo SD pero con el mismo resultado. Decidí tomar la opción 2 que consiste en utilizar 2 arduinos que se van a comunicar vía puerto serial.
Arduino mega pro
- Lee T° , lo envía a la oled 0.96"
- Luego esa T° lo envía por puerto serial.
Arduino nano
Recibe la T° por puerto serial y lo envía por LAN.
Por ahora uso el sensor DS18B20 pero a futuro sera el DHT22. Los programitas funcionan bien pero luego de unos 2 a 3 minutos el NANO envía CERO por LAN, si embargo en el mega todo anda bien porque en la oled si veo los valores de T°.
Le doy reset al NANO y luego de unos 2 a 3 minutos de estar funcionando bien vuelve a enviar CERO por LAN.
Para los programas me ayude de este link [Solucionado] Comunicación de dos arduinos - #23 by josue_gonzalezm
// Para el MEGA PRO
float temperatura = 4;// Obtención de la temperatura
void setup() {
// put your setup code here, to run once:
Serial1.begin(9600); // Inicia la comunicacion por (Tx1 y Rx1)
Serial1.flush(); // Depura la informacion
}
void loop()
{
Serial1.write((byte*)&temperatura, 4);
delay(10); // Valor de ensayo y error. Evita llenar el búfer del receptor en caso de que este sea más lento que el emisor; cosa que muy probablemente ocurra, por ahora estoy con delay(10)
// Un valor muy alto podría hacer que el flujo de datos deje de ser "constante".
}
Para en NANO:
float temperatura = 0.0;
void setup() {
// put your setup code here, to run once:
Serial1.begin(9600); // Inicia la comunicacion por (Tx1 y Rx1)
Serial.begin(9600); // Inicia la comunicacion por (Tx0 y Rx0) con el computador
Serial1.flush();
}
void loop() {
if (Serial1.available() > 7) { // Este es básicamente el paso 1.
// Paso 2:
Serial1.readBytes((byte*)&temperatura, 4);
}
Serial.println(temperatura);
}
Gracias..
El Nano solo tiene un único puerto serie hardware (Serial).
O sea que Serial1 no existe, en todo caso debes emularlo con la librería SoftwareSerial.
Entonces tu código está incompleto, y si lo tienes tal cual, es imposible que compile.
Si las placas están próximas, ¿No pensaste en usar comunicación I2C?
Hola gatul,
Tienes razón el código que puse lineas arriba me sirvió de guía , mi código
es este:
float temperatura = 0.0;
void setup() {
Serial.begin(9600); // Inicia la comunicación
Serial.flush();
}
void loop() {
if (Serial.available() > 7) {
Serial.readBytes((byte*)&temperatura, 4);
}
Serial.println(temperatura);
// en esta sección inicia la comunicación ethernet para enviar la temperatura
// por LAN, código ya conocido por ello no lo he puesto completo
EthernetClient cliente = server.available(); // Inicializa cliente como serv.
if (cliente) {
boolean currentLineIsBlank = true;
while (cliente.connected()) {
if (cliente.available()) {
....
}
}
}
} // fin de loop
Ojo SI hay transmisión puedo ver en LAN la temperatura pero solo dura 2 a 3 minutos y luego se queda en cero.
Los arduinos están cerca de hecho se van insertar en una carcasa pequeña, elegí transmitir por puerto serial porque fue lo primero que encontré me pareció sencillo, no tengo experiencia para comunicar dos arduinos.
No he probado con I2C, es una mejor opción, me recomiendas?
Gracias
¿Por qué esperas que haya más de 7 caracteres en el buffer (en lugar de 4) si sólo vas a leer 4?
if (Serial.available() > 7) {
Serial.readBytes((byte*)&temperatura, 4);
}
O sea, más de 7 son al menos 8, lo que equivale a que lees con una medición de retraso.
Lo cambiaría por
if (Serial.available() >= 4) {
Al margen, ese flush() en setup() no tiene sentido porque el buffer recién creado está vacío, no puede haber nada pendiente de enviarse.
Hola gatul,
Tome en cuenta tus comentarios (para el arduino UNO) pero el resultado es el mismo, me muestra la temperatura por LAN, pasan un par de minutos y me muestra de temperatura 0.0
// probe este
if (Serial.available() > 3) { // paso 1
// Paso 2:
Serial.readBytes((byte*)&temperatura, 4);
//tambien probe este
if (Serial.available() >=4) { // paso 1
// Paso 2:
Serial.readBytes((byte*)&temperatura, 4);
En ambo casos pasa mismo.
Estuve leyendo un poco de I2C tengo entendido que el esclavo envía la T° solo cuando el maestro le solicita, parece que es una mejor opción.
Saludos
Estuve probando (simulado en Proteus) una adaptación del código enviando valores float aleatorios de un arduino al otro durante 15 minutos cada 1 segundo sin inconvenientes.
También probé cada 500 mseg con igual resultado.
¿No será que el problema lo genera el módulo ethernet y/o su librería?
Por cierto,
if (Serial.available() > 3) {
y
if (Serial.available() >=4) {
son lo mismo porque un número entero mayor a 3 es, al menos, igual a 4 (o mayor).
Hi,
Porque espera cuando los caracteres son > de 3. Hazlo que sea > 0. Trata a ver si te trabaja mejor ignora el consejo si ya lo trataste.
Hola Tauro022,
Gracias por tu comentario,
Luego de algunos días puedo retomar este asunto pendiente.
Hice lo que me sugeriste y el resultado es el mismo, si hay envío por la LAN pero solo dura un par de minutos y se queda en cero (0.0).
Te comento que estoy probando otro código en el mega 2560 para volver a intentar la opción 1 (hacer todo este proyecto con el mega 2560, w5500, microSD).
La opción 2, en caso no pueda con la opción 1, es hacer el mismo proyecto pero con dos arduinos (mega 2560 y NANO) el primero le envía la T° al segundo y este lo envía por LAN.
Saludos,
Que tiene que ver Serial con una comunicación TCP/IP?
Hola a Surbyte,
No tiene nada que ver, solo quería hacer que un arduino (maestro) le envíe la temperatura (un float) via serial a un arduino nano (esclavo) y este lo envía por LAN.
Lo ideal es hacerlo con un solo arduino mega pero tuve muchos problemas.
Ahora bien, acabo de probar este código que le hice algunos cambios, todo funciona bien, envía la T° por LAN y cuando el selector esta en bajo graba en la micro SD.
Materiales: arduino mega, sensor de T°, shield W5100
Pongo el código:
#include <SPI.h>
#include <SD.h>
#include <Ethernet.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#define pin53 53 // no usado
#define SSpin 10 // pin 10 para shield
#define SDpin 4 // pin 4 para SD
#define DATA1 22 // pin digital 22 entrada de datos
File archivoSD;
OneWire oneWire1(DATA1); // a futuro sera cambiado por el DHT22
DallasTemperature sensors1 (&oneWire1); // declara variable/objeto para sensor DATA1
DeviceAddress sensor4 = {0x28, 0xE6, 0x52, 0x95, 0xF0, 0x01, 0x3C, 0xA7};
byte LED = 25, SELECTOR = 30;
float Temp, tiempoFinal = 0, tiempoInicial = 0;
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,169); //
EthernetServer server(80); // Puerto 80 por defecto para HTTP
void setup() {
Serial.begin(9600);
delay(500);
sensors1.setResolution(sensor4, 11); // sensor1 a resolución de 9 bits
Ethernet.begin(mac, ip); //inicializa la conexión Ethernet y el servidor
server.begin();
sensors1.begin();
pinMode(LED, OUTPUT);
pinMode(SELECTOR, INPUT);
pinMode(SDpin, OUTPUT); // SDpin 4
pinMode(pin53, OUTPUT); // pin53
pinMode(SSpin, OUTPUT); // SSpin 10
if (! SD.begin (SDpin)){ // inicialización de la tarjeta SD
Serial.print("No se encuentra micro SD"); // escribe en pantalla el texto
delay(3000);
return;
}
//digitalWrite(SDpin, HIGH);
//digitalWrite(SSpin, HIGH);
} // fin del setup
void loop() {
digitalWrite(LED, HIGH);
delay(200);
sensors1.requestTemperatures(); // envia comandos para tomar lecturas
Temp = sensors1.getTempC(sensor4); // toma de lactura del sensor 1
Serial.println(Temp, 1);
EthernetClient cliente = server.available(); // Inicializa cliente como servidor ethernet
if (cliente) {
boolean currentLineIsBlank = true;
while (cliente.connected()) {
if (cliente.available()) {
char c = cliente.read();
if (c == '\n' && currentLineIsBlank) {
cliente.println("HTTP/1.1 200 OK");
cliente.println("Content-Type: text/html"); // Envia el encabezado en codigo HTML estandar
cliente.println("Connection: close");
cliente.println("Refresh: 3"); // refresca la pagina automaticamente cada 3 segundos
cliente.println();
cliente.println("<!DOCTYPE HTML>");
cliente.println("<html>");
cliente.println("<HEAD>");
cliente.println("<TITLE>Ethernet REAL TIME</TITLE>");
cliente.println("</HEAD>");
cliente.println("<BODY BGCOLOR='#3375FF'>"); // abre el cuerpo de los comando htlm
cliente.println("<hr />");
cliente.println("<H1 STYLE='COLOR:#36FF33;'>SALA DE CONGELADORAS </H1>");
cliente.println("<br />");
cliente.println("<BODY BGCOLOR='#3375FF'>");
cliente.println("<H2 STYLE='COLOR:WHITE;'>Monitorea Valor</H2>");
cliente.println("<br />");
cliente.println("Lectura de sensores Ethernet");
cliente.println("<br />");
cliente.println("<br />");
cliente.print("Valor: ");
cliente.println(Temp, 1);
cliente.println("<br />");
cliente.println("Codigo de prueba");
cliente.println("</html>");
break;
}
if (c == '\n') {
currentLineIsBlank = true;
}
else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(15); // Da tiempo al Servidor para que reciba los datos 15ms
cliente.stop(); // cierra la conexion
digitalWrite(LED, LOW);
delay(100);
}
//microSD
if (digitalRead(SELECTOR) == LOW){
digitalWrite(LED, HIGH);
tiempoFinal = millis();
if (tiempoFinal - tiempoInicial >= 10000){ // 20 seg
archivoSD = SD.open ("datatemp.txt", FILE_WRITE); // apertura para read/w
if (archivoSD) {
archivoSD.println(Temp, 1); // escribe en SD el valor de sensor 0
Serial.println("escritura correcta");
//archivoSD.print(TEMP, 1);
//archivoSD.print(",");
//archivoSD.println(HR, 0);
//archivoSD.close(); // cierre de archivo
}
tiempoInicial = millis();
tiempoFinal = 0;
delay(100);
}
}
}
Pero mi objetivo es reemplazar el mega 2560 y el shield W5100 por el mega PRO y W5500 respectivamente.
Use el mismo código, en la primera prueba que hice el resultado fue que no envía nada por LAN, lo demás si funciona (lee T° y graba en la micro SD).
Que podria ser??
Qué problemas?