[SOLUCIONADO]leer datos en arduino y enviarlos a nodemcu para subirlos a THINGSP

Hola a todos tengo un arduino uno y NodeMCU. Quiero hacer lecturas de temperatura, humedad, luminosidad, etc transmitirlas por comunicación serie a NodeMCU y una vez este último las reciba, ir subiendo los datos a thingspeak. He leido ya aqui por los foros y de manera externa pero lo único que he conseguido es hacerme un cacao que me ha bloqueado aún más. Soy novato y no sé qué más hacer. Me podríais orientar a realizar el código. Por aquí he visto que ya hay gente que lo ha hecho pero no pone cómo. Gracias de antemano. Saludos.

Todo servicio como thingspeak tienen demos o códigos sugeridos para Arduino y otros procesadores.

Simplemente ve y busca la solucion propuesta para tu hardware. En tu caso Nodemcu.

pagina de thingspeak, buscas códigos o soporte y deben estar ahi los ejemplos para nodemcu.

Lo que dije link

Yo lo hice hace algún tiempo con Arduino, mediante una tarjeta de Wifi (ESP8266). Te adjunto el código por si quieres estudiarlo (lo único que he cambiado es mi nombre real de Wifi y mi contraseña para que no aparezcan). Hay algunas cosas que son específicas para la visulización de los datos en mi pantalla de 4Duino, pero si sabes extraer los datos realmente necesarios tal vez te sirva de ayuda:
La IP de thingspeak es:184.106.153.149 y la API te la asigna el la propia web de ThinsSpeak cuando creas la gráfica.

// Define LOG_MESSAGES to a serial port to send SPE errors messages to. Do not use the same Serial port as SPE
#define LOG_MESSAGES Serial
#define RESETLINE     30
#define DisplaySerial Serial1
#include "WiFi_TemperatureConst.h"
#include "Picaso_Serial_4DLib.h"
#include "Picaso_Const4D.h"

Picaso_Serial_4DLib Display(&DisplaySerial);
#include "Picaso_LedDigitsDisplay.h"
#define ESP_DEBUG

// Uncomment to use ESP8266
#define ESPRESET 17
#include <SoftwareSerial.h>
#define ESPserial SerialS
SoftwareSerial SerialS(8, 9) ;

#include "ESP8266.h"
ESP8266 wifi(SerialS,9600);

int loops = 0;                                 //a counter for testing
String ATresponse ;

#define SSID "MiNombreDeWIFI"      //name of wireless access point to connect to
#define PASSWORD "MiPasswordDeWifi*"  //wifi password
#define IP "184.106.153.149"                   // thingspeak.com

String GET_start = "GET /update?key=";
//go to www.Thingspeak.com and sign up to get the writeAPIKey
String writeAPIKey = "CYA7URD2WWR494FK";       //"F1VP0YS81ID5MDLS" add your writeAPIKey from thingspeak
String GET_end1 =  "&field1=";                 // field1 for the Celcius
String GET_end2 =  "&field2=";                 // field2 for the fahrenheit

String GET = GET_start + writeAPIKey + GET_end1 ;

// routine to handle Serial errors
void mycallback(int ErrCode, unsigned char Errorbyte)
{
#ifdef LOG_MESSAGES
  const char *Error4DText[] = {"OK\0", "Timeout\0", "NAK\0", "Length\0", "Invalid\0"} ;
  LOG_MESSAGES.print(F("Serial 4D Library reports error ")) ;
  LOG_MESSAGES.print(Error4DText[ErrCode]) ;
  if (ErrCode == Err4D_NAK)
  {
    LOG_MESSAGES.print(F(" returned data= ")) ;
    LOG_MESSAGES.println(Errorbyte) ;
  }
  else
    LOG_MESSAGES.println(F("")) ;
  while (1) ;                                 // you can return here, or you can loop
#else
// Pin 13 has an LED connected on most Arduino boards. Just give it a name
#define led 13
  while (1)
  {
    digitalWrite(led, HIGH);                 // turn the LED on (HIGH is the voltage level)
    delay(200);                              // wait for a second
    digitalWrite(led, LOW);                  // turn the LED off by making the voltage LOW
    delay(200);                              // wait for a second
  }
#endif
}
// end of routine to handle Serial errors

word hndl ;
int sensorPin = A0;                         //Vout of LM35 is connected to A0 of Arduino host

void setup()
{

  pinMode(RESETLINE, OUTPUT);               // Display reset pin
digitalWrite(RESETLINE, 1);       // Reset Display, using shield
  delay(100);                               // wait for it to be recognised
digitalWrite(RESETLINE, 0);       // Release Display Reset, using shield
// Uncomment when using ESP8266
  pinMode(ESPRESET, OUTPUT);                // ESP reset pin
  digitalWrite(ESPRESET, 1);                // Reset ESP
  delay(100);                               // wait for it
  digitalWrite(ESPRESET, 0);                // Release ESP reset
  delay(3000) ;                             // give display time to startup

// now start display as Serial lines should have 'stabilised'
  DisplaySerial.begin(200000) ;     // Hardware serial to Display, same as SPE on display is set to
  Display.TimeLimit4D = 5000 ;              // 5 second timeout on all commands
  Display.Callback4D = mycallback ;

// uncomment if using ESP8266
  ESPserial.begin(115200) ;                 // assume esp set to 115200 baud, it's default setting
                                            // what we need to do is attempt to flip it to 19200
                                            // the maximum baud rate at which software serial actually works
                                            // if we run a program without resetting the ESP it will already be 19200
                                            // and hence the next command will not be understood or executed
  ESPserial.println("AT+UART_CUR=19200,8,1,0,0\r\n") ;
  ESPserial.end() ;
  delay(10) ;                               // Necessary to allow for baud rate changes
  ESPserial.begin(19200) ;                   // start again at a resonable baud rate

  ESPserial.println("AT+CWDHCP_CUR=1,1\r\n") ;

  Display.gfx_ScreenMode(PORTRAIT) ;        // change manually if orientation change

  Display.putstr("Mounting...\n");
  if (!(Display.file_Mount()))
  {
    while(!(Display.file_Mount()))
    {
      Display.putstr("Drive not mounted...");
      delay(200);
      Display.gfx_Cls();
      delay(200);
    }
  }
  Display.gfx_Cls();
  hndl = Display.file_LoadImageControl("TEMPERAT.dat", "TEMPERAT.gci", 1);

  Display.print("Welcome!\n");

    if (wifi.setOprToStation()) {
        Display.print("to station + softap ok\r\n");
    } else {
        Display.print("to station + softap err\r\n");
    }

    if (wifi.joinAP(SSID, PASSWORD)) {
        Display.print("Join AP success\r\n");
        Display.print("IP: ");
        Display.println(wifi.getLocalIP().c_str());
    } else {
        Display.print("Join AP failure\r\n");
    }

     if (wifi.disableMUX()) {
      Display.print("single ok\r\n");
    } else {
      Display.print("single err\r\n");
    }
  Display.print("setup end\r\n");
  delay(5000);
  // Display the widgets now
  Display.gfx_Cls();
  Display.img_Show(hndl,iThermometer1) ;    // Thermometer1 show button, only do this once
  Display.img_Show(hndl, iThermometer2);    // Thermometer2 show button, only do this onceDisplay.img_SetWord(hndl, iLeddigits1, IMAGE_INDEX, 100);
  Display.img_Show(hndl, iLeddigits1);      // Leddigits1 show all digits at 0, only do this once
  Display.img_Show(hndl, iLeddigits2);      // Leddigits2 show all digits at 0, only do this once

} // end Setup **do not alter, remove or duplicate this line**

void updateTemp(String temp1, String temp2 ){

   if (wifi.createTCP(IP, (80))) {
     //   Display.print("create tcp ok \r\n");
     //Display.print(field);
    } else {
     //   Display.print("create tcp err\r\n");
    }

  String cmd = GET;
  cmd += temp1;
  cmd += GET_end2;
  cmd += temp2;
  cmd += "\r\n";

  ESPserial.print("AT+CIPSEND=");
  ESPserial.println(cmd.length());
  if(ESPserial.find(">")){
    Serial.print(">");
    Serial.print(cmd);
    ESPserial.print(cmd);
  }

  if(ESPserial.find("OK")){
    Serial.println("RECEIVED: OK");
  }else{
    Serial.println("RECEIVED: Error");
  }

  if (wifi.releaseTCP()) {
    //Display.print("release tcp ok \r\n");
  } else {
    //Display.print("release tcp err\r\n");
  }
}

void loop()
{
   // put your main code here, to run repeatedly
   float celcius = ((5.0 * analogRead(sensorPin)/20 * 100.0) / 1024) + 2;  //signal level sampled from sensorPin is converted to a temperature value. Do calibration  if needed.
  //float tempC = celcius;
  //set thermometer picture with the correct temperature and show it
   Display.img_SetWord(hndl, iThermometer1, IMAGE_INDEX, celcius) ;
   Display.img_Show(hndl,iThermometer1) ;
   LedDigitsDisplay(Display, hndl, celcius, iLeddigits1+1, 24, 3, 1, 29, 0) ;  // Leddigits1
   delay(50);

   float fahrenheit = celcius * 9 / 5 + 32;                                  //Convert temperature readings in degrees Celsius to degrees Fahrenheit
   Display.img_SetWord(hndl, iThermometer2, IMAGE_INDEX, fahrenheit - 50) ;  //minus 50 since the scale starts at 50
   Display.img_Show(hndl,iThermometer2) ;
   LedDigitsDisplay(Display, hndl, fahrenheit, iLeddigits2+1, 140, 3, 1, 29, 0) ;  // Leddigits2
   delay(50);

    char buffer1[10];
    char buffer2[10];
    String tempC = dtostrf(celcius, 4, 1, buffer1);
    String tempF = dtostrf(fahrenheit, 4, 1, buffer2);
    updateTemp(tempC,tempF);

}

Gracias surbayte por la info, mi primer objetivo es realizar el código que me permita leer con arduino y enviar por comunicación serie a NodeMCU los datos medidos por los sensores conectados a arduino. Luego me centraré en subir los datos a thingspeak que por lo que he leido hasta ahora lo veo menos complicado, aunque tampoco quiero lanzar campanas al vuelo jejeje porque soy bastante cortito y novato jejeje. Gracias nuevamente y estamos en contacto. Un abrazo

Gracias jlsogorb extraeré tu código y lo analizaré para extraer lo que realmente quiero por ahora que es lo que le comentaba a surbyte. Veo que tu código es muy completo y que tienes un dominio importante en la materia. En mi caso como comentaba soy novato y, me regalaron hace poco el NodeMCU y ahí estoy intentándole dar uso en un pequeño cultivo que tengo. Como le decía a surbyte mi primer objetivo es comunicar via serie arduino uno y nodemcu para enviar los datos del primero al segundo ya que NodeMCU solo tiene una entrada analógica y necesito más. Así que lo dicho voy a analizar tu código y a leerme la libreria de softwareserial del reference a ver si entre ambas cosas consigo mi objetivo. Gracias nuevamente, estamos en contacto si te parece bien. Un abrazo.

Y por eso te dije, ve a la pagina de Thinkspeak y tienes los ejemplos ahi. Son igual de complicados que el que te propuso jlsogorb porque asi son.

No comprendo como no los viste, ejemplo 1Post Temperature Data and Read from Channel es el mas simple

Tu hablas de leer datos en arduino ___ alamacenar variables ____ transimitir por puerto serial a otra tarjeta verdad?

-Alex.

AlexLPD: Tu hablas de leer datos en arduino ___ alamacenar variables ____ transimitir por puerto serial a otra tarjeta verdad?

-Alex.

Correcto, he creado las variables en el código de arduino. Leo con los sensores y almaceno esos valores leidos en las variables creadas y seguidamente quiero enviar mediante comunicación serie los valores contenidos en las variables almacenadas en arduino a otras variables creadas en NodeMCU. Posteriormente quiero subir esos valores a thingspeak.

En el código de jlsogorb me viene grande porque soy muy novato(discúlpame jlsogorb por mi ignorancia) y creo que deberia haber dos códigos, uno para arduino y otro para NodeMCu.

surbyte: Y por eso te dije, ve a la pagina de Thinkspeak y tienes los ejemplos ahi. Son igual de complicados que el que te propuso jlsogorb porque asi son.

No comprendo como no los viste, ejemplo 1Post Temperature Data and Read from Channel es el mas simple

Gracias surbyte. Si ese que me adjuntas ya lo vi y lo comprendo y lo veo más o menos asequible. Pero no me sirve por ahora para llevar a cabo mi proyecto. El ejemplo que me adjuntas me serviría una vez haya conseguido comunicar arduino uno y NodeMCu por comunicación serie. Los pasos a seguir son, comunicar arduino y mcu, leer con arduino y enviar los valores contenidos en las variables a nodemcu, seguidamente crear el canal en thingspeak y por último crear el código completo en NodeMCu para subir esos datos a thingspeak. Y esa era la ayuda que buscaba en primer lugar y de ahí el asunto del hilo. Sé que tengo que usar la libreria softwareserial en arduino uno y nodemcu pero no sé cómo construir el código para cada módulo ese es mi problema debido a mi novatez y mi bajo nivel de inglés. Muchas gracias por tu ayuda y por las futuras. Un abrazo.

Bueno tu problema entonces es que el proyecto es mas grande que tu conocimiento actual y quieres de golpe hacer demasiado. Cuando esto pasa debes comenzar por tareas mas simples y no por lo mas complejo.

Veamos.. 1. Arduino tomará datos via puertos analógicos. 2. Arduino y Nodemcu deben comunicarse via serie. 3. Nodemcu podrá tmb tomar datos digitales pero debe comunicarse con ThinkSpeak

Ve resolviendo paso a paso las cosas. 1 y 2 es ahora tu problema mas importante porque 3. lo tienes resuelto con los ejemplos. Hay algunos muy simples en el link que te pasé.

Solo te falta agregar la comunicación serie. Recuerda que tu arduino puede ser de 5V y tu nodemcu trabaja a 3.3 asi que debes tener precaución en como se comunican. Fundamentalmente el tx del arduino que llega al RX del nodemcu.

Correcto, por lo que he leido para conectar Tx de arduino a Rx de NodeMCU con poner un divisor de tensión que me dé los 3,3V que necesita NodeMCU lo tendría solucionado. El paso 1 que indicas ya lo tengo programado, ahora mi objetivo es el punto 2 que mencionas, que sería empleando la librería SoftwareSerial.

Ya la he estado leyendo y ahora lo que tengo que ver es qué pines conectar entre sí que imagino que será el pin 1(Tx) de arduino al pin GPIO3 de NodeMCU. He visto en el código de jlsogorb que emplea los pines 8 y 9 y en otro ejemplo que vi por la red usa para Rx y Tx los pines 2 y 3. En mi caso creo que tendré que poner el pin 1 en el código de arduino y el pin 3 o D9 en el código de NodeMCU. Es lo que pienso seguramente no esté en lo correcto.

Por un lado tendré que programar dos códigos, uno para arduino que lea las entradas analógicas y los transmita por Tx y otro para cargar en NodeMCU que lea Rx y vaya colocando cada lectura de cada sensor en una variable,que luego se subirá a thingspeak. El tema es que cada vez que leo una entrada analógica en arduino la envío a NodeMCU y tengo que detectar en NodeMCU que se ha recibido un dato para no perder medidas. No se si emplear interrupciones en el código a cargar en el NodeMCU cada vez que se reciba un valor por Rx del NodeMCU para no perder ninguna medida o no se si es muy descabellado.

Disculpad el chorro de dudas, espero con la información que voy leyendo y lo que me ayudéis ir solucionando todos los pasos.

De nuevo surbyte gracias por tu ayuda e ideas. Un abrazo.

Moderador: No repitas lo que se lee arriba

NO. No uses SoftwareSerial con 0 y 1 del Arduino porque esos son los pines físicos y si los usas te quedas sin monitor Serie en el Arduino. Pero si podras usarlos prescindiendo de SoftwareSerie cuando este terminado tu código. Ya lo entenderás. Ve por pasos. El arduino tiene 1 solo Serial FISICO en 0 y 1. Si quieres otro usas SoftwareSerie en los pines que elijas ej. 7 y 8 o los de tu agrado menos 0 y 1.

Los códigos serán fáciles. Uno casi lo tienes, el demo o ejemplo de ThinkSpeak para el ESPXXXX y el otro el de arduino,

Resuelve la comunicación serie con los datos que arduino le enviara al ESP. Luego te concentras en la comunicación del ESP con ThinkSpeak.

De acuerdo voy a ello a ver si implemento la comunicación y voy poniendo por aquí. Gracias por tu ayuda de nuevo surbyte. Un abrazo.

Moderador: No repitas lo que se lee arriba

Como bien dice Surbyte, ves solucionando poco a poco las cosas por pasos, una vez que llegues a tener que enviar las cosas a Thingspeak, si quieres te aislo lo realmente importante de mi código, que en realidad es lo menos complicado.

Buenas de nuevo surbyte y jlsogorb. Aquí os dejo el código que he programdo para arduino siguiendo los pasos que me comentabas surbyte. Se trata de un código que lee una LDR por A0, lo pasa luminosidad relativa y además enciende un led en función de la luminosidad. He añadido lo necesario, creo, para realizar el envío del valor ‘LR’ a nodemcu via serie a través del pin 3 de arduino uno. ¿Con esto estaría terminado el código a cargar en arduino?

#include <SoftwareSerial.h>
SoftwareSerial Trans(2, 3);                      //Pines para Rx y Tx.

//Declaración de variables del proceso

float valor_medido;                                //Valor obtenido al leer por A0.
int ledPin = 10;                                     //Pin de conexión del led de prueba.
float LR;                                               //Variable para almacenar la luminosidad relativa.
float val;                                              //Variable empleada para el mapeo del valor medido para enviarlo al pin 10.

void setup()

{
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  Trans.begin(115200);                        //Velocidad de envío para la transmisión al NodeMCU.
}

void loop()

{
  valor_medido = analogRead(A0);                      //Valor de luminosidad medido en A0
  LR = (valor_medido * 100) / 1023;                   //Luminosidad medida en tanto por ciento
  Serial.print(LR);                                              //Para mostrar el valor en el monitor serie de arduino.
  Serial.println(" % luminosidad relativa");
  delay(1000);
  val = map(valor_medido, 0, 1023, 0, 255);      //Mapeo del valor medido al rango de salida de las salidas digitales 
                                                                      //para encender el led.
  analogWrite(ledPin, val);
  delay(1000);
  Trans.print(LR);                                            //Transmisión del valor a NodeMCU.
  delay(1000);
}

Ahora para el caso del NodeMCU el código deberia seguir estas pautas:

  • Incluir la libreria softwareserial
    -Comprobar si está disponible el puerto serie para leer.
    -si es así realizar la lectura y almacenar el valor en una variable.
  • Seguidamente añadir el código y librerias necesarias para enviar los datos a thingspeak.

¿Más o menos sería esa la idea?

Gracias de nuevo. Espero vuestras respuestas. Un abrazo.

Ves como haciendo tareas mas simples se simplifica la cosa!!

Si encaras todo te abrumas, pero resolviendo y probando subtareas logras encontrarle la vuelta al problema.

Vas muy bien.

Gracias surbyte por tu ayuda y ánimos.

Una duda que se me plantea, lo que no sé si es correcto plantearla aquí o en otra entrada. Además he estado leyendo otras entradas en relación a la duda y no me lo han aclarado.

El buffer del puerto serie es de 64 bytes, el valor que yo envío, LR, es un float que ocupa 32 bits, es decir, 4 bytes. Esto quiere decir que cada vez que envío el valor de LR estoy ocupando 4 bytes del buffer, ¿es así?.

Por otro lado, una vez quiera leer en NodeMCU cada float, ¿qué me va a ir leyendo de byte en byte o voy a poder leer el valor de LR completo sin problema aunque sea de 32 bits?

A raíz de estas dudas pueden surgir varios problemas:

  • Que se me llene el buffer si no leo más rápido que envío.
  • Si en NodeMCU se va leyendo de byte en byte tendré que unir de 4 en 4 bytes para obtener el valor completo.
  • Y sobre todo cómo obtener la velocidad de envío y lectura correcta para que todo vaya sincronizado y se pierda información.

Voy a seguir programando el código para NodeMCU siguiendo las pautas que ponía en el mensaje anterior y subo código. Si quieres una vez haya subido dicho código me respondes, si puedes, estas dudas y los comentarios sobre el código en un mismo mensaje. Loq ue mejor veas.

Gracias de nuevo. Un abrazo.

El buffer del puerto serie es de 64 bytes, el valor que yo envío, LR, es un float que ocupa 32 bits, es decir, 4 bytes. Esto quiere decir que cada vez que envío el valor de LR estoy ocupando 4 bytes del buffer, ¿es así?.

Por otro lado, una vez quiera leer en NodeMCU cada float, ¿qué me va a ir leyendo de byte en byte o voy a poder leer el valor de LR completo sin problema aunque sea de 32 bits?

Estas ocupando 4 bytes del buffer siempre y cuando el buffer no sea leído. Si haces bien las cosas y no usas delays, eso no va a ocurrir. Si tu le envias datos a toda velocidad sin pausas, claramente el buffer se llenará y perderás algun dato. Pero hay que ser cuidadoso y tener sentido común. Para que enviar mas datos de los que puedas procesar, leer o guardar?

Repito, todo depende de como lees en tu nodemcu que hara las veces de receptor de esos datos. Si no pones delays todo fluirá. Además el código debe atender el envio de datos a ThinkSpeak y eso ya insume tiempo. Pero no te preocupes verás que no es para volverse loco.

  • Si en NodeMCU se va leyendo de byte en byte tendré que unir de 4 en 4 bytes para obtener el valor completo.

Si, es correcto, hay que rearmar el float.

  • Y sobre todo cómo obtener la velocidad de envío y lectura correcta para que todo vaya sincronizado y se pierda información.

Dependerá de cuanto quieres o prestendes actualizar los datos en ThingSpeak.

Resulta que luego dices, quiero un dato x minuto o un dato cada 10 minutos y entonces? Todo lo anterior es preocupación sin sentido. Pero si dices quiero un 100 datos x segundo, y claro pagas una cuenta de ThingSpeak que permita esa tasa, aún asi 100 floats x segundo serían 100x4x(8 mas bit de stop y paridad) hablamos de 4000 bits x segundo.. eso es NADA de NADA.

Buenas de nuevo surbyte. Para evitar el tener que unir los 4 bytes para reconstruir el float, lo que he hecho ha sido transmitir a NodeMCU la variable ‘val’ que es de 8 bits. El código es el siguiente, solo varía lo comentado.

#include <SoftwareSerial.h>
SoftwareSerial Trans(2, 3);                      //Pines para Rx y Tx.

//Declaración de variables del proceso

float valor_medido;                                //Valor obtenido al leer por A0.
int ledPin = 10;                                     //Pin de conexión del led de prueba.
float LR;                                               //Variable para almacenar la luminosidad relativa.
float val;                                              //Variable empleada para el mapeo del valor medido para enviarlo al pin 10.

void setup()
{
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  Trans.begin(115200);                           //Velocidad de envío para la transmisión al NodeMCU.
}

void loop()
{
  valor_medido = analogRead(A0);                      //Valor de luminosidad medido en A0
  LR = (valor_medido * 100) / 1023;                   //Luminosidad medida en tanto por ciento
  Serial.print(LR);                                               //Para mostrar el valor en el monitor serie de arduino.
  Serial.println(" % luminosidad relativa");
  delay(1000);
  val = map(valor_medido, 0, 1023, 0, 255);           //Mapeo del valor medido al rango de salida de las salidas digitales para 
                                                                           //encender el led.
  analogWrite(ledPin, val);
  delay(1000);
  Trans.print(val);                                                    //Transmisión del valor a NodeMCU.
  delay(1000);  
}

En el NodeMCU he cargado el código siguiente. Lo que he hecho ha sido leer el valor enviado de 8 bits y mapearlo para obtener el float y seguidamente realizar la operación para obtener de nuevo el valor de ‘LR’ y enviarlo al monitor serie para visualizarlo. El problema es que solo me ha mostrado un valor en el monitor serie del NodeMCU en letras raras para nada un valor numérico.

#include <SoftwareSerial.h>

void setup() {
  Serial.begin(9600);

}

void loop() {
   
  if (Serial.available()>0)

  {
    char byte_leido = Serial.read();
    float valor_medido=map(byte_leido, 0, 255, 0, 1023);
    float LR=((valor_medido*100)/1023);
    Serial.print(LR);
  }

}

En cuanto a las conexiones y configuración de ambas placas, he alimentado Arduino Uno y NodeMCU mediante USB una vez he cargado los códigos en cada placa. Habiendo seleccionado en cada caso la placa y el puerto correspondiente. Entre el pin 3 del Arduino que es el de Tx y el pin Rx de NodeMCU he puesto el divisor de tensión para obtener los 3,3V, conectando además los GND de cada placa y el del divisor entre sí como he leído en otros tutoriales. El resultado del monitor serie del NodeMCU es el que te he comentado antes, una sola recepción en letras raras.

¿Sabes donde puede estar el fallo de porqué no recibo bien las medidas en NodeMCU?
¿Qué fallos le ves a los códigos para que no se establezca bien la comunicación y los envíos?

He leído algo de que hay que conectar la primera vez el reset del NodeMCU a GND o algo así para que funcione, de esto último no lo tengo muy claro.

P.D.: En el monitor serie de Arduino Uno se visualiza correctamente las medidas de LR cada x tiempo.

26.20 % luminosidad relativa
27.96 % luminosidad relativa
28.54 % luminosidad relativa
34.51 % luminosidad relativa
31.77 % luminosidad relativa
17.01 % luminosidad relativa
11.73 % luminosidad relativa
25.22 % luminosidad relativa
27.57 % luminosidad relativa

Saludos y gracias de nuevo. Un abrazo.

Hay algunos errores como este en el nodemcu

float valor_medido=map(byte_leido, 0, 255, 0, 1023);

map esta armada para enteros o enteros largos.

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

No para float asi que esa funcion no esta bien implementada.
Luego esto conceptualmente… si envias 8 bits no puedes conseguir 10 gratis!!!

Si bajas de 10 a 8 como hiciste en el emisor, ya esta decidido y te quedas con 8 bits.

Porque no envias solo el valor de analogRead o sea unsigned int, que necesidad de convertirlo a float si no suma nada, por el contrario resta.

EMISOR

unsigned int valor_medido;                                //Valor obtenido al leer por A0.
int ledPin = 10;                                     //Pin de conexión del led de prueba.
float LR;                                               //Variable para almacenar la luminosidad relativa.
float val;                                              //Variable empleada para el mapeo del valor medido para enviarlo al pin 10.

void setup()
{
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  Trans.begin(115200);                           //Velocidad de envío para la transmisión al NodeMCU.
}

void loop()
{
  valor_medido = analogRead(A0);                      //Valor de luminosidad medido en A0
  LR = (valor_medido * 100) / 1023.0;                   //Luminosidad medida en tanto por ciento
  Serial.print(LR);                                               //Para mostrar el valor en el monitor serie de arduino.
  Serial.println(" % luminosidad relativa");
  delay(1000);                                                                           //encender el led.
  analogWrite(ledPin, val);
  delay(1000);
  Trans.print(valor_medido);                                                    //Transmisión del valor a NodeMCU.
  delay(1000);  
}

Receptor

//Declaración de variables del proceso
#include <SoftwareSerial.h>

void setup() {
  Serial.begin(9600);
}

void loop() {
   
  if (Serial.available()>0)   {
      int one = Serial.read();
      int two = Serial.read();

      unsigned int valor_medido = ( one - 48) *10 + (two - 48);

      float LR = ((valor_medido*100.0)/1023.0);
      Serial.print(LR);
  }
}

Prueba esto a ver si lee lo que estas enviando.