void LogTemps(){
if (!file.open(root, filename, O_CREAT | O_APPEND | O_WRITE)) {
//error(“open”);
}
// write values to the file
sensorsa.requestTemperatures();
sensorsb.requestTemperatures();
sensorsc.requestTemperatures();
sensorsd.requestTemperatures();
file.print(now() );
file.print("|");
file.print(sensorsa.getTempCByIndex(0));
file.print("|");
file.print(sensorsb.getTempCByIndex(0));
file.print("|");
file.print(sensorsc.getTempCByIndex(0));
file.print("|");
file.print(sensorsd.getTempCByIndex(0));
file.print("\n");
if (!file.close() || file.writeError){
// error(“close/write”);
}
}
void DS18B20_sample(){
#ifdef DEBUG_DS18B20_POLLER
DEBUG_1("Starting");
#endif
#ifdef DEBUG_DS18B20_POLLER
DEBUG_5("Requesting Temperatures");
#endif
char buf[25];
ds_sensors.requestTemperatures();
for (int i=0; i < ds_count; i++){
#ifdef DEBUG_DS18B20_POLLER
DEBUG_5("Logging DSB Pin");
#endif
sprintf(buf, "DS18B20.%d", i);
logMessage(buf, ds_sensors.getTempCByIndex(i), "Degrees/C");
#ifdef DEBUG_DS18B20_POLLER
DEBUG_5("Logged DSB Pin");
#endif
}
#ifdef DEBUG_DS18B20_POLLER
DEBUG_2("Requested Temperatures");
#endif
#ifdef DEBUG_DS18B20_POLLER
DEBUG_1("Finished");
#endif
}
float MXS1101::getTempC()
{
oneWire.reset();
_MXS1101.begin();
_MXS1101.requestTemperatures();
return _MXS1101.getTempCByIndex(0);
}
void temperatureJob() {
float gotTemp = 0;
Serial << "the device count is " << deviceCount << endl;
sensor.requestTemperatures(); // get all the tempratures first to speed up, moved up from getTemp()
for (int i =0; i < deviceCount; i++ ) {
gotTemp = sensor.getTempF(*deviceAddressArray[i]);
if (gotTemp < -195 ) continue;
Serial << "gotTemp() = " << i << " " << gotTemp << endl;
request.body = formatTempToBody(gotTemp, i);
// if (mycounter % PUSHFREQ == 0 && PUSHTOUBIFLAG == 1 ) {
if (mycounter % PUSHFREQ == 0 && PUSHTOUBIFLAG == 1) {
String mypath = String("/api/v1.6/variables/");
mypath.concat(ubivar[i]);
mypath.concat("/values");
Serial << "going to push "<< request.body << " to " << mypath << endl;
request.path = mypath;
http.post(request, response, headers);
if( debug ) Serial << "http body: " << request.body << endl;
Serial << " Did we reboot? I hope not ";
}
if( debug) debugSerial(i);
}
}
/* Temperature Sensor */
long sensorRoofTempdecic(void)
{
long value = 0;
dallas_roof_sen.requestTemperatures();
value = dallas_roof_sen.getTempCByIndex(0);
return value;
}
bool setTemperature(unsigned long iTemp){
//Serial.println("Req temp");
sensors.requestTemperatures(); // Send the command to get temperatures
//Serial.println("Requested");
float tempr = sensors.getTempCByIndex(0);
//Serial.println("Temp res");
//displayData("Temp res");
char buffer[256];
displayData(itoa(tempr, buffer, 10));
displayData(",");
displayData(itoa(iTemp, buffer, 10));
displayData(",");
//Serial.println("params");
// Serial.println("thi:" + iTenHighMax);
// Serial.println("tlo:" + iTenLowMax);
if ((tempr <= iTemp) && (iTenHigh < iTenHighMax)){
digitalWrite(TEN_WIRE, HIGH);
displayData("H");
iTenHigh++;
iTenLow = 0;
}else{
digitalWrite(TEN_WIRE, LOW);
displayData("L");
iTenLow++;
if(iTenLow >= iTenLowMax)
iTenHigh = 0;
}
displayData("\r\n");
return (tempr >= (iTemp - 1)) and (tempr <= (iTemp + 10));
}
void setup() {
// Init display
mySerial.begin(9600); // set up serial port for 9600 baud
delay(500); // wait for display to boot up
// Setup DS1820 temp sensor
sensors.begin();
sensors.setResolution(Sensor1, 11);
sensors.setResolution(Sensor2, 11);
sensors.setWaitForConversion(false);
sensors.requestTemperatures();
delayInMillis = 750 / (1 << (12 - 11)); //750 for 12bit, 400 for 11bit, 220 for 10bit, 100 for 9bit
// calc by delayInMillis = 750 / (1 << (12 - resolution));
lastTempRequest = millis();
// Set next state i FSM
menu_FSM = M_PAGE1;
menu_last_state = M_PAGE1;
system_FSM = S_IDLE;
// **************** Set up display *******************
DisplayClear();
MenuShowTime = millis();
// **************** Set up RTC ***********************
Wire.begin();
rtc.begin();
//TimeDate(rtc.now(),dateTimeString,1);
//DateTime now = rtc.now();
// write on display
DisplayGoto(2,0);
mySerial.print("Version 0.9B");
// **************** Set up SD card *******************
pinMode(10, OUTPUT);
DisplayGoto(1,0);
mySerial.write("Init SD -> "); // clear display + legends
DisplayGoto(1,11);
// see if the card is present and can be initialized:
if (!SD.begin())
mySerial.write("Fail");
else
mySerial.write("OK");
delay(2000);
// ***************** Clear display ********************
DisplayClear();
}
void readTempHumid()
{
temperatureSensor.requestTemperatures();
double tempCelcius = temperatureSensor.getTempCByIndex(0);
String toDrawTemp = doubleToString(tempCelcius, 2);
double humidityVoltage = (double) analogRead(5) / 1024 * REFERENCE_VOLTAGE;
double humidityPercentage = (humidityVoltage / REFERENCE_VOLTAGE - 0.16) / 0.0062;
double relativeHumidity = humidityPercentage / (1.0546 - 0.00216 * tempCelcius);
if(relativeHumidity > 100)
relativeHumidity = 100;
else if(relativeHumidity < 0)
relativeHumidity = 0;
String toDrawHumid = doubleToString(relativeHumidity, 2);
if(deviceStatus == TEMP_VIEW)
{
LCD.rectangle(81, 0, 320, 240, BLACK);
LCD.tText(7, 6, WHITE, "Temp(C): " + toDrawTemp + "C");
LCD.tText(7, 7, WHITE, "RH%: " + toDrawHumid + "%");
}
if(writeToSD)
{
String toWrite = toDrawTemp + "\t" + toDrawHumid + "\n";
LCD.appendString2File("Data", toWrite);
}
}
void doTout() {
String vStr;
memset(tmpChr,0,sizeof(tmpChr));
if (hasTpwr>0) {
digitalWrite(hasTpwr, HIGH); // ow on
delay(5); // wait for powerup
}
ds18b20.requestTemperatures();
byte retry = 20;
float temp=0.0;
do {
temp = ds18b20.getTempCByIndex(0);
retry--;
delay(2);
} while (retry > 0 && (temp == 85.0 || temp == (-127.0)));
if (hasTpwr>0) {
digitalWrite(hasTpwr, LOW); // ow off
}
vStr = String("temp=") + String(temp,3);
vStr.toCharArray(tmpChr, vStr.length()+1);
}
void loop(void)
{
delay(2000);
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
Serial.print("Requesting temperatures...");
sensors.requestTemperatures(); // Send the command to get temperatures
Serial.println("DONE");
// Loop through each device, print out temperature data
for(int i=0;i<numberOfDevices; i++)
{
// Search the wire for address
if(sensors.getAddress(tempDeviceAddress, i))
{
// Output the device ID
Serial.print("Temperature for device: ");
Serial.println(i,DEC);
// It responds almost immediately. Let's print out the data
printTemperature(tempDeviceAddress); // Use a simple function to print out the data
}
//else ghost device! Check your power requirements and cabling
}
}
/**
* \brief Prints all connected OneWire sensors with there index
and current temperature value.
*/
void tempSensorsPrintInfo(void){
uint8_t address[8];
float temp;
uint8_t deviceCount=sensors.getDeviceCount();
Serial.print("Found devices: ");
Serial.println(deviceCount);
Serial.println(" ");
sensors.requestTemperatures();
for(int i=0; i<deviceCount; i++){
Serial.print("Device: ");
Serial.println(i);
if(sensors.getAddress(address, i)){
temp=sensors.getTempC(address);
Serial.print("Temp: ");
Serial.print(temp);
Serial.println(" ");
//delay(100);
Serial.print("Resolution: ");
Serial.println(sensors.getResolution(address));
Serial.println("");
//delay(100);
}
}
}
void setup()
{
pinMode(13, OUTPUT);
// Set up all of the Digital IO pins.
pinMode(pin_leftCutterCheck,INPUT);
pinMode(pin_rightCutterCheck,INPUT);
pinMode(pin_leftCutterControl,OUTPUT);
pinMode(pin_rightCutterControl,OUTPUT);
// Turn off the cutters by default
digitalWrite(pin_leftCutterControl,LOW);
digitalWrite(pin_rightCutterControl,LOW);
// Initialize the rear panel LED outputs
pinMode(pin_ledHigh,OUTPUT);
pinMode(pin_ledMid,OUTPUT);
pinMode(pin_ledLow,OUTPUT);
digitalWrite(pin_ledHigh, LOW);
digitalWrite(pin_ledMid, LOW);
digitalWrite(pin_ledLow, LOW);
temperatureTop.begin();
temperatureBot.begin();
// Make sure we have temperature sensors, if not, set to something
// unreasonable. This would be 0 in Alabama.
if(!temperatureTop.getAddress(topAddress,0))
{
msgStatus.temperature_1 = 0.0;
} else {
temperatureTop.setResolution(topAddress,9);
temperatureTop.setWaitForConversion(false);
temperatureTop.requestTemperatures();
}
if(!temperatureBot.getAddress(botAddress,0))
{
msgStatus.temperature_2 = 0.0;
} else {
temperatureBot.setResolution(botAddress,9);
temperatureBot.setWaitForConversion(false);
temperatureBot.requestTemperatures();
}
nh.initNode();
nh.advertise(status_pub);
nh.advertiseService(cutter_srv);
}
double Sensor::getDS18B20Reading()
{
OneWire oneWire(index);
DallasTemperature sensor = DallasTemperature(&oneWire);
sensor.setResolution(12);
sensor.begin();
sensor.requestTemperatures();
return sensor.getTempCByIndex(0);
}
void readData()
{
Serial.print("Requesting temperatures...");
sensors.requestTemperatures(); // Send the command to get temperatures
Serial.println("DONE");
temp = sensors.getTempCByIndex(0);
Serial.print("Temperature for Device 1 is: ");
Serial.print(temp); // Why "byIndex"? You can have more than one IC on the same bus. 0 refers to the first IC on the wire
}
void updateTemperature()
{
sensor.requestTemperatures();
tempInCelsius = (int) (sensor.getTempC(devAddr)*10);
digitValues[0] = tempInCelsius / 100;
digitValues[1] = (tempInCelsius % 100) / 10;
digitValues[2] = tempInCelsius % 10;
for (int i = 0; i < N-1; i++)
display.writeDigit(i, digitValues[i]);
}
void loop(void)
{
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
Serial.print("Requesting temperatures...");
sensors.requestTemperatures(); // Send the command to get temperatures
Serial.println("DONE");
// It responds almost immediately. Let's print out the data
printTemperature(insideThermometer); // Use a simple function to print out the data
delay(1000);
}
/**
* \brief Reads all connected temperature sensors.
*
* Table: DS18B20 Conversion Times and Resolution Settings
* Resolution 9 bit 10 bit 11 bit 12 bit
* Conversion Time (ms) 93.75 187.5 375 750
* LSB (°C) 0.5 0.25 0.125 0.0625
* See also: http://www.maximintegrated.com/en/app-notes/index.mvp/id/4377
*/
error_t tempSensorRead(void){
sensors.requestTemperatures();
for(int i=0; i<tempSensorTable.size; i++){
if(sensors.isConnected(tempSensorTable.tableEntry[i].address)){
tempSensorTable.tableEntry[i].sensorValue=sensors.getTempC(tempSensorTable.tableEntry[i].address);
}
else{
tempSensorTable.tableEntry[i].sensorValue=999;
}
}
return ERR_NO_ERR;
}
void getSoilTemp()
{
// get temp from DS18B20
sensors.requestTemperatures();
update18B20Temp(inSoilThermometer, InTempC);
// Every so often there is an error that throws a -127.00, this compensates
if(InTempC < -100) {
soiltempf = soiltempf; // push last value so data isn't out of scope
}
else {
soiltempf = (InTempC * 9)/5 + 32; // else grab the newest, good data
}
}
float Thermometer::readTemperatureF() {
float tempC = (float)DEVICE_DISCONNECTED;
this->lastReadingError = true;
sensors.requestTemperatures();
tempC = sensors.getTempC(thermometerAddress);
if (tempC == (float)DEVICE_DISCONNECTED) {
this->lastReadingError = true;
} else {
this->lastReadingError = false;
}
return DallasTemperature::toFahrenheit(tempC);
}
int sensors_temperature(){
// call temp_sensor.requestTemperatures() to issue a global temperature request to all devices on the bus
temp_sensor.requestTemperatures(); // Send the command to get temperatures
// call temp_sensor.getTempC to read temperature in degrees Celsius from the device
int temperature =(int) temp_sensor.getTempC(insideThermometer);
#ifdef DEBUG_SENS
softdebug.println();
softdebug.print("Temp C: ");
softdebug.println(temperature);
#endif
return temperature;
}
void temperatureJob() {
sensor.requestTemperatures(); // get all the tempratures first to speed up, moved up from getTemp()
for (int i =0; i < deviceCount; i++ ) {
request.body = getTemp(i);
if (mycounter % PUSHFREQ == 0 && pushtoubiflag == true ) {
String mypath = String("/api/v1.6/variables/");
mypath.concat(ubivar[i]);
mypath.concat("/values");
request.path = mypath;
http.post(request, response, headers);
if( debug ) Serial << "http response: " << request.body << endl;
}
if( debug) debugSerial(i);
//delay(200); //seems like there is a natrual delay of about 150 ms
}
}
void setup()
{
fsmState = EDIT_TIME_MODE;
// initialize thermometer
sensor.begin();
sensor.setWaitForConversion(true);
sensor.getAddress(devAddr, 0);
sensor.requestTemperatures();
tempInCelsius = (int) (sensor.getTempC(devAddr)*10);
// initialize buttons
buttonA.setClickTicks(250);
buttonA.setPressTicks(600);
buttonA.attachLongPressStart(longPressA);
buttonA.attachClick(singleClickA);
buttonA.attachDoubleClick(doubleClickA);
buttonB.setClickTicks(250);
buttonB.setPressTicks(600);
buttonB.attachClick(singleClickB);
buttonB.attachDoubleClick(doubleClickB);
buttonB.attachLongPressStart(longPressB);
// initialize serial
Serial.begin(115200);
// initialize rtc
setSyncProvider(RTC.get);
setSyncInterval(1);
if(timeStatus()!= timeSet)
{
Serial.println("Unable to sync with the RTC");
fsmState = ERROR_MODE;
} else
{
Serial.println("RTC has set the system time");
}
// default alarm settings, 08:30, disabled
pinMode(ALARM_PIN, INPUT_PULLUP);
}
void loop()
{
// keep DHCP refreshed
static int count=10;
while( count <= 0 ) // keep trying DHCP
{
if ( dhcpInit() )
{
count = 10 ; // refresh DHCP every 50 minutes
}
}
count--;
sensors.requestTemperatures(); // Send the command to get temperatures
sendData();
//delay( ( 5l * 60l * 1000l) - 11000l ); // wait 5 minutes
delay( ( 60l * 1000l) - 11000l ); // wait 5 minutes
//delay( ( 15l * 1000l) - 11000l ); // wait 5 minutes
}
void handleMessage(nRFTP::ByteBuffer& bb, uint8_t type, bool isResponse){
#if GATEWAY_NODE == 1
digitalWrite(13, HIGH);
//Serial.write(bb.data, Message::SIZE);
delay(200);
digitalWrite(13, LOW);
#endif
switch (type){
case nRFTP::Message::TYPE_PING:
break;
case Message::TYPE_ROUTE:
break;
case Message::TYPE_SENSORDATA:
{
SensorData sensorData(bb);
if(!isResponse) //This message was request.
{
uint16_t tmp = sensorData.header.srcAddress;
sensorData.header.srcAddress = sensorData.header.destAddress;
sensorData.header.destAddress = tmp;
sensorData.header.setFlag(sensorData.header.FLAG_IS_RESPONSE, 1);
switch(sensorData.sensorType){
case SensorData::TYPE_BATTERY:
{
digitalWrite(BATT_MEASURE_EN, HIGH);
sensorData.sensorData = analogRead(BATTERY_PIN) * 0.01299; // Const = 13.3 / 3.3 = 0.01299;
digitalWrite(BATT_MEASURE_EN, LOW);
break;
}
case SensorData::TYPE_LIGHT:
{
sensorData.sensorData = analogRead(LIGHT_PIN);
break;
}
case SensorData::TYPE_CURRENT:
{
sensorData.sensorData = analogRead(CURRENT_PIN) * 0.03949; //Const = (3.3 * 1000) / (1024*1.6*51) = 0.03949
break;
}
case SensorData::TYPE_TEMPERATURE:
{
sensors.requestTemperatures();
sensorData.sensorData = sensors.getTempCByIndex(0);
break;
}
default:
break;
}
bb.reset();
sensorData.copyToByteBuffer(bb);
delay(20);
transportProtocol.sendMessage(bb, sensorData.header.destAddress);
}
else
{
// This message was response, the payload contains the sensor data and type.
}
break;
}
default:
break;
}
}
void loop() {
File dataFile;
//String dataString;
//char dataToSD[40];
//String timeString;
char tempstring[10]; // create string arrays
//float temp;
static int WaitingForTemp = 0;
//int readCount;
DateTime now; // = rtc.now();
static int nowriting = 0;
delay(1000);
switch(system_FSM) {
case S_IDLE:
//Read time from RTC
now = rtc.now();
if(now.minute() % 11 == 0)
nowriting = 0;
//Trigger state change
if(WaitingForTemp == 1){
if (millis() - lastTempRequest >= delayInMillis) // waited long enough??
system_FSM = S_READ_SENS;
}
if(WaitingForTemp == 0) {
system_FSM = S_TRIG_TEMP;
if(now.minute() % 10 == 0 || nowriting == 0)
system_FSM = S_WRITE_SD;
nowriting = 1;
}
break;
case S_TRIG_TEMP:
// Trig async reading of DS1820 temp sensor
sensors.requestTemperatures();
// remember time of trigger
lastTempRequest = millis();
WaitingForTemp = 1;
system_FSM = S_IDLE;
break;
case S_READ_SENS:
//read value of sensors
SensorData.sensor1 = sensors.getTempC(Sensor1);
SensorData.sensor2 = sensors.getTempC(Sensor2);
//SensorData.sensor1 = sensors.getTempC(Sensor1);
//SensorData.sensor1 = sensors.getTempC(Sensor1);
//SensorData.sensor1 = sensors.getTempC(Sensor1);
WaitingForTemp = 0;
system_FSM = S_IDLE;
/*
if(readCount == 0)
system_FSM = S_WRITE_SD;
else
system_FSM = S_IDLE;
readCount++;
*/
break;
case S_WRITE_SD:
// Read time and date from RTC
TimeDate(rtc.now(),dateTimeString,1);
// Open datafile
dataFile = SD.open("templog.txt", FILE_WRITE);
// Write values to SD card
if (dataFile) {
dataFile.print(dateTimeString);
dataFile.print(";");
dataFile.print(SensorData.sensor1);
dataFile.print(";");
dataFile.println(SensorData.sensor2);
dataFile.close();
}
// state change to IDLE
system_FSM = S_IDLE;
break;
default:
system_FSM = S_IDLE;
}
switch(menu_FSM) {
case M_PAGE1:
if(menu_FSM !=menu_last_state) {
DisplayClear();
mySerial.write("Time"); // clear display + legends
MenuShowTime = millis();
}
now = rtc.now();
DisplayGoto(1,0);
mySerial.write("Time"); // clear display + legends
DisplayGoto(1,8);
TimeDate(now,dateTimeString,2);
mySerial.print(dateTimeString);
DisplayGoto(2,6);
TimeDate(now,dateTimeString,3);
mySerial.print(dateTimeString);
//reserved for showing time and SD card status
menu_last_state = M_PAGE1;
if(millis() - MenuShowTime >= MenuDelayInMillis)
menu_FSM = M_PAGE2;
break;
case M_PAGE2:
if(menu_FSM !=menu_last_state) {
DisplayClear();
mySerial.write("Sens 1: C");
mySerial.write("Sens 2: C");
DisplayGoto(1,14);
mySerial.write(223);
DisplayGoto(2,14);
mySerial.write(223);
MenuShowTime = millis();
}
DisplayGoto(1,10);
mySerial.write(dtostrf(SensorData.sensor1,4,1,tempstring)); // write out the RPM value
DisplayGoto(2,10);
mySerial.write(dtostrf(SensorData.sensor2,4,1,tempstring)); // write out the TEMP value
//mySerial.write(dtostrf(system_FSM,4,1,tempstring)); DEBUG
menu_last_state = M_PAGE2;
if(millis() - MenuShowTime >= MenuDelayInMillis)
menu_FSM = M_PAGE3;
break;
case M_PAGE3:
if(menu_FSM !=menu_last_state) {
DisplayClear();
mySerial.write("Sens 3: N/A C"); // clear display + legends
mySerial.write("Sens 4: N/A C");
DisplayGoto(1,14);
mySerial.write(223);
DisplayGoto(2,14);
mySerial.write(223);
MenuShowTime = millis();
}
DisplayGoto(1,7);
// mySerial.write(dtostrf(SensorData.sensor1,4,1,tempstring)); // write out the RPM value
DisplayGoto(2,7);
//mySerial.write(dtostrf(MenuShowTime,4,1,tempstring)); // write out the TEMP value
menu_last_state = M_PAGE3;
if(millis() - MenuShowTime >= MenuDelayInMillis)
menu_FSM = M_PAGE1;
break;
case M_PAGE4:
break;
default:
menu_FSM = M_PAGE1;
}
}
void loop()
{
Client client = server.available();
if (client) {
// an http request ends with a blank line
boolean current_line_is_blank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
// if we've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so we can send a reply
if (c == '\n' && current_line_is_blank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
// print all the files, use a helper to keep it clean
//ListFiles(client, 0);
client.println("<h2>Temperature:</h2>");
sensorsa.requestTemperatures();
sensorsb.requestTemperatures();
sensorsc.requestTemperatures();
sensorsd.requestTemperatures();
client.println(sensorsa.getTempCByIndex(0));
client.println("<br>");
client.println(sensorsb.getTempCByIndex(1));
client.println("<br>");
client.println(sensorsc.getTempCByIndex(2));
client.println("<br>");
client.println(sensorsd.getTempCByIndex(3));
client.println("<br><br>..");
//ListFiles(client, 0);
break;
}
if (c == '\n') {
// we're starting a new line
current_line_is_blank = true;
}
else if (c != '\r') {
// we've gotten a character on the current line
current_line_is_blank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
client.stop();
}
if(now() > time33mins + (33 * SECS_PER_MIN) )
{
//Serial.println("33 minutes has elapsed");
time33mins = now();
LogTemps();
}
if(now() > time60mins + (60 * SECS_PER_MIN) )
{
//Serial.println("one hour has elapsed");
time60mins = now();
LogTemps();
}
}
uint16_t ds18b20_read_value(uint8_t index)
{
sensors.requestTemperatures();
uint16_t value = ((uint16_t)(sensors.getTempCByIndex(index) * 100) + 5500);
return value;
}
void loop()
{
msgStatus.voltage = (12 * analogRead(pin_voltage) + 4*prev_voltage)/16;
prev_voltage = msgStatus.voltage;
msgStatus.voltage *= 30;
msgStatus.current = (12 * analogRead(pin_current) + 4*prev_current)/16;
prev_current = msgStatus.current;
msgStatus.current = 333*(msgStatus.current - 501);
if(abs(msgStatus.current) <= 1000 )
{
// Current is less than 1 amp in either direction,
// Batteries are (probably?) disconnected.
batteryState = ERROR;
}
else if(msgStatus.voltage < 20000)
{
batteryState = ERROR;
stateOfCharge = 0;
}
else if(msgStatus.current > 0)
{
// If current is positive, we are charging
stateOfCharge = 100;
if (msgStatus.current < 3000)
batteryState = TRICKLE_CHARGING;
else
batteryState = CHARGING;
} else {
// Otherwise, we are discharging.
stateOfCharge = msgStatus.voltage/25 - 900;
if (stateOfCharge > 100)
stateOfCharge = 100;
if (stateOfCharge < 20)
batteryState = DISCHARGING_CRITICAL;
else
batteryState = DISCHARGING;
}
msgStatus.battery_state = batteryState;
msgStatus.charge = stateOfCharge;
updateBatteryDisplay();
msgStatus.temperature_1 = temperatureTop.getTempCByIndex(0);
msgStatus.temperature_2 = temperatureBot.getTempCByIndex(0);
temperatureTop.requestTemperatures();
temperatureBot.requestTemperatures();
msgStatus.cutter_1 = (digitalRead(pin_leftCutterCheck) ? FALSE : TRUE);
msgStatus.cutter_2 = (digitalRead(pin_rightCutterCheck) ? FALSE : TRUE);
if(leftCutterState && !msgStatus.cutter_1)
{
digitalWrite(pin_leftCutterControl, LOW);
leftCutterState = LOW;
msgStatus.cutter_1 = FALSE;
}
if(rightCutterState && !msgStatus.cutter_2)
{
digitalWrite(pin_rightCutterControl, LOW);
rightCutterState = LOW;
msgStatus.cutter_2 = FALSE;
}
status_pub.publish( &msgStatus );
nh.spinOnce();
delay(400);
}
float OpenGardenClass::readSoilTemperature() {
sensors.requestTemperatures(); // Send the command to get temperatures
return sensors.getTempCByIndex(0);
}
void ds18b20() {
DS18B201.requestTemperatures();
DS18B202.requestTemperatures();
DS18B203.requestTemperatures();
DS18B204.requestTemperatures();
int i1 = 0;
int i2 = 0;
int i3 = 0;
int i4 = 0;
temp11 = DS18B201.getTempCByIndex(0);
while ((temp11 == 85) && (i1 < 5))
{
delay (1000);
DS18B201.requestTemperatures();
temp11 = DS18B201.getTempCByIndex(0);
i1++;
}
temp22 = DS18B202.getTempCByIndex(0);
while ((temp22 == 85) && (i2 < 5))
{
delay (1000);
DS18B202.requestTemperatures();
temp22 = DS18B202.getTempCByIndex(0);
i2++;
}
temp33 = DS18B203.getTempCByIndex(0);
while ((temp33 == 85) && (i3 < 5))
{
delay (1000);
DS18B203.requestTemperatures();
temp33 = DS18B203.getTempCByIndex(0);
i3++;
}
temp44 = DS18B204.getTempCByIndex(0);
while ((temp44 == 85) && (i4 < 5))
{
delay (1000);
DS18B204.requestTemperatures();
temp44 = DS18B204.getTempCByIndex(0);
i4++;
}
EEPROM.begin(512);
delay(10);
String temp1k = "";
String temp2k = "";
String temp3k = "";
String temp4k = "";
for (int i = 110; i < 115; i++)
{
temp1k += char(EEPROM.read(i));
}
for (int i = 115; i < 120; i++)
{
temp2k += char(EEPROM.read(i));
}
for (int i = 120; i < 125; i++)
{
temp3k += char(EEPROM.read(i));
}
for (int i = 125; i < 130; i++)
{
temp4k += char(EEPROM.read(i));
}
EEPROM.end();
Serial.println("Kalibrierung T1: " + temp1k);
Serial.println("Kalibrierung T2: " + temp2k);
Serial.println("Kalibrierung T3: " + temp3k);
Serial.println("Kalibrierung T4: " + temp4k);
temp1 = temp11 + temp1k.toInt();
temp2 = temp22 + temp2k.toInt();
temp3 = temp33 + temp3k.toInt();
temp4 = temp44 + temp4k.toInt();
//String tempC = dtostrf(temp, 4, 1, buffer);//handled in sendTemp()
Serial.print(String(sent) + " Temperature_neu1: ");
Serial.println(temp1);
Serial.println("Temperature_neu2: ");
Serial.println(temp2);
Serial.println("Temperature_neu3: ");
Serial.println(temp3);
Serial.println("Temperature_neu4: ");
Serial.println(temp4);
NTP();
}
