Datalogger con HC12

ciao
Sto cercando di realizzare una comunicazione tra 2 HC12 per trasmettere e ricevere dati di temperatura e umidità
Alla fine ci sarà un master con display e micro SD e 5 slave
I parametri sono gli stessi per entrambi i moduli
Riesco a trasmettere e ricevere il numero che ho attribuito al modulo (02) e solo talvolta i dati letti dal sensore
Grazie per qualsiasi suggerimento
Master

///////////////////////////////////////////////datalogger
/* Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
*/
//sezione oled
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
// The pins for I2C are defined by the Wire-library.
// On an arduino UNO:       A4(SDA), A5(SCL)

#define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
//fine sezione oled

#include <SoftwareSerial.h>

const byte HC12RxdPin = 2;                      // "RXD" Pin on HC12
const byte HC12TxdPin = 3;                      // "TXD" Pin on HC12
const byte HC12SetPin = 6;                      // "SET" Pin on HC12

SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

byte incomingByte;
String readBuffer = "";
boolean HC12End = false;

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer

  ///////////////////////////////////////////////////////////////////////sezione oled start
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS))
  {
    Serial.println(F("SSD1306 allocation failed"));
    for (;;); // Don't proceed, loop forever
  }

  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setTextSize(1);
  display.setCursor(20, 0);
  display.print("STYRABAG AG");

  // Show initial display buffer contents on the screen --
  // the library initializes this with an Adafruit splash screen.
  display.display();
  delay(2000); // Pause for 2 seconds
  display.clearDisplay();
  /////////////////////////////////////////////////////////////////////////sezione oled fine

  ///////////////////////////////////////////////////////////sezione HC12 start
  HC12.begin(9600);                         // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);
  ///////////////////////////////////////////////////////////sezione HC12 fine

  delay(500);
}

void loop()
{
  
  HC12.print("02");      // Send code to HC-12 remote sensor unit
  delay(500);
  HC12.print('\n');      // Send code to HC-12 remote sensor unit
  delay(500);
  Serial.println("waiting for data");
  delay(500);

  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    readBuffer += char(incomingByte);     // Add each byte to ReadBuffer string variable
    Serial.print(readBuffer);             // Send the data to Serial monitor

    if (readBuffer == "00")
    {
      HC12End = true;
      Serial.println("HC12End");             // Send the data to Serial monitor
    }
    
    display.clearDisplay();
  }
  
///////////////////////////////////////////////////////////////////////sezione oled start
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setTextSize(1);
  display.setCursor(20, 0);
  display.println("STYRABAG AG");
  display.setTextSize(2);      // Normal 1:1 pixel scale
  display.print(readBuffer);
  display.display();  // Show initial display buffer contents on the screen
   /////////////////////////////////////////////////////////////////////sezione oled fine
   
  readBuffer = "";
  
 // delay(2000); // Pause for 2 seconds  readBuffer = "";
}

Slave

///////////////////////////////////////////////datalogger
/*  HC12 Send/Receive Example Program 1
    By Mark J. Hughes
    for AllAboutCircuits.com

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
*/
//htu21d start

#include <Wire.h>
#include "Adafruit_HTU21DF.h"

// Connect Vin to 3-5VDC
// Connect GND to ground
// Connect SCL to I2C clock pin (A5 on UNO)
// Connect SDA to I2C data pin (A4 on UNO)

Adafruit_HTU21DF htu = Adafruit_HTU21DF();

#include <SoftwareSerial.h>

float h;
float t;

const byte HC12RxdPin = 2;  //HC12 "RXD" Pin on HC12
const byte HC12TxdPin = 3;  //HC12 "TXD" Pin on HC12
const byte HC12SetPin = 4;  //HC12 "SET" Pin on HC12

SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

String sensorNum = "02";

char incomingByte;
String readBuffer = "";
boolean HC12End = false;

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer

  if (!htu.begin())
  {
    Serial.println("Couldn't find sensor!");
    while (1);
  }

  /////////////////////////////////////////////////////////sezione HC12 start
  HC12.begin(9600);             // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);
  ///////////////////////////////////////////////////////////sezione HC12 fine

  delay(500);
}

void loop()
{
  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    readBuffer += char(incomingByte);     // Add each byte to ReadBuffer string variable
    Serial.println(readBuffer);             // Send the data to Serial monitor
//    if (readBuffer == '\n')
//    {
//      HC12End = true;
//      Serial.println("HC12End");             // Send the data to Serial monitor
//    }

  }
  if (readBuffer == sensorNum)
  {
//    HC12End = false;
    readBuffer = "";
    
    

    t = htu.readTemperature();
    h = htu.readHumidity();

    Serial.print("Temp: "); Serial.print(t); Serial.print(" C");
    Serial.print("\t");
    Serial.print("Humidity: "); Serial.print(h); Serial.println(" \%");

    delay(3000);

    // check if returns are valid, if they are NaN (not a number) then something went wrong!
    if (isnan(t) || isnan(h))
    {
      Serial.println("Failed to read from DHT");

      delay(500);
    }
    else
    {
      Serial.println("Sending data");
      //      HC12.print("S ");
      //      HC12.print(sensorNum);
      //      HC12.print('\n');
      HC12.print("h ");
      HC12.println(h);
      HC12.print('\n');
      HC12.print("t ");
      HC12.println(t);
      HC12.print('\n');
      HC12.print("00");
    }
  }
}





//void sendData(float h)
//{
//  HC12.write(h);
//  HC12.print("|");
//  HC12.print('\n');
//
//  ////sends the angle value with start marker "s" and end marker "e"
//  //  HC12.print("s" + angleString + "e");
//}

Ci sono alcune cose non ideali

Tu gestisci in maniera farraginosa lo handshaking tra le due macchine

Inoltre usi oggetti stringa, che sono sempre un male

Come ti ho detto a dicembre vai a dare uno sguardo a "termoremoto non è termometro"

Fino a che userai oggetti stringa non risponderò più

Grazie per il feedback
recupero il link

ciao
riprendo questo topic per chiedere se avete idea del perchè accade
con queste righe ho il seguente output

Serial.println("sending DATA to HC ");
      delay(50);
      HC12.print(t);
      HC12.print('\n');
      HC12.print(rh);
      HC12.print(endComm);

    float temp = htu.readTemperature();
    float rel_hum = htu.readHumidity();
    Serial.print("Temp: "); Serial.print(t); Serial.print(" C");
    Serial.print("\t\t");
    Serial.print("Humidity: "); Serial.print(rh); Serial.println(" \%");
    delay(500);

output

sending DATA to HC 
Temp: 23.44 C		Humidity: 60.97 %

invece con queste righe ho il seguente output

      Serial.println("sending DATA to HC ");
      delay(50);
      HC12.print(t);
      HC12.print('\n');
      HC12.print(rh);
      HC12.print(endComm);

//    float temp = htu.readTemperature();
//    float rel_hum = htu.readHumidity();
    Serial.print("Temp: "); Serial.print(t); Serial.print(" C");
    Serial.print("\t\t");
    Serial.print("Humidity: "); Serial.print(rh); Serial.println(" \%");
    delay(500);

output

sending DATA to HC 
Temp: ⸮&	⸮⸮⸮(⸮]⸮⸮⸮⸮⸮⸮ 61.33 %

qui sotto il codice completo

#include <Wire.h>
#include "Adafruit_HTU21DF.h"

// Connect Vin to 3-5VDC
// Connect GND to ground
// Connect SCL to I2C clock pin (A5 on UNO)
// Connect SDA to I2C data pin (A4 on UNO)

Adafruit_HTU21DF htu = Adafruit_HTU21DF();

//htu21d end

#include <SoftwareSerial.h>

float t;
float rh;

const byte HC12RxdPin = 2;  //HC12 "RXD" Pin on HC12
const byte HC12TxdPin = 3;  //HC12 "TXD" Pin on HC12
const byte HC12SetPin = 6;  //HC12 "SET" Pin on HC12

SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

char incomingByte;
String readBuffer = "";

String sensornum;
char startComm;
char endComm;

byte sensorType = 'h';

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer

  t = 0.0;
  rh = 0.0;
  
  sensornum = "<3>";
  //  startComm = '<';
  endComm = '>';

  if (!htu.begin())
  {
    Serial.println("Couldn't find sensor!");
    while (1);
  }

  //sezione HC12 start
  HC12.begin(9600);                         // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);
  //sezione HC12 fine

  delay(500);
}

void loop()
{
  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    //    Serial.print("incomingByte ");             // Send the data to Serial monitor
    //    Serial.println(incomingByte);             // Send the data to Serial monitor
    readBuffer += incomingByte;     // Add each byte to ReadBuffer string variable
    Serial.print("readBuffer ");             // Send the data to Serial monitor
    Serial.println(readBuffer);             // Send the data to Serial monitor
  }

  //    if (incomingByte == char(sensornum))  // At the end of the line
  //    {
  if (readBuffer == sensornum )  // At the end of the line
  {
    Serial.print("readBuffer X ");             // Send the data to Serial monitor
    Serial.print(readBuffer);             // Send the data to Serial monitor
    Serial.println();

    t = htu.readTemperature();
    rh = htu.readHumidity();

    delay(100);

    // check if returns are valid, if they are NaN (not a number) then something went wrong!
    if (isnan(t) || isnan(rh))
    {
      Serial.println("Failed to read from DHT");

      delay(50);
    }
    else
    {
      Serial.println("sending DATA to HC ");
      delay(50);
      HC12.print(t);
      HC12.print('\n');
      HC12.print(rh);
      HC12.print(endComm);

    float temp = htu.readTemperature();
    float rel_hum = htu.readHumidity();
    Serial.print("Temp: "); Serial.print(t); Serial.print(" C");
    Serial.print("\t\t");
    Serial.print("Humidity: "); Serial.print(rh); Serial.println(" \%");
    delay(500);
    }
  }
  readBuffer = "";
}

grazie

ciao
per condivisione
qui sotto il codice per il master
interroga singolarmente i sensori, riceve e scrive su SD

sensorNumTot = 2;

conla riga sopra si indica il numero dei sensori da leggere

/*
  HC12 Send/Receive Example Program 1
    By Mark J. Hughes
    for AllAboutCircuits.com

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
    RX

      The circuit:
   analog sensors on analog ins 0, 1, and 2
   SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)

*/

#include <SPI.h>

#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

///////////////////////////////////sezione datalogger

#include <SD.h>
byte pinCS = 4;
File dataFile;

///////////////////////////////////////////////////////////sezione HC12 start
#include <SoftwareSerial.h>
const byte HC12RxdPin = 2;                      // "RXD" Pin on HC12
const byte HC12TxdPin = 3;                      // "TXD" Pin on HC12
const byte HC12SetPin = 6;                      // "SET" Pin on HC12
SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin
///////////////////////////////////////////////////////////sezione HC12 stop

char incomingByte;
String readBuffer = "";
boolean HC12End = false;

byte sensorNum, sensorNumTot;
char startComm;
char endComm;
String sensorNumTX;
String Time;

long interval;
unsigned long previousMillis;        // will store last time was updated
unsigned long currentMillis;

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer
  Wire.begin();

  //sezione SD start

  pinMode(pinCS, OUTPUT);
  Serial.print("Initializing SD card...");

  if (!SD.begin(pinCS))// see if the card is present and can be initialized:
  {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");

  //sezione SD fine

  //sezione HC12 start
  HC12.begin(9600);                         // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);

  //sezione HC12 fine

  startComm = '<';
  endComm = '>';
  sensorNum = 1;
  sensorNumTot = 2;
  sensorNumTX = "";

  previousMillis = 0;
  currentMillis = millis();
  interval = 5000;

  delay(5000);
}

void loop()
{
  sensorNumTX += String(sensorNum);
  sensorNumTX += startComm;

  HC12.print(sensorNumTX);

  Serial.println(sensorNumTX);
  sensorNumTX = "";

  delay(10);

  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    readBuffer += incomingByte;     // Add each byte to ReadBuffer string variable
    //  Serial.println(readBuffer);             // Send the data to Serial monitor

    if (incomingByte == endComm)
    {
      //sezione RTC
      tmElements_t tm;

      //  if (RTC.read(tm)) {
      //    Serial.print("Ok, Time = ");
      //    print2digits(tm.Hour);
      //    Serial.write(':');
      //    print2digits(tm.Minute);
      //    Serial.write(':');
      //    print2digits(tm.Second);
      //    Serial.print(", Date (D/M/Y) = ");
      //    Serial.print(tm.Day);
      //    Serial.write('/');
      //    Serial.print(tm.Month);
      //    Serial.write('/');
      //    Serial.print(tmYearToCalendar(tm.Year));
      //    Serial.println();
      //  } else {
      //    if (RTC.chipPresent()) {
      //      Serial.println("The DS1307 is stopped.  Please run the SetTime");
      //      Serial.println("example to initialize the time and begin running.");
      //      Serial.println();
      //    } else {
      //      Serial.println("DS1307 read error!  Please check the circuitry.");
      //      Serial.println();
      //    }

      if (RTC.read(tm))
      {
        Time += tm.Day;
        Time += '/';
        Time += tm.Month;
        Time += '/';
        Time += tmYearToCalendar(tm.Year);
        Time += " ";
        Time += tm.Hour;
        Time += ':';
        Time += tm.Minute;
        Time += ':';
        Time += tm.Second;        
      }
      else
      {
        if (RTC.chipPresent())
        {
          Serial.println("The DS1307 is stopped.  Please run the SetTime");
          Serial.println("example to initialize the time and begin running.");
          Serial.println();
        }
        else
        {
          Serial.println("DS1307 read error!  Please check the circuitry.");
          Serial.println();
        }
      }
      Serial.print(Time);
      Serial.print('\t');
      Serial.print("readBuffer to file ");// Send the data to Serial monitor
      Serial.println(readBuffer);// Send the data to Serial monitor

      // open the file. note that only one file can be open at a time,
      // so you have to close this one before opening another.
      dataFile = SD.open("datalog.txt", FILE_WRITE);

      if (dataFile) // if the file is available, write to it:
      {
        //sezione SD
        dataFile.print(Time);
        dataFile.print('\t');
        dataFile.println(readBuffer);

        dataFile.close();

        readBuffer = "";
        Time = "";
      }
      else  // if the file isn't open, pop up an error:
      {
        Serial.println("error opening datalog.txt");
      }

    }
  }

  sensorNum++;
  if (sensorNum == sensorNumTot + 1)
  {
    sensorNum = 1;
  }

  delay(interval);
}



void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    Serial.write('0');
  }

  Serial.print(number);
}

qui sotto il codice per gli slave

  sensorNum = '1';
  sensorNumRX = "1<";

aggiornare queste righe di fare l upload

/*  HC12 Send/Receive Example Program 1
    By Mark J. Hughes
    for AllAboutCircuits.com

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
    TX slave
*/
//htu21d start

#include <Wire.h>
#include "Adafruit_HTU21DF.h"

// Connect Vin to 3-5VDC
// Connect GND to ground
// Connect SCL to I2C clock pin (A5 on UNO)
// Connect SDA to I2C data pin (A4 on UNO)

Adafruit_HTU21DF htu = Adafruit_HTU21DF();

//htu21d end

#include <SoftwareSerial.h>

float t;
float rh;

byte count;

const byte HC12RxdPin = 2;  //HC12 "RXD" Pin on HC12
const byte HC12TxdPin = 3;  //HC12 "TXD" Pin on HC12
const byte HC12SetPin = 6;  //HC12 "SET" Pin on HC12

SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

char incomingByte = "";
String readBuffer = "";
String data = "";

String sensorNum, sensorNumRX;
char startComm;
char endComm;

byte sensorType = 'h';

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer

  t = 0.0;
  rh = 0.0;
  count = 1;

  sensorNum = '1';
  sensorNumRX = "1<";
  startComm = '<';
  endComm = '>';

  if (!htu.begin())
  {
    Serial.println("Couldn't find sensor!");
    while (1);
  }
  else
  {
    Serial.println("HTU21D ready");
  }

  //sezione HC12 start
  HC12.begin(9600);                         // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);
  //sezione HC12 fine

  delay(5000);
}

void loop()
{
  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    readBuffer += incomingByte;     // Add each byte to ReadBuffer string variable

    Serial.print("readBuffer B ");             // Send the data to Serial monitor
    Serial.println(readBuffer);             // Send the data to Serial monitor

    if (incomingByte == '>')
    {
      readBuffer = "";
    }

    if (readBuffer == sensorNumRX && incomingByte == '<')
    {
      Serial.print("readBuffer C ");             // Send the data to Serial monitor
      Serial.print(readBuffer);             // Send the data to Serial monitor
      Serial.println();

      count++;
      if (count > 100)
      {
        count = 1;
      }

      t = htu.readTemperature();
      rh = htu.readHumidity();

      // check if returns are valid, if they are NaN (not a number) then something went wrong!

      if (!htu.begin())
      {
        Serial.println("Couldn't find sensor!");
        while (1);
      }
      else
      {
        data += sensorNum;
        data += " ";
        data += count;
        data += " ";
        data += "°C";
        data += " ";
        data += t;
        data += " ";
        data += '%';
        data += " ";
        data += rh;
        data += " ";
        data += endComm;
      }
      Serial.println("sending DATA to HC12 ");

      HC12.print(data);

      Serial.print("data ");
      Serial.println(data);


      //      Serial.print("sensorNum "); Serial.print(sensorNum);
      //      Serial.println();
      //      Serial.print("count "); Serial.print(count);
      //      Serial.println();
      //      Serial.print("Temp: "); Serial.print(t); Serial.print(" C");
      //      Serial.print('\t');
      //      Serial.print("Humidity: "); Serial.print(rh); Serial.print(" \%");
      //      Serial.println();
      data = "";

      readBuffer = "";
    }

  }

  data = "";

  readBuffer = "";

}



//void sendData(float h)
//{
//  HC12.write(h);
//  HC12.print("|");
//  HC12.print('\n');
//
//  ////sends the angle value with start marker "s" and end marker "e"
//  //  HC12.print("s" + angleString + "e");
//}

buonasera
ritorno su questo post con un problema
sul RX ricevo la stringa di dati incompleta dal TX
il programma zoppicando ma non andava male fino ad adesso ma zoppicava
cercando di migliorarlo mi trovo adesso con questo problema
ogni suggerimento è benvenuto
RX

1<
1
1,
1,5
1,55
1,55,
1,55,1
1,55,19
1,55,19.
1,55,19.9
1,55,19.98
1,55,19.98,
1,55,19.98,⸮
1,55,19.98,°
1,55,19.98,°C
1,55,19.98,°C,
1,55,19.98,°C,5

TX

readBuffer B 1
readBuffer B 1<
readBuffer C 1<
sending DATA to HC12 
data 1,55,19.98,°C,58.29,%,>

sotto il programma del RX

/*
  HC12 Send/Receive Example Program 1
    By Mark J. Hughes
    for AllAboutCircuits.com

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
    RX

      The circuit:
   analog sensors on analog ins 0, 1, and 2
   SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)

*/

#include <SPI.h>

#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

///////////////////////////////////sezione datalogger

#include <SD.h>
byte pinCS = 4;
File dataFile;

///////////////////////////////////////////////////////////sezione HC12 start
#include <SoftwareSerial.h>
const byte HC12RxdPin = 2;                      // "RXD" Pin on HC12
const byte HC12TxdPin = 3;                      // "TXD" Pin on HC12
const byte HC12SetPin = 6;                      // "SET" Pin on HC12
SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin
///////////////////////////////////////////////////////////sezione HC12 stop

char incomingByte;
String readBuffer = "";
boolean HC12End = false;

byte sensorNum, sensorNumTot;
char startComm;
char endComm;
String sensorNumTX;
String Time;
String data;

long interval;
unsigned long previousMillis;        // will store last time was updated
unsigned long currentMillis;

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer
  Wire.begin();

  //sezione SD start

  pinMode(pinCS, OUTPUT);
  Serial.println("Initializing SD card...");

  if (!SD.begin(pinCS))// see if the card is present and can be initialized:
  {
    Serial.println("Card failed, or not present");// don't do anything more
    while (1);
  }
  Serial.println("SD card initialized.");

  //sezione SD fine

  //sezione HC12 start
  HC12.begin(9600);                         // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);

  //sezione HC12 fine

  startComm = '<';
  endComm = '>';
  sensorNum = 1;
  sensorNumTot = 2;
  sensorNumTX = "";

  previousMillis = 0;
  currentMillis = millis();
  interval = 5000;

  delay(5000);
}

void loop()
{
  sensorNumTX += String(sensorNum);
  sensorNumTX += startComm;

  HC12.print(sensorNumTX);

  Serial.println(sensorNumTX);
  sensorNumTX = "";

  delay(300);

  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    readBuffer += incomingByte;     // Add each byte to ReadBuffer string variable
    Serial.println(readBuffer);             // Send the data to Serial monitor

    if (incomingByte == endComm)
    {
      //sezione RTC
      tmElements_t tm;
      if (RTC.read(tm))
      {
        Time += tm.Day;
        Time += '/';
        Time += tm.Month;
        Time += '/';
        Time += tmYearToCalendar(tm.Year);
        Time += " ";

        print2digits(tm.Hour);
        Time += tm.Hour;
        Time += ':';
        print2digits(tm.Minute);
        Time += tm.Minute;
        Time += ':';
        print2digits(tm.Second);
        Time += tm.Second;
      }
      else
      {
        if (RTC.chipPresent())
        {
          Serial.println("The DS1307 is stopped.  Please run the SetTime");
          Serial.println("example to initialize the time and begin running.");
          Serial.println();
        }
        else
        {
          Serial.println("DS1307 read error!  Please check the circuitry.");
          Serial.println();
        }
      }

      data += Time;
      data += ',';
      data += readBuffer;
      
      Serial.println(data);

      // open the file. note that only one file can be open at a time,
      // so you have to close this one before opening another.
      dataFile = SD.open("datalog.txt", FILE_WRITE);

      if (dataFile) // if the file is available, write to it:
      {
        dataFile.println(data);
        dataFile.close();

        readBuffer = "";
        Time = "";
        data = "";
      }
      else  // if the file isn't open, pop up an error:
      {
        Serial.println("error opening datalog.txt");
      }

      sensorNum++;
      if (sensorNum == sensorNumTot + 1)
      {
        sensorNum = 1;
      }
    }
  }

  delay(interval);

  readBuffer = "";
  Time = "";
  data = "";
}



void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    // Serial.write('0');
    Time += '0';
  }
  // Serial.print(number);
}

ancora qua
ho accorciato il ciclo while ma ancora non ricevo la stringa completa

/*
  HC12 Send/Receive Example Program 1
    By Mark J. Hughes
    for AllAboutCircuits.com

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
    RX

      The circuit:
   analog sensors on analog ins 0, 1, and 2
   SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)

*/

#include <SPI.h>

#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

///////////////////////////////////sezione datalogger

#include <SD.h>
byte pinCS = 4;
File dataFile;

///////////////////////////////////////////////////////////sezione HC12 start
#include <SoftwareSerial.h>
const byte HC12RxdPin = 2;                      // "RXD" Pin on HC12
const byte HC12TxdPin = 3;                      // "TXD" Pin on HC12
const byte HC12SetPin = 6;                      // "SET" Pin on HC12
SoftwareSerial HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin
///////////////////////////////////////////////////////////sezione HC12 stop

char incomingByte;
String readBuffer = "";
boolean HC12End = false;

byte sensorNum, sensorNumTot;
char startComm;
char endComm;
String sensorNumTX;
String Time;
String data;

long interval;
unsigned long previousMillis;        // will store last time was updated
unsigned long currentMillis;

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer
  Wire.begin();

  //sezione SD start

  pinMode(pinCS, OUTPUT);
  Serial.println("Initializing SD card...");

  if (!SD.begin(pinCS))// see if the card is present and can be initialized:
  {
    Serial.println("Card failed, or not present");// don't do anything more
    while (1);
  }
  Serial.println("SD card initialized.");

  //sezione SD fine

  //sezione HC12 start
  HC12.begin(9600);                         // Open serial port to HC12
  Serial.println("HC12 ready:");
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);

  //sezione HC12 fine

  startComm = '<';
  endComm = '>';
  sensorNum = 1;
  sensorNumTot = 2;
  sensorNumTX = "";

  previousMillis = 0;
  currentMillis = millis();
  interval = 5000;

  delay(5000);
}

void loop()
{
  sensorNumTX += String(sensorNum);
  sensorNumTX += startComm;

  HC12.print(sensorNumTX);

  Serial.println(sensorNumTX);
  sensorNumTX = "";

  delay(250);

  while (HC12.available()) // If HC-12 has data
  {
    incomingByte = HC12.read();           // Store each icoming byte from HC-12
    readBuffer += incomingByte;     // Add each byte to ReadBuffer string variable
   // Serial.println(readBuffer);             // Send the data to Serial monitor
  }
  
    if (incomingByte == endComm)
    {
      //sezione RTC
      tmElements_t tm;
      if (RTC.read(tm))
      {
        Time += tm.Day;
        Time += '/';
        Time += tm.Month;
        Time += '/';
        Time += tmYearToCalendar(tm.Year);
        Time += " ";

        print2digits(tm.Hour);
        Time += tm.Hour;
        Time += ':';
        print2digits(tm.Minute);
        Time += tm.Minute;
        Time += ':';
        print2digits(tm.Second);
        Time += tm.Second;
      }
      else
      {
        if (RTC.chipPresent())
        {
          Serial.println("The DS1307 is stopped.  Please run the SetTime");
          Serial.println("example to initialize the time and begin running.");
          Serial.println();
        }
        else
        {
          Serial.println("DS1307 read error!  Please check the circuitry.");
          Serial.println();
        }
      }

      data += Time;
      data += ',';
      data += readBuffer;
      
      Serial.println(data);

      // open the file. note that only one file can be open at a time,
      // so you have to close this one before opening another.
      dataFile = SD.open("datalog.txt", FILE_WRITE);

      if (dataFile) // if the file is available, write to it:
      {
        dataFile.println(data);
        dataFile.close();

        readBuffer = "";
        Time = "";
        data = "";
      }
      else  // if the file isn't open, pop up an error:
      {
        Serial.println("error opening datalog.txt");
      }

      sensorNum++;
      if (sensorNum == sensorNumTot + 1)
      {
        sensorNum = 1;
      }
    }
 

  delay(interval);

  readBuffer = "";
  Time = "";
  data = "";
}



void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    // Serial.write('0');
    Time += '0';
  }
  // Serial.print(number);
}

secondo me che ti frega è la tempistica, mi spiego:
tu trasmetti la stringa di interrogazione dei singoli sensori
poi aspetti un quarto di secondo
poi ti metti in attesa che il buffer di ricezione sia vuoto
e poi, se hai ricevuto il carattere di finetrasmissione tratti la stringa ricevuta
e poi passi al sensore successivo
mi sembra che tu debba esaminare anche il caso che tu "non" abbia ricevuto il carattere di fine trasmissione, ma che grazie alla velocità di arduino tu abbia comunque svuotato il buffer di ricezione
non chiedermi come fare, io quel programma lo butteri via direttamente, fai uso di String e inizializzi/azzeri le variabili in maniera poco ordinata

grazie per il riscontro
torno a lavorarci

In questo modo esce dal while quando incomingByte == endComm.

Nota che endComm viene aggiunto a readBuffer, se non lo desideri la if la sposti una riga sopra.

PS: secondo me è meglio che crei un altro scketch dove hai solo il necessario per testare la comunicazione. Poi quando funziona pensi a rendere più robusto il protocollo e solo dopo pensi al resto.
Ciao.

Grazie per il riscontro
Torno a lavorarci
Il test fatto non era male ma non perfetto
Torno a studiarmi il programma di @Standardoil

ciao
eccomi di ritorno
eliminato oggetti stringa
incompleto ma meglio di prima
sotto la stampa di controllo lato trasmittente

0	1
1	8
2	.
3	3
4	7
5
6

0	6
1	0
2	.
3	3
4	1
5
6		

sending DATA to HC12 
18.37
60.31

questo lato ricevente, ma manca una parte della stringa, cerco idee su come trattare i valori mancanti

#1>
#1,C,18.37
#2>
#3>
#4>
#5>
#1>
#1,C,18.27
#2>
#3>
#4>
#5>
#1>
#1,C,18.26
#2>
#3>
#4>

qui sotto lo sketch della trasmittente

/*  HC12 Send/Receive

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
    TX slave
*/
//librerie
//htu21d
#include <Wire.h>
#include "Adafruit_HTU21DF.h"

// Connect Vin to 3-5VDC
// Connect GND to ground
// Connect SCL to I2C clock pin (A5 on UNO)
// Connect SDA to I2C data pin (A4 on UNO)

Adafruit_HTU21DF htu = Adafruit_HTU21DF();

#include <SoftwareSerial.h>

float t;
float rh;

char START;// carattere di start trasmissione
char END;// carattere di end trasmissione
char sensorNum;//codice della stazione
char rx;//variabile di appoggio


const byte HC12RxdPin = 2;  //HC12 "RXD" Pin on HC12
const byte HC12TxdPin = 3;  //HC12 "TXD" Pin on HC12
const byte HC12SetPin = 6;  //HC12 "SET" Pin on HC12

SoftwareSerial Radio_HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

char readBuffer[5] = "";
char data[25] = "";
char dataT[10] = "";
char dataRH[10] = "";
char count_[2] = "";

int count;
byte i, j;//contatori


//sezione delay con millis()
unsigned long previousMillis;        // will store last time LED was updated
unsigned long currentMillis;
long interval;


void setup()
{
  Serial.begin(9600);                       // Open serial port to computer

  t = 0.0;//inizializzo variabili sensore
  rh = 0.0;//inizializzo variabili sensore

  count = 0;

  if (!htu.begin())
  {
    Serial.println("HTU21D Couldn't find sensor!");
    while (1);
  }
  else
  {
    Serial.println("HTU21D ready");
  }

  //sezione HC12
  Radio_HC12.begin(9600);// Open serial port to HC12

  Serial.println("HC12 ready:");

  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);

  i = 0;//indice vettore
  j = 0;//indice vettore

  START = '#';// carattere di start trasmissione
  END = '>';// carattere di end trasmissione
  sensorNum = '1';//codice della stazione

  previousMillis = 0;
  interval = 1000;

  delay(2000);
}

void loop()
{
  while (Radio_HC12.available())
  {
    rx = Radio_HC12.read();

    if (rx == START)
    {
      readBuffer[0] = rx;
    }

    if (rx == sensorNum)
    {
      readBuffer[1] = rx;
    }
    if (rx == END)
    {
      readBuffer[2] = rx;
    }
  }

  if (readBuffer[0] == START && readBuffer[1] == sensorNum && readBuffer[2] == END)
  {

    readBuffer[0] = "";
    readBuffer[1] = "";
    readBuffer[2] = "";

    //    byte j = count++;
    //
    //    count_[0] = j;
    //    count_[1] = '\0';
    //    Serial.println(i);
    //    Serial.println(char(count_[0]));
    //    //  Serial.println(count_[1]);
    //
    //    if (count >= 100)
    //    {
    //      count = 1;
    //    }

    t = htu.readTemperature();
    rh = htu.readHumidity();

    Serial.println(t);
    Serial.println(rh);

    dtostrf(t, 4, 2, dataT);

    i = 0;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataT[i]);

    i = 0;

    Serial.println();

    dtostrf(rh, 4, 2, dataRH);
    i = 0;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i++;
    Serial.print(i);
    Serial.print('\t');
    Serial.println(dataRH[i]);

    i = 0;

    //check if returns are valid, if they are NaN (not a number) then something went wrong!
    if (!htu.begin())
    {
      Serial.println("Couldn't find sensor!");
      while (1);
    }
    else
    {
      data[0] = START;
      i++;
      data[i] = sensorNum;
      i++;
      data[i] = ',';
      i++;
      data[i] = 'C';//contatore
      i++;
      data[i] = ',';

      for (byte k = 0; k < 10; k++)
      {
        if (dataT[k] != "")
        {
          i++;
          data[i] = dataT[k];
        }
      }

      i++;
      data[i] = ',';

      for (byte k = 0; k < 10; k++)
      {
        if (dataRH[k] != "")
        {
          i++;
          data[i] = dataRH[k];
        }
      }

      i++;
      data[i] = ',';
      i++;
      data[i] = '%';
      i++;
      data[i] = ',';
      i++;
      data[i] = END;

      i = 0;

      Serial.println("sending DATA to HC12 ");

      Radio_HC12.print(data);

      //      Radio_HC12.println(dataT);
      //      Radio_HC12.println(dataRH);

      Radio_HC12.println();

      Serial.println(dataT);
      Serial.println(dataRH);
    }
  }

}

grazie

Ne parlavo con papà ieri
Lo vedo inutilmente complesso
E comunque il test sui caratteri non si fa usando stringhe nulle

Intendo dire che se non metti il programma della ricevente non saprei cosa dirti

ciao
sotto il programma della ricevente
testo un pezzo alla volta

//from Nelson StandardOil
//from progetto stagioneriscaldamento
//from termometri distribuiti - unità centrale
//from termometri distribuiti >> unità centrale

// libreries
// per le radio
#include <SoftwareSerial.h>
const byte HC12RxdPin = 2;                      // "RXD" Pin on HC12
const byte HC12TxdPin = 3;                      // "TXD" Pin on HC12
const byte HC12SetPin = 6;                      // "SET" Pin on HC12
SoftwareSerial Radio_HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

#define START '#'// carattere di start trasmissione
#define END '>'// carattere di end trasmissione
char rx;
byte index;
char stringa[25];

const byte MAXRX = 25;


//per la parte orologio
#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

//Scheda SD
#include <SPI.h>
#include <SD.h>
byte chipSDSelect;
File dataFile;

char logfile; // contenitore per nome file di log

byte sensorNumTot;
char id_sensor[7];//vettore codice stazione aggiungere le stazioni se serve

byte i;



//sezione delay con millis()
unsigned long previousMillis;        // will store last time LED was updated
unsigned long currentMillis;
long interval;


void setup()
{
  Serial.begin(9600);                       // Open serial port to computer
  Wire.begin();

  Radio_HC12.begin(9600);                         // Open serial port to HC12
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);
  Serial.println("HC12 ready:");

  chipSDSelect = 4;
  pinMode(chipSDSelect, OUTPUT);
  Serial.println("Initializing SD card...");

  if (!SD.begin(chipSDSelect))// see if the card is present and can be initialized:
  {
    Serial.println("Card failed, or not present");// don't do anything more
    while (1);
  }
  Serial.println("SD card initialized.");

  i = 1;

  logfile = "datalog.txt"; // contenitore per nome file di log

  sensorNumTot = 5;

  id_sensor[0] = START; //carattere inizio trasmissione
  id_sensor[1] = '1'; //aggiungere le stazioni se serve
  id_sensor[2] = '2'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[3] = '3'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[4] = '4'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[5] = '5'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[6] = END; //caratte fine trasmissione

  interval = 3000;//frequenza delle interrogazioni delle stazioni

  previousMillis = 0;

  rx = "";
  index = 0;
  stringa[25] = "";

}

void loop()
{
  currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;// save the last time

    Radio_HC12.print(id_sensor[0]);// carattere di start trasmissione
    Radio_HC12.print(id_sensor[i]);//codice stazione TU
    Radio_HC12.println(id_sensor[6]);// carattere di end trasmissione

    Serial.print(id_sensor[0]);// carattere di start trasmissione
    Serial.print(id_sensor[i]);//codice stazione TU
    Serial.println(id_sensor[6]);// carattere di end trasmissione

    i++;
    if (i > sensorNumTot)
    {
      i = 1;
    }
  }

  if (Radio_HC12.available())
  {
    Serial.print(char (Radio_HC12.read()));

    /*rx = Radio_HC12.read(); // sono sicuro che esista un carattere dal leggere, altrimenti non sarebbe stata chiamata

    if (rx == START)
    {
      index = 1;
      stringa[0] = rx;
      //return;
      // sempre un carattere trattato, fuori dalla funzione
      Serial.print("ricevuto carattere START");
    }

    if (index > 0 && index < MAXRX)
    {
      stringa[index++] = rx;// se abbiamo sentito un carattere di start e non abbiamo indice fuori range
      // la radioricevi riceve e tratta i dati dalle radio
      //  Radioricevi();
      Serial.print("scrivo stringa");
      Serial.print(index);
      Serial.print(stringa);
    }
    
    
    if (rx == END)
    {
      Serial.println("fine trasmissione")
      rx = "";
    }*/

  }

}



/*void Radioricevi(void)
  {
  // riceve e tratta i dati dalla radio
  static char stringa[MAXRX]; // il buffer di appoggio della trasmissione
  static byte index = 0;
  char rx = Radio_HC12.read(); // sono sicuro che esista un carattere dal leggere, altrimenti non sarebbe stata chiamata

  if (rx == START)
  {
    index = 1;
    stringa[0] = rx;
    return;
    // sempre un carattere trattato, fuori dalla funzione
  }

  if (index > 0 && index < MAXRX)
  {
    // se abbiamo sentito un carattere di start
    // e non abbiamo indice fuori range
    stringa[index++] = rx;

    return;
  }
  }
*/


/*void scrivi(char logfile[], char indirizzo, char stringa[])
  {
  // scrive su un file la stringa
  // Data, ora, indirizzo, valori di temperatura e umidita'
  File datafile;
  datafile = SD.open(logfile, FILE_WRITE);

  if (datafile)
  {
    // ok file aperto
    datafile.print(year());

    datafile.print('/');

    if (month() < 10)
    {
      datafile.print('0');
    }

    datafile.print(month());

    datafile.print('/');

    if (day() < 10)
    {
      datafile.print('0');
    }

    datafile.print(day());

    datafile.print(',');

    if (hour() < 10)//scrive ora
    {
      datafile.print('0');
    }

    datafile.print(hour());

    datafile.print(':');

    if (minute() < 10)//scrive minuti
    {
      datafile.print('0');
    }
    datafile.print(minute());

    datafile.print(':');

    if (second() < 10)//scrive secondi
    {
      datafile.print('0');
    }

    datafile.print(second());

    datafile.print(',');//separatore campi

    datafile.print(indirizzo);
    datafile.print(',');
    datafile.println(stringa);
    datafile.close();
  }
  else
  {
    Serial.println(F("Errore apertura file di log"));
  }
  }*/

//void print2digits(int number)
//{
//  if (number >= 0 && number < 10)
//  {
//    // Serial.write('0');
//    Time += '0';
//  }
//  // Serial.print(number);
//}

Il problema è che entrambe ricevono e trasmettono, invece di chiamarli così per differenziarli usa Master (principale) per arduino che invia le interrogazioni agli slave (schiavi) e appunto Slave per gli arduino che ricevono richieste dal master e rispondono.

Dal codice postato ti consiglio di studiare bene gli array la codifica ASCII ecc. Ma proprio bene bene.

Ciao.

E funziona? Vedi quello che ti aspetti?

ciao
un aggiornamento
sotto lo slave

/*  slave

    Connect HC12 "RXD" pin to Arduino Digital Pin 4
    Connect HC12 "TXD" pin to Arduino Digital Pin 5
    Connect HC12 "Set" pin to Arduino Digital Pin 6

    Do not power over USB.  Per datasheet,
    power HC12 with a supply of at least 100 mA with
    a 22 uF - 1000 uF reservoir capacitor.
    Upload code to two Arduinos connected to two computers.

    Transceivers must be at least several meters apart to work.
    TX slave
*/
//librerie
//htu21d
#include <Wire.h>
#include "Adafruit_HTU21DF.h"

// Connect Vin to 3-5VDC
// Connect GND to ground
// Connect SCL to I2C clock pin (A5 on UNO)
// Connect SDA to I2C data pin (A4 on UNO)

Adafruit_HTU21DF htu = Adafruit_HTU21DF();

#include <SoftwareSerial.h>

float t;
float rh;

char START;// carattere di start trasmissione
char END;// carattere di end trasmissione
char sensorNum;//codice della stazione
char rx;//variabile di appoggio


const byte HC12RxdPin = 2;  //HC12 "RXD" Pin on HC12
const byte HC12TxdPin = 3;  //HC12 "TXD" Pin on HC12
const byte HC12SetPin = 6;  //HC12 "SET" Pin on HC12

SoftwareSerial Radio_HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

char readBuffer[4] = "";
char data[27] = "";

char dataT[8] = "";
char dataRH[8] = "";

char count_[2] = "";

int count;
byte i, j, k;//contatori

void setup()
{
  Serial.begin(9600);                       // Open serial port to computer

  t = 0.0;//inizializzo variabili sensore
  rh = 0.0;//inizializzo variabili sensore

  count = 0;

  if (!htu.begin())
  {
    Serial.println("HTU21D Couldn't find sensor!");
    while (1);
  }
  else
  {
    Serial.println("HTU21D ready");
  }

  //sezione HC12
  Radio_HC12.begin(9600);// Open serial port to HC12

  Serial.println("HC12 ready:");

  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);

  i = 0;//indice vettore
  j = 0;//indice vettore

  START = '#';// carattere di start trasmissione
  END = '>';// carattere di end trasmissione
  sensorNum = '2';//codice della stazione
  
  delay(2000);
}

void loop()
{
  while (Radio_HC12.available())
  {
    rx = Radio_HC12.read();

    if (rx == START)
    {
      readBuffer[0] = rx;
    }

    if (rx == sensorNum)
    {
      readBuffer[1] = rx;
    }
    if (rx == END)
    {
      readBuffer[2] = rx;
    }
  }

  if (readBuffer[0] == START && readBuffer[1] == sensorNum && readBuffer[2] == END)
  {

    readBuffer[0] = "";
    readBuffer[1] = "";
    readBuffer[2] = "";
    readBuffer[3] = "";

    //    byte j = count++;
    //
    //    count_[0] = j;
    //    count_[1] = '\0';
    //    Serial.println(i);
    //    Serial.println(char(count_[0]));
    //    //  Serial.println(count_[1]);
    //
    //    if (count >= 100)
    //    {
    //      count = 1;
    //    }

    t = htu.readTemperature();
    rh = htu.readHumidity();

    /*
        Serial.println(t);
        Serial.println(rh);
    */

    dtostrf(t, 7, 2, dataT);

    //    Serial.print("sizeof(dataT) ");
    //    Serial.println(sizeof(dataT));

    /*    i = 0;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataT[i]);

        i = 0;

        Serial.println();
    */

    dtostrf(rh, 7, 2, dataRH);

    //    Serial.print("sizeof(dataRH) ");
    //    Serial.println(sizeof(dataRH));

    /*
        i = 0;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i++;
        Serial.print(i);
        Serial.print('\t');
        Serial.println(dataRH[i]);

        i = 0;
    */
    //check if returns are valid, if they are NaN (not a number) then something went wrong!

    if (!htu.begin())
    {
      Serial.println("Couldn't find sensor!");
      while (1);
    }
    else
    {
      i = 0;
      data[i] = START;
      i++;
      data[i] = sensorNum;
      i++;
      data[i] = ',';
      i++;
      data[i] = 'C';//contatore
      i++;
      data[i] = ',';

      for (k = 0; k < 7; k++)
      {
        i++;
        data[i] = dataT[k];
      }

      i++;
      data[i] = ',';
      i++;
      data[i] = 'C';//temperatura
      i++;
      data[i] = ',';

      for (k = 0; k < 7; k++)
      {
        i++;
        data[i] = dataRH[k];
      }

      i++;
      data[i] = ',';
      i++;
      data[i] = '%';//umidita
      i++;
      data[i] = ',';
      i++;
      data[i] = END;

      Radio_HC12.println(data);
  
        Serial.println("sending DATA to HC12 ");

      Serial.print(dataT);
      Serial.print(dataRH);
      Serial.println();
    }
  }
}




//void sendData(float h)
//{

//  HC12.write(h);
//  HC12.print(" | ");
//  HC12.print('\n');
//
//  ////sends the angle value with start marker "s" and end marker "e"
//  //  HC12.print("s" + angleString + "e");
//}

il master

//master
//from termometri distribuiti >> unità centrale memorizza

// libreries
// per le radio
#include <SoftwareSerial.h>
const byte HC12RxdPin = 2;                      // "RXD" Pin on HC12
const byte HC12TxdPin = 3;                      // "TXD" Pin on HC12
const byte HC12SetPin = 6;                      // "SET" Pin on HC12
SoftwareSerial Radio_HC12(HC12TxdPin, HC12RxdPin); // RX nano to HC-12 TX Pin, TX nano to HC-12 RX Pin

#define START '#'// carattere di start trasmissione
#define END '>'// carattere di end trasmissione
char rx;
byte index;
char stringa[25];

const byte MAXRX = 15;


//per la parte orologio
#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

//Scheda SD
#include <SPI.h>
#include <SD.h>
byte chipSDSelect;
File dataFile;

char logfile; // contenitore per nome file di log

byte sensorNumTot;
char id_sensor[8];//vettore codice stazione aggiungere le stazioni se serve

byte i, j;//contatori

//sezione delay con millis()
unsigned long previousMillis;        // will store last time LED was updated
unsigned long currentMillis;
long interval;


void setup()
{
  Serial.begin(9600);                       // Open serial port to computer
  Wire.begin();

  Radio_HC12.begin(9600);                         // Open serial port to HC12
  pinMode(HC12SetPin, OUTPUT);
  digitalWrite(HC12SetPin, HIGH);
  Serial.println("HC12 ready:");

  chipSDSelect = 4;
  pinMode(chipSDSelect, OUTPUT);
  Serial.println("Initializing SD card...");

  if (!SD.begin(chipSDSelect))// see if the card is present and can be initialized:
  {
    Serial.println("Card failed, or not present");// don't do anything more
    while (1);
  }
  Serial.println("SD card initialized.");

  i = 0;

  logfile = "datalog.txt"; // contenitore per nome file di log

  sensorNumTot = 5;

  id_sensor[0] = START; //carattere inizio trasmissione
  id_sensor[1] = '1'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[2] = '2'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[3] = '3'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[4] = '4'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[5] = '5'; //aggiungere le stazioni se serve e aggiornare indice vettore
  id_sensor[6] = END; //caratte fine trasmissione


  Serial.println(id_sensor);

  interval = 800;//intervallo delle interrogazioni delle stazioni

  previousMillis = 0;

  rx = "";
  index = 0;
  stringa[25] = "";

  delay(1000);

}

void loop()
{
  currentMillis = millis();

  if (currentMillis - previousMillis >= interval)
  {
    i++;
    previousMillis = currentMillis;// save the last time

    Radio_HC12.print(id_sensor[0]);// carattere di start trasmissione
    Radio_HC12.print(id_sensor[i]);//codice stazione TU
    Radio_HC12.println(id_sensor[6]);// carattere di end trasmissione

    Serial.print(id_sensor[0]);// carattere di start trasmissione
    Serial.print(id_sensor[i]);//codice stazione TU
    Serial.println(id_sensor[6]);// carattere di end trasmissione

    if (i == sensorNumTot)
    {
      i = 0;
    }
  }

  if (Radio_HC12.available())
  {
    rx = Radio_HC12.read(); // sono sicuro che esista un carattere dal leggere, altrimenti non sarebbe stata chiamata

Serial.print(rx);

    //
    //    if (rx != '\0')
    //    {
    //      stringa[j] = rx;
    //      Serial.print(stringa[j];
    //      j++;
    //    }


    //    if (rx == START)
    //    {
    //      index = 1;
    //      stringa[0] = rx;
    //      //return;
    //      // sempre un carattere trattato, fuori dalla funzione
    //      Serial.print("ricevuto carattere START");
    //    }
    //
    //    if (index > 0 && index < MAXRX)
    //    {
    //      stringa[index++] = rx;// se abbiamo sentito un carattere di start e non abbiamo indice fuori range
    //      // la radioricevi riceve e tratta i dati dalle radio
    //      //  Radioricevi();
    //      Serial.print("scrivo stringa");
    //      Serial.print(index);
    //      Serial.print(stringa);
    //    }
    //

    if (rx == END)
    {
      Serial.println();
      Serial.print("fine trasmissione");
      rx = "";
    }
  }

}


/*void Radioricevi(void)
  {
  // riceve e tratta i dati dalla radio
  static char stringa[MAXRX]; // il buffer di appoggio della trasmissione
  static byte index = 0;
  char rx = Radio_HC12.read(); // sono sicuro che esista un carattere dal leggere, altrimenti non sarebbe stata chiamata

  if (rx == START)
  {
    index = 1;
    stringa[0] = rx;
    return;
    // sempre un carattere trattato, fuori dalla funzione
  }

  if (index > 0 && index < MAXRX)
  {
    // se abbiamo sentito un carattere di start
    // e non abbiamo indice fuori range
    stringa[index++] = rx;

    return;
  }
  }
*/


/*void scrivi(char logfile[], char indirizzo, char stringa[])
  {
  // scrive su un file la stringa
  // Data, ora, indirizzo, valori di temperatura e umidita'
  File datafile;
  datafile = SD.open(logfile, FILE_WRITE);

  if (datafile)
  {
    // ok file aperto
    datafile.print(year());

    datafile.print('/');

    if (month() < 10)
    {
      datafile.print('0');
    }

    datafile.print(month());

    datafile.print('/');

    if (day() < 10)
    {
      datafile.print('0');
    }

    datafile.print(day());

    datafile.print(',');

    if (hour() < 10)//scrive ora
    {
      datafile.print('0');
    }

    datafile.print(hour());

    datafile.print(':');

    if (minute() < 10)//scrive minuti
    {
      datafile.print('0');
    }
    datafile.print(minute());

    datafile.print(':');

    if (second() < 10)//scrive secondi
    {
      datafile.print('0');
    }

    datafile.print(second());

    datafile.print(',');//separatore campi

    datafile.print(indirizzo);
    datafile.print(',');
    datafile.println(stringa);
    datafile.close();
  }
  else
  {
    Serial.println(F("Errore apertura file di log"));
  }
  }*/

//void print2digits(int number)
//{
//  if (number >= 0 && number < 10)
//  {
//    // Serial.write('0');
//    Time += '0';
//  }
//  // Serial.print(number);
//}

l output sul master


#5>
#1>
#2>
#2,C,  17.33,C,  57.36,%,>
fine trasmissione
#3>
#4>
#5>
#1>
#2>
#2,C,  17.33,C,  57.35,%,>
fine trasmissione
#3>
#4>
#5>
#1>
#2>
#2,C,  17.31,C,  57.39,%,>
fine trasmissione
#3>
#4>
#5>
#1>
#2>
#2,C,  17.32,C,  57.41,%,>
fine trasmissione
#3>
#4>
#5>
#1>
#2>
#2,C,  17.32,C,  57.42,%,>
fine trasmissione
#3>
#4>
#5>

credo di avere problemi, sulla com seriale, il serial monitor non scrive niente

Per azzerare readBuffer la sintassi che usi non è corretta, cioè usare "" al posto di 0.

Per creare il buffer usa:

char readBuffer[7] = { 0 }; 

Questo crea readBuffer composto da 7 elementi numerati da 0÷6 tutti inizializzati con il valore 0.
Attenzione 0 (zero) qui è proprio il numero 0 e non il codice ascii di '0'.

Per azzerare il buffer invece usa memset così ad esempio:

memset(readBuffer, 0, 7);

Altra cosa riguardo alle interrogazioni ... aspe che leggo il master cosa fa. Ok per essere contorto è contorto, serve semplificare ad esempio perche non limitarsi ad interrogare un solo slave per volta e poi aggiungerne un'altro e così via.

Sarebbe anche il caso riassumessi il protocollo che intendi usare per comunicare. Io per adesso dal codice vedo che il master inizia con # e termina con >, stessa cosa per gli slave i quali sono anche essi in ascolto sia quando ricevono dal master che quando è uno degli slave a trasmette. Detto in altri termini quando ad esempio lo slave 1 trasmette # nello slave 2 questa porzione di codice viene eseguita:

rx = Radio_HC12.read();

    if (rx == START)
    {
      readBuffer[0] = rx;
    }

Stessa cosa accade con >
Sono un poco confuso, ma vediamo se dallo slave 1 spedisco # poi altri caratteri poi casualmente nei dati c'è 2 altri dati e per finire > cosa impedisce allo slave 2 di sentirsi interrogato?

Ciao.

Temo nulla. Il protocollo di trasmissione è bello approssimato...
Anche le tempistiche e anche la distinzione tra caratteri, stringhe, array di caratteri, cifre (intese come caratteri o stringhe) o numeri
Ma anche la presenza di tanto codice commentato o doppio mette confusione