Possible issues with Memory usage

My program is on an Arduino Nano, and connects to 3 DHT sensors, a Water sensor to measure rain, and also uses a RealTime clock. It outputs to a 20x4 Serial LCD display, and to an sD card for logging the data. .
My issue seems to be that when reading my DHT11 (first one read), i get a correct reading. But when I try to store it in an array, it is storing a different number. I'm not sure why.

The problem seems to be in my "ReadTemps()" subroutine. (Where I have commented out a lot of DEBUG code to get this to fit in my Nano uP). Right not I am trying to figure out why the value being stored for the Temp from sensor 1 "Temp[0]" gets read as around 22C, but then after sensor 3 is read, the value in Temp[0] is 60.00.... I cant figure out how that is getting changed....

I will try to add code and output results here .... in the method "I think is preferred" on this site...

Compiler Output:

Blockquote

Sketch uses 26872 bytes (87%) of program storage space. Maximum is 30720 bytes.
Global variables use 1476 bytes (72%) of dynamic memory, leaving 572 bytes for local variables. Maximum is 2048 bytes.

Serial Port Output:

Multi Temp/Humidity/Rain Sensor reading
Initializing SD card...SD-card initialized!
	Data Logging

Sensor  Temperatue		Humidity	T-Raw	H-Raw
--------------------
Reading Sensor 1
Next Temp[0]= 23.30ºC  next Humid[0] = 47.00%
--------------------
Cant seem to get this to show the full serial output with the info I need <<<<< HELP IN DOING THAT>>>>>

Program Code:

#define VERSION "11"
/*  Simple_External_Interrupt_RainGauge-Mod9.ino


  Still debugging void ReadTemp()
  8/4 Attempting to save space, change "int" variables to "int8_t" for less space
*/
//===========================[ Included Libraries ]=======================
#include "PinChangeInterrupt.h"       //Use non-standard interrupts for rain and menu inupts
#include <SPI.h>                      //SPI Bus for RTC or LCD???
#include <SD.h>                       //SD Card Read Library
#include <Wire.h>                     //Wire
#include "DHT.h"                      //DHT Humidty/Temp sensorsc


//String  fahSymbol = "ºF";
String readString;
String Blank = "                    ";

//=========================[ DHT sensor related items ]=====================

DHT dht1(5, DHT11);
DHT dht2(4, DHT11);
DHT dht3(3, DHT12);
int8_t Toff1 = 0;   //Offsets to calibrate the sensors and compensate
int8_t Toff2 = 0;   //for each sensor's errors.  May want to move this to
int8_t Toff3 = 0;   //and external file to be read in each time program is run...TBD
int8_t Hoff1 = 0;   //  Stored at 1/100 value.... so +122 is really 1.22
int8_t Hoff2 = 0;
int8_t Hoff3 = 0;
float FAH;
float DHT11_t; float DHT11_h; float DHT21_t; float DHT21_h; float DHT22_t; float DHT22_h;

//=========================[ LCD related items ]=====================

#include <LiquidCrystal_I2C.h>        //Liquid Crystal I2C Serial Display
LiquidCrystal_I2C lcd(0x27, 20, 4); // set the LCD address to 0x27 for a 20 chars and 4 line display

#include <DS1307RTC.h>                //Real Time Clock RTC_DS3231 rtc;
#include <TimeLib.h>
time_t t = now();
tmElements_t tm;
String TimeString;    // = "";

//=========================[ Program Constants ]=====================
float Temp[2]; float Humid[2];    //Store previous reading
const int8_t chipSelect = 10;
int8_t LoopCt;
int8_t loopctr;              //Used to allow LED to turn on briefly when tip bucket changes
const int8_t MaxMenu = 8;
const char *monthName[12] = {
  "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
//PROGMEM const String J  "Temp";
int8_t backlight = 6;                  // the pin the LED is connected to pin 7 (D7)
int8_t ledPin = 13;                    // LED is attached to digital pin 13
const byte RainInterruptPin = 7;    //Mod 3 changed from pin 2 to pin 7
const byte MenuInterruptPin = 8;    //Mod 3 changed from pin 3 to pin 8

//inches of rain per tip of bucet - calculated by measuring bucket volume and surface area of
//    collector/funnel to bucket (16.605 sq.in.)
float conversion_factor = .02858489;


//========================[ Program Variables ]===========================
int8_t x = 0; // variable to be updated by the interrupt

//variables to keep track of the timing of recent interrupts
unsigned long button_time = 0;
unsigned long last_button_time = 0;
unsigned long menu_time = 0;
unsigned long last_menu_time = 0;
unsigned long RainEvent = LOW;

volatile uint8_t Menu_Select;
volatile uint8_t Bucket_Tip_Occurence;
float Bucket_tip_hour_total = 0;
float Bucket_tip_current_hour_total = 0;
float Bucket_tip_previous_hour_total = 0;
float Bucket_tip_current_day_total = 0;
float Bucket_tip_previous_day_total = 0;
uint8_t current_minute;
uint8_t loop_minute;
uint8_t current_hour;
uint8_t loop_hour;
uint8_t current_day;
uint8_t loop_day;
uint8_t tip_counter;
volatile unsigned long backlightOfftime;
// duration (miiliseconds) that backlight remains on after menu select button pushed
volatile unsigned long backlightOnDuration = 30000;

//================= SubroutinePrototypes===================
void countRain(void);
void UpdateDateTime(void);
void OutPutLog(String Indatastring);
void Menu(void);
void setMenu(int a);
void ReadTimeDate(int Versn);
float Convert(int type, float Value, int Sensor);




/*================================[ countRain ]==============================
  Debounces the input from the Tip Water Bucket.  Incremets counter when
  The bucket tips... And sets Flag "Bucket_Ti_Occurence to 1
*/
void countRain() {
  static unsigned long last_interrupt_time_bucket = 0;
  unsigned long interrupt_time_bucket = millis();
  static int RainCt;

  // Serial.print(F("Rain Event: #"));   //This is working debug code
  Serial.println(RainCt++);

  // If interrupts come faster than 300ms, assume it's a bounce and ignore
  if (interrupt_time_bucket - last_interrupt_time_bucket > 300)
  {
    Bucket_Tip_Occurence = 1;
    digitalWrite(9, HIGH);  RainEvent = millis();
  }
  last_interrupt_time_bucket = interrupt_time_bucket;
}// endsub countRain()


/*=============================[TimeOutRainLed(]=========================
    When bucket flips, led will go on for about 1000 milliseconds
    then turn off.  RainEvent is time set when bucket changes.
*/
void TimeOutRainLed() {
  //Serial.print(RainEvent);Serial.print("\t");Serial.println(millis() - RainEvent);
  if ((millis() - RainEvent ) > 1000) {   //1 seconds
    digitalWrite(9, LOW);  //Timeout turn LED off
  }
}


/*=================================[print2digits]=========================
    Takes an Hour, Date, Minute, Second and makes it 2 digits wide
*/
void print2digits(int number) {
  if (number >= 0 && number < 10) {
    TimeString +=  '0';
  }
  TimeString += number;
}//endsub print2digits()


/*===============================[ PrintBlank LCD line ]=====================
    Prints a blank line ie. clears line of the LCD.  Instead of lCD.clear 
    which causes more flickering of the display
*/
void PrintBlank(int row) {
  lcd.setCursor(0, row); lcd.print(Blank);
  /*for (int j = 0; j <= 19; j++) {
    lcd.setCursor(j, row); lcd.print(F(" "));
    }
  */
} //Endsub PrintBlank()


/*===============================[addColon]==============================

*/
void addColon()
{
  Serial.write(':'); lcd.write(':'); TimeString += ':';
}//endsub addColon()

/*==================================[addDash]==========================

*/
void addDash()
{
  Serial.write('/'); lcd.write('/'); TimeString += '/';
}  //endsub addDash

/*==================================[SprintLine]==========================

*/
void SprintLine(){
  for (int j = 0; j <= 19; j++) {
    Serial.print('-');
    }
    Serial.println();
}



/*=============================[ReadTimeDate]==========================
  Called from within main loop() . Gets the Date and time from Real time Clock
  and puts it in a readable format into the String TimeString.
*/
void ReadTimeDate(int Versn) {

  if (RTC.read(tm)) {
    TimeString = "";
    current_minute = tm.Minute;
    loop_minute = tm.Minute;
    current_hour = tm.Hour;
    loop_hour = tm.Hour;
    current_day = tm.Day;
    loop_day = tm.Day;

    //  Serial.print(F("\nRTC Read: Time = "));
    //Time
    print2digits(tm.Hour); TimeString += ':';   //Adds Hour in 2 digit format to TimeString
    print2digits(tm.Minute); TimeString += ':'; //Adds Minutes in 2 digit format to TimeString
    print2digits(tm.Second); TimeString += "  "; //Adds Seconds in 2 digit format to TimeString

    //Date
    print2digits(tm.Month); TimeString += '/';
    print2digits(tm.Day); TimeString += '/';
    TimeString += tmYearToCalendar(tm.Year);

    if (Versn == 0) {
      lcd.setCursor(9, 1);
      lcd.print(F("Rain Gauge"));
      lcd.setCursor(9, 2); lcd.print(F("Version: ")); lcd.print(10);
    }

    ///    Serial.print(TimeString);
    //    Serial.println();

  } else {
    if (Versn == 0) {
      lcd.clear();
      lcd.setCursor (0, 2); lcd.print(F("MilliSeconds: "));
      //lcd.print();
      lcd.print(millis());
      lcd.setCursor(1, 1);
      lcd.print(F("RTC Error ")); lcd.print(now());
    }//end Versn
    /*
       if (RTC.chipPresent()) {
         Serial.println(F("The DS1307 is stopped.  Please run the SetTime"));
         Serial.println(F("example to initialize the time and begin running.\n"));
       } else {
         Serial.println(F("DS1307 read error!  Please check the circuitry.\n"));
       }  //Endif RTC.chipPresent
      \*/
  } //Endif RTC.Tm

} //Endusb


/*=============================[ UpdatedateTime]=====================
*/
/*void UpdateDateTime() {
  //tmElements_t tm;
  time_t t = now();

  if (RTC.read(tm)) {
    current_minute = tm.Minute;
    loop_minute = tm.Minute;
    current_hour = tm.Hour;
    loop_hour = tm.Hour;
    current_day = tm.Day;
    loop_day = tm.Day;

    //lcd.setCursor (0, 0);
    //lcd.print();
    lcd.setCursor(9, 1);
    lcd.print(F("Rain Gauge"));
  } else {
    // PauseForInput(3);
    lcd.clear();
    lcd.setCursor (0, 2); lcd.print(F("MilliSeconds: "));
    //lcd.print();
    lcd.print(millis());
    lcd.setCursor(1, 1);
    lcd.print(F("RTC Error ")); lcd.print(now());
  }//end RTC
  } //endsub UpdateDteTime
*/


/*========================[ OUTPUT LOG]=========================
    Currently only logging Rain Data/
*/
void OutPutLog(String Indatastring) {
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  /*
    File dataFile = SD.open(F("RainGauge.txt"), FILE_WRITE);

    // if the file is available, write to it:
    if (dataFile) {
      dataFile.print(TimeString); dataFile.print("\t");
      dataFile.println(Indatastring);
      dataFile.close();

      // print to the serial port too:
      Serial.print(TimeString); Serial.print("\t");
      Serial.println(Indatastring);
    }  else {    // if the file isn't open, pop up an error:
      Serial.println(F("error opening datalog.txt"));
      lcd.clear(); lcd.setCursor(3, 0);
      lcd.print(F("Error Data Log"));

      //PauseForInput(2);

    }
  */
}//endsub OutPutLog

/*=====================================[]=========================
   Pause program execution to get feedback from the user.
*/
void PauseForInput(int a) {
  delay(300);
  Serial.print(F(">>PAUSED: PRESS KEY<<\t")); Serial.println(a);
  while (Serial.available() == 0) {
  }
  Serial.read();
  Serial.flush();
}

/*===========================[ Menu ]=======================
  Menu Button called when external input changes... and Interrupt:
  Toggle LCD through menu opions, and the default display...
  When user presses the Menu Button (A???).  Debounce it.  And increment
  the menu choice to display next item.
*/
void Menu() {
  static unsigned long last_interrupt_time_menu = 0;
  unsigned long interrupt_time_menu = millis();
  // If interrupts come faster than 300ms, assume it's a bounce and ignore
  if (interrupt_time_menu - last_interrupt_time_menu > 300)
  {
    if (Menu_Select < MaxMenu) {
      Menu_Select++;
    } else {
      Menu_Select = 1;
    }
    Serial.print(F("Menu ")); Serial.println(Menu_Select);//debug

    //<<<<<<<<<<<<<<<<<<<<<< NOT YET TESTED>>>>>>>>>>>>>>>>>>>>>
    if (digitalRead(backlight) == LOW) {
      digitalWrite(backlight, HIGH); //turns on backlight if was previously off
    }

    backlightOfftime = millis() + backlightOnDuration;
    last_interrupt_time_menu = interrupt_time_menu;   //Debouncing input
  }
}

/*===============================[getTime]============================
   Set Date variables based on Time program was started/compiles
*/
bool getTime(const char *str)
{
  int Hour, Min, Sec;
  if (sscanf(str, "%d:%d:%d", &Hour, &Min, &Sec) != 3) return false;
  tm.Hour = Hour;
  tm.Minute = Min;
  tm.Second = Sec;
  return true;
}

/*============================[getDate]================================
   Set Date variables based on Date program was started/compiles
*/
bool getDate(const char *str)
{
  char Month[12]; int Day, Year;
  uint8_t monthIndex;
  if (sscanf(str, "%s %d %d", Month, &Day, &Year) != 3) return false;
  for (monthIndex = 0; monthIndex < 12; monthIndex++) {
    if (strcmp(Month, monthName[monthIndex]) == 0) break;
  }
  if (monthIndex >= 12) return false;
  tm.Day = Day;
  tm.Month = monthIndex + 1;
  tm.Year = CalendarYrToTm(Year);
  return true;
}


/*======================[ Sub SETUP ]==========================

*/
void setup() {
  bool parse = false;
  bool config = false;
  pinMode(9, OUTPUT);         //LED showing when tip bucket tips
  digitalWrite(9, HIGH);

  //Get the Date/Time this prog was compiled...
  if (getDate(__DATE__) && getTime(__TIME__)) {
    parse = true;
    if (RTC.write(tm)) {
      config = true;
    }
  }

  //enable interrupt 0 which uses pin D2, 1 which uses Pin D3
  //jump to the increment function on falling edge
  pinMode(ledPin, OUTPUT);
  pinMode(RainInterruptPin, INPUT_PULLUP);

  attachPCINT(digitalPinToPCINT(RainInterruptPin), countRain, FALLING);
  //attachPinChangeInterrupt(RainInterruptPin, countRain, CHANGE);
  //attachInterrupt(digitalPinToInterrupt(RainInterruptPin), countRain, FALLING);
  // attachInterrupt(0, countRain, FALLING);   //not preferred call method

  pinMode(MenuInterruptPin, INPUT_PULLUP);
  attachPCINT(digitalPinToPCINT(MenuInterruptPin), Menu, FALLING);
  //attachPinChangeInterrupt(MenuInterruptPin, Menu, CHANGE);
  //attachInterrupt(digitalPinToInterrupt(MenuInterruptPin), Menu, FALLING);
  //attachInterrupt(1, Menu, FALLING);

  Serial.begin(9600);  //turn on serial communication
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  lcd.init();
  lcd.backlight();
  lcd.begin(20, 4); // Initializes the interface to the LCD screen, and specifies the dimensions (width and height) of the display
  lcd.home();  // Setting Cursor at Home i.e. 0,0
  //rtc.begin(); //initiate use of Real Time Clock variables

  //This has not yet been implemented or tested 7/29/21
  pinMode(10, OUTPUT);
  pinMode(backlight, OUTPUT); // Declare the LED as an output
  digitalWrite(backlight, HIGH); //turn on lcd backlight
  backlightOfftime = millis() + backlightOnDuration;  //set inital time delay for the LCD backlight to be On

  Serial.println(F("Multi Temp/Humidity/Rain Sensor reading"));
  dht1.begin(); dht2.begin(); dht3.begin();   //Initialize temp sensoors

  Serial.print(F("Initializing SD card..."));
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println(F("Card failed, or not present"));
    // don't do anything more:
    lcd.print(F("Card not Detected, Prog END"));
    while (1);   //debug this temp disabled
  }
  Serial.println(F("SD-card initialized!"));
  Serial.println(F("\tData Logging\n"));

  OutPutLog(F("Rain Gauge Ready - unit powered up"));

  lcd.clear();
  PrintBlank(1);
  /*lcd.setCursor(7, 1);
    lcd.print(F("Weatherizer"));
    delay(2000);
  */
  PrintBlank(1);
  Serial.print(F("Sensor  Temperatue\t\tHumidity\tT-Raw\tH-Raw\n"));
  delay(2000);
  //PauseForInput(1);

  Menu_Select = 1;
  digitalWrite(9, LOW); //Bucket Tip Indicator

}  //end Setup


/*=============================[ReadTemps ]===================================
  Create check so does not test temperature quite so often.
*/
void ReadTemps() {
  FAH;
  static float lastTime;
  long NowTime = millis();
  String t = F("DHT11 Temp ");
  String h = F(" Humidity ");
  String ReadingSensor = F("Reading Sensor ");
  String x = F("ºF  ");

  //Serial.print(lastTime); Serial.print("\t"); Serial.print(k); Serial.print("\t"); Serial.println(k - lastTime);
  if ((NowTime - lastTime) <= 1000) {//<<<<<<<<<<<<< not working
    lastTime = NowTime;

  } else {    // Else read the DHT sensor data
    lastTime = NowTime;

    SprintLine(); Serial.print(ReadingSensor); Serial.println(1);
    DHT11_t = dht1.readTemperature();
    DHT11_h = dht1.readHumidity();
    delay(300);
    
    if (isnan(DHT11_t) || isnan(DHT11_h)) {
      Serial.println(F("DHT11 Error"));
    } else {
      //Only print/store the changes if they vary by 1ºC or by 1% from previous read value...
      if ((abs(int(DHT11_t - Temp[0])) > 1) || (abs(int(DHT11_h - Humid[0])) > 1)) {
        /* Serial.print(F("Comp DHT11 Temp= "));
          Serial.print(Convert(0, DHT11_t, 1)); //Convert to �F, and add offset
          Serial.println(x);
          Serial.print(h);
          Serial.print(Convert(1, DHT11_h, 1)); Serial.println("%");
          Serial.print("DHT11_T= "); Serial.print(DHT11_t); Serial.println("�C");
          Serial.print(F("Now Temp[0]=")); Serial.println(Temp[0]);
          Serial.print(F("Diff = ")); Serial.println(abs(int(DHT11_t - Temp[0])));//Campare with previous reading
        */
        Temp[0] = DHT11_t; Humid[0] = DHT11_h;  //Save current reading till next loop

        Serial.print(F("Next Temp[0]= "));
        Serial.print(Temp[0]);
        Serial.print(F("ºC  next Humid[0] = "));
        Serial.print(Humid[0]); Serial.println('%');

        delay(100);
      } else {
        Serial.println("No change");
        //Endif
      }//Endif abs(int(DHT11...
    } //subsud isnan

    TimeOutRainLed();//<<<<<<<<<<<<<<<<<<< Temp[0] changes value somewhere.....

    SprintLine();  Serial.print(ReadingSensor); Serial.println(2);
    DHT21_t = dht2.readTemperature();
    DHT21_h = dht2.readHumidity();
    delay(300);
    
    if (isnan(DHT21_t) || isnan(DHT21_h)) {
      Serial.println(F("DHT21 Error"));
    } else {
      //Only print/store the changes if they vary by 1ºC or by 1% from previous read value...
      if ((abs(int(DHT21_t - Temp[1])) > 1) || (abs(int(DHT11_h - Humid[1])) > 1)) {
        /*  Serial.print(F("Comp DHT21 Temp= "));
          Serial.print(Convert(0, DHT21_t, 2)); //Convert to �F, and add offset
          Serial.println(x);
          Serial.print(h);
          Serial.print(Convert(1, DHT21_h, 2));   //show Humidity with offset
          Serial.println("%");
          Serial.print("DHT21_T= "); Serial.print(DHT21_t); Serial.println("�C");
          Serial.print(F("Now Temp[1]=")); Serial.println(Temp[1]);
          Serial.print(F("Diff = ")); Serial.println(abs(int(DHT21_t - Temp[1])));
        */
        Temp[1] = DHT21_t; Humid[1] = DHT21_h;
        Serial.print(F("Next Temp[1]= "));
        Serial.print(Temp[1]);
        Serial.print(F("ºC  next Humid[1] = "));
        Serial.print(Humid[1]); Serial.println('%');

        Serial.print(">>>>>>  Temp[0] ="); Serial.println(Temp[0]);
        delay(100);
      } else {
        Serial.println("No change");
      }//Endif abs(int(DHT21...
    }

    TimeOutRainLed();
    SprintLine(); Serial.print(ReadingSensor); Serial.println(3);
    DHT22_t = dht3.readTemperature();
    DHT22_h = dht3.readHumidity();
    delay(300);
    
    if (isnan(DHT22_t) || isnan(DHT22_h)) {
      Serial.println(F("DHT22 Error"));
    } else {
      //Only print/store the changes if they vary by 1ºC or by 1% from previous read value...
      if ((abs(int(DHT22_t - Temp[2])) > 1) || (abs(int(DHT22_h - Humid[2])) > 1)) {
        /*Serial.print(F("Comp DHT22 \tTemp= "));
          Serial.print(Convert(0, DHT22_t, 3)); //Convert to �F, and add offset
          Serial.println(x);
          Serial.print(h);
          Serial.print(Convert(1, DHT22_h, 3));
          Serial.println("%");
          Serial.print("DHT22_T= "); Serial.print(DHT22_t); Serial.println("�C");
          Serial.print(F("Now Temp[2]=")); Serial.println(Temp[2]);
          Serial.print(F("Diff = ")); Serial.println(abs(int(DHT22_t - Temp[2])));
        */
        Temp[2] = DHT22_t; Humid[2] = DHT22_h;

        Serial.print(F("\nNext Temp[2]= "));
        Serial.print(Temp[2]);
        Serial.print(F("ºC,  next Humid[2] = "));
        Serial.print(Humid[2]); Serial.println('%');
        Serial.println(F("   <<<< why humidity 10% high>>>> TBD"));
        delay(100);
        Serial.print(F(">>>>>>  How is Temp[0] = Changing here??? to >>")); Serial.println(Temp[0]);

      } else {
        Serial.println("No change");
      }//Endif abs(int(DHT22...
    }

    
    SprintLine();
    Serial.println(F("\t\t>>>>DEBUG Temp[],Humid[] Array Values stored <<<<<"));
    Serial.print(Temp[0]); Serial.print(F("ºC , ")); Serial.print(Humid[0]); Serial.println('%');
    Serial.print(Temp[1]); Serial.print(F("ºC , ")); Serial.print(Humid[1]); Serial.println('%');
    Serial.print(Temp[2]); Serial.print(F("ºC , ")); Serial.print(Humid[2]); Serial.println('%');
    Serial.println();

  }//NonTime - LastTime

}//ensub ReadTemps-----------------------


/*==============================[SprintEqual]=============================

*/
void SprintEqual() {
  for (int j = 0; j <= 80; j++) {
    Serial.print('=');
  }//endfor
  Serial.print('\n');;
}


/*==============================[SprintLine]=============================

void SprintLine() {
  Serial.print('\t');
  for (int j = 0; j <= 60; j++) {
    Serial.print('-');
  }//endfor
  Serial.print('\n');
}



/*======================================[ Convert ]=======================
   Purpose:  Convert Centigrade to Fahrenheit, and add offset value to correct reading errr
   Calling Info:  type 0=Temperature, 1 = Humidity
   Value = Temp in C, or Humidity in %
   Sensor 1=DHT11, 2=DHT21, 3 DHT22
  Offset values are stored AS integers, and are 100* actual value  (I.E. ACTUAL oFFSET = INTEGER/100)
*/
float Convert(int type, float Value, int Sensor) {
  float offset;

  if (type == 0) { //Temperature
    if (Sensor == 1) {
      offset = (Toff1 / 100.0);
    } else if (Sensor == 2) {
      offset = (Toff2 / 100);
    } else if (Sensor == 3) {
      offset = (Toff3 / 100.0);
    }
    return (Value * 1.8 + 31) - offset;
  } else {
    if (Sensor == 1) {
      offset = (Hoff1 / 100.0);
    } else if (Sensor == 2) {
      offset = (Hoff2 / 100);
    } else if (Sensor == 3) {
      offset = (Hoff3 / 100.0);
    }
    return (Value - offset); //Humidity
  }

  TimeOutRainLed();   //This is used often so see if need to turn of this LED
}

/*==============================[ Main Loop ]========================

*/
void loop() {
  tmElements_t tm;
  ReadTimeDate(0);      //UpdateDateTime();  Relaced by ReadTimeDate version 0

  LoopCt++;
  digitalWrite(ledPin, LOW);
  delay(300); //pretend to be doing something useful


  //Begin Loop to determine tally current day totals
  //  i.e. Stay in this loop, till the end of the day...
  while (loop_day - current_day == 0) {

    //Begin Loop to determine tally current hour totals
    //  i.e. stay in this loop, till the end of the hour...
    while (loop_hour - current_hour == 0) {

      ReadTimeDate(2);   //Put Date & Time in TimeString
      TimeOutRainLed();
      lcd.setCursor(0, 3);
      lcd.print(TimeString);
      //PauseForInput(4);

      if (millis() > backlightOfftime) {
        digitalWrite(backlight, LOW);
      }

      if  (Bucket_Tip_Occurence == 1) {

        if (loopctr < 10) {//<<<<<<<<<<<<<<<<<not working
          digitalWrite(9, HIGH);
        } else {
          digitalWrite(10, LOW);
        }
        if (loopctr > 100) {
          loopctr = 0;
        } else {
          loopctr++;
        }
        Bucket_Tip_Occurence = 0;
        tip_counter++;

        if (RTC.read(tm)) {
          File myFile = SD.open("RainGauge.txt", FILE_WRITE);
          Serial.print(F("Event Logged"));
          myFile.print(F("Event "));
          myFile.print(TimeString);
          myFile.print("  ");
          myFile.print(conversion_factor, 5);
          myFile.println();
          myFile.close();
          delay(200);
        }  else {
          Serial.print(F("No Real Time Clock Detected"));
        }//endif RTC

      } else { //Check for current hour status
        RTC.read(tm);
        loop_hour = tm.Hour;

        setMenu(Menu_Select);
      } //endif Bucket_Tip_Occurence

      //Totalize current hour total
      Bucket_tip_previous_hour_total = tip_counter * conversion_factor;

    } // end while loop_hour
    tip_counter = 0;
    if (RTC.read(tm)) {  // Reset counters for next one hour loop
      current_hour = tm.Hour;
      loop_hour = tm.Hour;
    }  else {
      Serial.print(F("No Real Time Clock Detected"));
    }//end RTC.read

    Serial.print(F("\n\tNew Hour Started"));
  } //End While Loop_day
  Serial.print(F("\n\t\tNew Day Started"));

  if (RTC.read(tm)) {  // Reset counters for next day loop
    current_hour = tm.Hour;
    loop_day = tm.Day;
    current_day = tm.Day;
  }  else {
    Serial.print(F("No Real Time Clock Detected"));
  }//end RTC.read

  //Totalize current Day total
  Bucket_tip_current_day_total = Bucket_tip_previous_hour_total + Bucket_tip_current_day_total;

  tip_counter = 0;

  Serial.println(F("End of loop() routine... should never get here..."));
  Serial.println(tip_counter * conversion_factor);
  Serial.println(Bucket_tip_previous_day_total);
  Serial.println(Bucket_tip_current_day_total + tip_counter * conversion_factor);
  Serial.println();
  Serial.print(loop_day); Serial.print(" "); Serial.print(current_day);
  Serial.print(loop_hour); Serial.print(" "); Serial.println(current_hour);
} //End Sub Loop

/*====================================[ setMenu ]===========================
  Allow the user to step through a series of menu's to view the curent 
  sensor readings, and previous readings... More options TBD at this point.
*/
void setMenu(int a) {
  static int oldCtr;
  static int LastMenu;
  ReadTemps();

  if (a != LastMenu) {  //prevents flickering on LCD
    lcd.setCursor(0, 0); lcd.print(Blank);
    lcd.setCursor(0, 0); lcd.print(a); lcd.print('>');
    lcd.setCursor(0, 1); lcd.print(Blank);
  }
  lcd.setCursor(0, 3); lcd.print(TimeString);
  //debug PauseForInput(5);

  lcd.setCursor(0, 0); lcd.print(a);
  switch (a) {
    case 1:
      lcd.print(F("Current Hour"));
      lcd.setCursor(2, 1);
      lcd.print(tip_counter * conversion_factor);
      break;
    case 2:
      lcd.print(F("Previous Hour"));
      lcd.setCursor(2, 1);
      lcd.print(Bucket_tip_previous_hour_total);
      break;
    case 3:
      lcd.print(F("Current Day"));
      lcd.setCursor(2, 1);
      lcd.print(Bucket_tip_current_day_total + tip_counter * conversion_factor);
      break;
    case 4:
      lcd.print(F("Previous Day"));
      lcd.setCursor(2, 1);
      lcd.print(Bucket_tip_previous_day_total);
      break;
    case 5:
      PrintBlank(1);
      lcd.print(F(":Indoor Sensors"));
      lcd.setCursor(2, 1);
      if (DHT11_t == 0) {
        lcd.print(F("Indoor Sensor Bad"));
      } else {
        lcd.print(Convert(0, DHT11_t, 1)); lcd.write(0xDF); lcd.print("F ");
        lcd.print(Convert(1, DHT11_h, 1)); lcd.print('%');
      }
      break;
    case 6:
      PrintBlank(1);
      lcd.print(F(":2nd Ind Sensors"));
      lcd.setCursor(2, 1);
      if (DHT21_t == 0) {
        lcd.print(F(" Sensor #2 Bad"));
      } else {
        lcd.print(Convert(0, DHT21_t, 2)); lcd.write(0xDF); lcd.print("F ");
        lcd.print((Convert(1, DHT21_h, 2))); lcd.print('%');
      }
      break;
    case 7:
      //PrintBlank(1);
      lcd.print(F(":Outdoor Sensors"));
      lcd.setCursor(2, 1);
      if (DHT21_t == 0) {
        lcd.print(F("Outdoor Sensor Bad"));
      } else {
        lcd.print(Convert(0, DHT22_t, 3)); lcd.write(0xDF); lcd.print("F ");
        lcd.print(Convert(1, DHT22_h, 3)); lcd.print('%');
      }
      break;


      
    case 8:
      /*  TEMPORARILY DISABLED FOR DEBUGGING PURPOSES, AND CAUSE RUNING OF OF SPACE ON THE NANO.
       *   
       *   lcd.clear();
        lcd.print(F(":RealTime Clock Set"));
        lcd.setCursor(0, 1); lcd.print(F("Enter Date & Time"));
        lcd.setCursor(1, 2); lcd.print(F("format ..."));
        lcd.setCursor(0, 3); lcd.print(F("MM-DD-YY HH:MN:SS"));
        // Get the info from serial ;port
        Serial.print(F("Enter RTC value in format:  MM-DD-YY_HH:MN:SS"));
        PauseForInput(8);
      */
      /*
        tm.Month = MM;
        tm.Day = DD;
        tm.Year = YY;
        tm.Hour = HH;
        tm.Minute = MN;
        tm.Second = SS;

        // Get the info from serial ;port
        tm.Month = MM;
        tm.Day = DD;
        tm.Year = YY;
      */
      //................................... need more work to manually set time here.....................
      /* Serial.println(">>PRESS KEY<<");
        while (Serial.available() == 0) {
         delay(2);    //Pause here doing nothing
         char c = Serial.read(); //Add each character to the input string
         if (c = ".") {//Command finished process it
           readString += c;
         }
         if (readString.length() > 0) {
           Serial.print("Command Received:"); Serial.println(readString);
           readString = "";
         }
         Serial.flush();
      */
      delay(3000);
      /*lcd.setCursor(2,2);
        lcd.print(F("Into Serial port"));
        PauseForInput()
      */

      // Call to routine to set the Real Time Clock ... TBD
      break;
    case 9:
      lcd.clear();
      lcd.print(F(":View Log File - Not Implemented"));//Probably print log file to serial port???
      lcd.setCursor(2, 1);
      lcd.print(F("T.B.D."));
      break;
    default:
      break;
  }//end switch

  //Only print this if the counter has changed...
  if (oldCtr != tip_counter) {
    Serial.print(F(" Rain Event logged at ")); Serial.print(TimeString);
    Serial.print(' '); Serial.print(tip_counter * conversion_factor);
    Serial.print(F(" \" of rain\n"));
    //Serial.println(F("\tShould Log this now... not yet implemented"));
    PauseForInput(9);
  }

  if ((tip_counter == 0) && (a <= 4)) {//First 4 menus are about Rain
    lcd.setCursor(2, 1); lcd.print(F("  No Rain   "));
  } else {
    //  For first 4 menus' will be showing inches...
    if (a >= 1 && a <= 4) {
      lcd.setCursor(7, 1); lcd.print(F("In"));
    }
  }
  //Update the lcd at the bottom with the date/time
  ReadTimeDate(1);
  LastMenu = a;
  oldCtr = tip_counter;  //Used to only serial print if there is a change..

}//endsub SetMenu()

What's FAH?
Why is a time a float?

Oops

Trying to fix this post. FAH was a left over variable, that I thought I'd deleted. Thanks for noticing that. And I believe the lastTime was to be a long. Again thank you.

Not sure about this oops. Was that value not assigned somewhere?

How can I post the Serial windows printed data properly here??? Seems to get truncted. ( I a bit of a newbie here)

You've assigned something to the third element of a two element array.
Ditto Humid.

Thought elements were #0,#1, #2 So Temp[0] is first, Temp[1] is second, and Temp[2] is third. So in may assignment at the top is should be float Temp[3]; float Humid[3];? That really is a noob mistake... wow thank you

I made that change, and it did solve my initial issue. Can anyone tell me how to post the Serial window results properly here? There is still an issue that its is printing some garbage...

Thanks in advance!!!

Here you define two, two element arrays.
Valid subscripts are zero and one.

I don't use the serial monitor much, but you could try highlighting the stuff to want to copy, and use the the copy control key combination.

Thanks for the help. I was simply getting the index and number of elements mixed up.... Silly mistake on my part. DUH!