I want to use a solar panel that is connected to a arduino uno and have a program grab it and put it on a website.
Questions & Issues
Website: I don't want a log I want to show the Latest data. (it is in PHP)
Solar panel: None
Arduino UNO: Convert voltage to percentage
This is just a simple post.
I want to use a solar panel that is connected to a arduino uno and have a program grab it and put it on a website.
An UNO is not a great choice; it does not have wifi or ethernet connectivity.
If you have the option to use wifi you could consider the NodeMCU or WEMOS mini; or an ESP32 board;
loads of info on thi ssite about Arduino web servers
Here is some ESP32 code that takes in info from a sensor and sends it to a Database through a MQTT Broker, Hopefully you can adapt the code.
part 1
#include <WiFi.h>
#include <PubSubClient.h>
#include "certs.h" // include the connection infor for WiFi and MQTT
#include "sdkconfig.h" // used for log printing
#include "esp_system.h"
#include "freertos/FreeRTOS.h" //freeRTOS items to be used
#include "freertos/task.h"
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"
#include <Adafruit_GFX.h> // Core graphics library
#include <Adafruit_ST7789.h> // Hardware-specific library for ST7789
#include <driver/adc.h>
#include "esp32-hal-ledc.h"
////
Adafruit_BME680 bme( GPIO_NUM_5 ); // use hardware SPI, set GPIO pin to use
//Adafruit_ST7789 tft = Adafruit_ST7789( TFT_CS , TFT_DC , TFT_MOSI , TFT_SCLK , TFT_RST );
Adafruit_ST7789 tft = Adafruit_ST7789( GPIO_NUM_15, GPIO_NUM_0, GPIO_NUM_13, GPIO_NUM_14, GPIO_NUM_22 );
WiFiClient wifiClient; // do the WiFi instantiation thing
PubSubClient MQTTclient( mqtt_server, mqtt_port, wifiClient ); //do the MQTT instantiation thing
////
#define evtDoParticleRead ( 1 << 0 ) // declare an event
#define evtWaitForBME ( 1 << 1 )
#define evtParseMQTT ( 1 << 3 )
EventGroupHandle_t eg; // variable for the event group handle
////
QueueHandle_t xQ_RM0; //remaining moisture level sensor 0
QueueHandle_t xQ_eData; // environmental data to be displayed on the screen
struct stu_eData
{
float Temperature = 0.0f;
float Pressure = 0.0f;
float Humidity = 0.0f;
float IAQ = 0.0f;
float RM0 = 0.0f;
float PM2 = 0.0f;
} x_eData; // environmental data
QueueHandle_t xQ_Message; // payload and topic queue of MQTT payload and topic
struct stu_message
{
char payload [150] = {'\0'};
String topic;
} x_message;
//
const float oGasResistanceBaseLine = 149598.0f;
int mqttOK = 0;
////
esp_timer_handle_t oneshot_timer; //veriable to store the hardware timer handle
////
SemaphoreHandle_t sema_MQTT_KeepAlive;
SemaphoreHandle_t sema_PublishPM;
SemaphoreHandle_t sema_mqttOK;
////
// interrupt service routine for WiFi events put into IRAM
void IRAM_ATTR WiFiEvent(WiFiEvent_t event)
{
switch (event) {
case SYSTEM_EVENT_STA_CONNECTED:
log_i("Connected to WiFi access point");
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
log_i("Disconnected from WiFi access point");
break;
case SYSTEM_EVENT_AP_STADISCONNECTED:
log_i("WiFi client disconnected");
break;
default: break;
}
} // void IRAM_ATTR WiFiEvent(WiFiEvent_t event)
////
void IRAM_ATTR oneshot_timer_callback( void* arg )
{
BaseType_t xHigherPriorityTaskWoken;
xEventGroupSetBitsFromISR( eg, evtDoParticleRead, &xHigherPriorityTaskWoken ); //freeRTOS event trigger made for ISR's
} //void IRAM_ATTR oneshot_timer_callback( void* arg )
////
void IRAM_ATTR mqttCallback(char* topic, byte * payload, unsigned int length)
{
memset( x_message.payload, '\0', 150 ); // clear payload char buffer
x_message.topic = ""; //clear topic string buffer
x_message.topic = topic;
int i = 0;
for ( i; i < length; i++)
{
x_message.payload[i] = ((char)payload[i]);
}
x_message.payload[i] = '\0';
xQueueOverwrite( xQ_Message, (void *) &x_message );// send data
} // void mqttCallback(char* topic, byte* payload, unsigned int length)
////
void setup()
{
x_message.topic.reserve(150);
//
xQ_Message = xQueueCreate( 1, sizeof(stu_message) );
xQ_RM0 = xQueueCreate( 1, sizeof(float) );
xQ_eData = xQueueCreate( 1, sizeof(stu_eData) ); // sends a queue copy of the structure
//
sema_PublishPM = xSemaphoreCreateBinary();
xSemaphoreGive( sema_PublishPM );
sema_mqttOK = xSemaphoreCreateBinary();
xSemaphoreGive( sema_mqttOK );
//
ledcSetup( 4, 12000, 8 ); // ledc: 4 => Group: 0, Channel: 2, Timer: 1, led frequency, resolution bits // blue led
ledcAttachPin( GPIO_NUM_12, 4 ); // gpio number and channel
ledcWrite( 4, 0 ); // write to channel number 4
//
eg = xEventGroupCreate(); // get an event group handle
//
gpio_config_t io_cfg = {}; // initialize the gpio configuration structure
io_cfg.mode = GPIO_MODE_OUTPUT; // set gpio mode
//bit mask of the pins to set
io_cfg.pin_bit_mask = ( (1ULL << GPIO_NUM_4) ); // assign gpio number to be configured
//configure GPIO with the given settings
gpio_config(&io_cfg); // configure the gpio based upon the parameters as set in the configuration structure
gpio_set_level( GPIO_NUM_4, LOW); // set air particle sensor trigger pin to LOW
// set up A:D channels, refer: https://dl.espressif.com/doc/esp-idf/latest/api-reference/peripherals/adc.html
adc1_config_width(ADC_WIDTH_12Bit);
adc1_config_channel_atten(ADC1_CHANNEL_0, ADC_ATTEN_DB_11);// using GPIO 36
//
// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/esp_timer.html?highlight=hardware%20timer High Resoultion Timer API
esp_timer_create_args_t oneshot_timer_args = {}; // initialize High Resoulition Timer (HRT) configuration structure
oneshot_timer_args.callback = &oneshot_timer_callback; // configure for callback, name of callback function
esp_timer_create( &oneshot_timer_args, &oneshot_timer ); // assign configuration to the HRT, receive timer handle
//
xTaskCreatePinnedToCore( fparseMQTT, "fparseMQTT", 7000, NULL, 5, NULL, 1 ); // assign all to core 1, WiFi in use.
xTaskCreatePinnedToCore( MQTTkeepalive, "MQTTkeepalive", 20000, NULL, 6, NULL, 1 ); // create and start the two tasks to be used, set those task to use 20K stack
xTaskCreatePinnedToCore( DoTheBME680Thing, "DoTheBME280Thing", 20000, NULL, 5, NULL, 1);
xTaskCreatePinnedToCore( fDoParticleDetector, "fDoParticleDetector", 6000, NULL, 3, NULL, 1 ); // assign all to core 1
xTaskCreatePinnedToCore( fmqttWatchDog, "fmqttWatchDog", 3000, NULL, 3, NULL, 1 ); // assign all to core 1
xTaskCreatePinnedToCore( fDoTheDisplayThing, "fDoTheDisplayThing", 22000, NULL, 3, NULL, 1 ); // assign all to core 1
} //void setup()
////
void fparseMQTT( void *pvParameters )
{
struct stu_message px_message;
for (;;)
{
if ( xQueueReceive(xQ_Message, &px_message, portMAX_DELAY) == pdTRUE )
{
xSemaphoreTake( sema_mqttOK, portMAX_DELAY );
mqttOK = 0;
xSemaphoreGive( sema_mqttOK );
if ( px_message.topic == topicRemainingMoisture_0 )
{
x_eData.RM0 = String(px_message.payload).toFloat();
}
} //if ( xQueueReceive(xQ_Message, &px_message, portMAX_DELAY) == pdTRUE )
} //for(;;)
vTaskDelete( NULL );
} // void fparseMQTT( void *pvParameters )
////}
part 2
////
void fDoTheDisplayThing( void * parameter )
{
tft.init(240, 320); // Init ST7789 320x240
tft.setRotation(3);
tft.setTextSize(3);
tft.fillScreen(ST77XX_BLACK);
tft.setTextWrap(false);
struct stu_eData px_eData;
int OneTwoThree = 0;
int countUpDown = 255;
ledcWrite( 4, countUpDown );
int dimDelaytime = 7;
for (;;)
{
if ( xQueueReceive(xQ_eData, &px_eData, portMAX_DELAY) == pdTRUE )
{
//dim backlight
for ( countUpDown; countUpDown-- > 0; )
{
ledcWrite( 4, countUpDown ); // write to channel number 4
vTaskDelay( dimDelaytime );
}
tft.fillScreen(ST77XX_BLACK);
tft.setCursor(0, 0);
OneTwoThree++;
if ( OneTwoThree == 1 )
{
tft.setTextColor( ST77XX_RED );
}
if ( OneTwoThree == 2 )
{
tft.setTextColor( ST77XX_WHITE );
}
if ( OneTwoThree == 3 )
{
tft.setTextColor( ST77XX_BLUE );
OneTwoThree = 0;
}
tft.println( "Temp " + String(px_eData.Temperature) + "F" );
tft.setCursor(0, 30);
tft.println( "Hum " + String(px_eData.Humidity) + "%" );
tft.setCursor(0, 60);
tft.println( "Pres " + String(px_eData.Pressure) + "mmHg" );
tft.setCursor(0, 90);
tft.println( "AQI " + String(px_eData.IAQ) + "%" );
tft.setCursor( 0, 120 );
tft.println( "RM0 " + String(px_eData.RM0) + "%" );
tft.setCursor( 0, 150 );
tft.println( "PM2 " + String(px_eData.PM2) + "ug/m3" );
tft.setCursor( 0, 180 );
if( px_eData.PM2 <= 35.0f )
{
//tft.setTextColor( ST77XX_GREEN );
tft.println( "PM2 is Excellent" );
}
if( (px_eData.PM2 > 35.0f) && px_eData.PM2 <= 75.0f )
{
tft.println( "PM2 is Average" );
}
if( (px_eData.PM2 > 75.0f) && px_eData.PM2 <= 115.0f )
{
tft.println( "PM2 is Light" );
}
if( (px_eData.PM2 > 115.0f) && px_eData.PM2 <= 150.0f )
{
tft.println( "PM2 is Moderate" );
}
if( (px_eData.PM2 > 150.0f) && px_eData.PM2 <= 250.0f )
{
tft.println( "PM2 is Heavy" );
}
if( (px_eData.PM2 > 250.0f) )
{
tft.println( "PM2 is Serious" );
}
//brighten blacklight level
vTaskDelay( 400 ); // wait for screen update to be done
for ( countUpDown; countUpDown <= 255; countUpDown++ )
{
ledcWrite( 4, countUpDown ); // write to channel number 4
vTaskDelay( dimDelaytime );
}
//log_i( "DoTheBME280Thing high watermark % d", uxTaskGetStackHighWaterMark( NULL ) );
} //if ( xQueueReceive(xQ_eData, &px_eData, portMAX_DELAY) == pdTRUE )
} //for (;;)
vTaskDelete( NULL );
} //void fDoTheDisplayTHing( void * parameter )
////
void fmqttWatchDog( void * paramater )
{
int maxNonMQTTresponse = 5;
for (;;)
{
vTaskDelay( 1000 );
if ( mqttOK >= maxNonMQTTresponse )
{
ESP.restart();
}
}
vTaskDelete( NULL );
}
////
part 3
float fCalulate_IAQ_Index( int gasResistance, float Humidity)
{
float hum_baseline = 40.0f;
float hum_weighting = 0.25f;
float gas_offset = 0.0f;
float hum_offset = 0.0f;
float hum_score = 0.0f;
float gas_score = 0.0f;
gas_offset = oGasResistanceBaseLine - float( gasResistance );
hum_offset = float( Humidity ) - hum_baseline;
// calculate hum_score as distance from hum_baseline
if ( hum_offset > 0.0f )
{
hum_score = 100.0f - hum_baseline - hum_offset;
hum_score /= ( 100.0f - hum_baseline );
hum_score *= ( hum_weighting * 100.0f );
} else {
hum_score = hum_baseline + hum_offset;
hum_score /= hum_baseline;
hum_score *= ( 100.0f - (hum_weighting * 100.0f) );
}
//calculate gas score as distance from baseline
if ( gas_offset > 0.0f )
{
gas_score = float( gasResistance ) / oGasResistanceBaseLine;
gas_score *= ( 100.0f - (hum_weighting * 100.0f ) );
} else {
gas_score = 100.0f - ( hum_weighting * 100.0f );
}
return ( hum_score + gas_score );
} //void fCalulate_IAQ_Index( int gasResistance, float Humidity):
////
void fDoParticleDetector( void * parameter )
{
/*
ug/m3 AQI Lvl AQ (Air Quality)
(air Quality Index)
0-35 0-50 1 Excellent
35-75 51-100 2 Average
75-115 101-150 3 Light pollution
115-150 151-200 4 moderate
150-250 201-300 5 heavy
250-500 >=300 6 serious
*/
float ADbits = 4095.0f;
float uPvolts = 3.3f;
float adcValue = 0.0f;
float dustDensity = 0.0f;
float Voc = 0.6f; // Set the typical output voltage in Volts when there is zero dust.
const float K = 0.5f; // Use the typical sensitivity in units of V per 100ug/m3.
xEventGroupWaitBits (eg, evtWaitForBME, pdTRUE, pdTRUE, portMAX_DELAY );
TickType_t xLastWakeTime = xTaskGetTickCount();
const TickType_t xFrequency = 100; //delay for mS
for (;;)
{
//enable sensor led
gpio_set_level( GPIO_NUM_4, HIGH ); // set gpio 4 to high to turn on sensor internal led for measurement
esp_timer_start_once( oneshot_timer, 280 ); // trigger one shot timer for a 280uS timeout, warm up time.
xEventGroupWaitBits (eg, evtDoParticleRead, pdTRUE, pdTRUE, portMAX_DELAY ); // event will be triggered by the timer expiring, wait here for the 280uS
adcValue = float( adc1_get_raw(ADC1_CHANNEL_0) ); //take a raw ADC reading from the dust sensor
gpio_set_level( GPIO_NUM_4, LOW );//Shut off the sensor LED
adcValue = ( adcValue * uPvolts ) / ADbits; //calculate voltage
dustDensity = (adcValue / K) * 100.0; //convert volts to dust density
if ( dustDensity < 0.0f )
{
dustDensity = 0.00f; // make negative values a 0
}
if ( xSemaphoreTake( sema_PublishPM, 0 ) == pdTRUE ) // don't wait for semaphore to be available
{
xSemaphoreTake( sema_MQTT_KeepAlive, portMAX_DELAY );
//log_i( "ADC volts %f Dust Density = %ug / m3 ", adcValue, dustDensity ); // print the calculated voltage and dustdensity
MQTTclient.publish( topicInsidePM, String(dustDensity).c_str() );
xSemaphoreGive( sema_MQTT_KeepAlive );
x_eData.PM2 = dustDensity;
}
//
xLastWakeTime = xTaskGetTickCount();
vTaskDelayUntil( &xLastWakeTime, xFrequency );
//log_i( " high watermark % d", uxTaskGetStackHighWaterMark( NULL ) );
}
vTaskDelete( NULL );
}// end fDoParticleDetector()
////
void DoTheBME680Thing( void *pvParameters )
{
SPI.begin(); // initialize the SPI library
vTaskDelay( 10 );
if (!bme.begin()) {
log_i("Could not find a valid BME680 sensor, check wiring!");
while (1);
}
// Set up oversampling and filter initialization
bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C for 150 ms
//wait for a mqtt connection
while ( !MQTTclient.connected() )
{
vTaskDelay( 250 );
}
xEventGroupSetBits( eg, evtWaitForBME );
TickType_t xLastWakeTime = xTaskGetTickCount();
const TickType_t xFrequency = 1000 * 15; //delay for mS
for (;;)
{
x_eData.Temperature = bme.readTemperature();
x_eData.Temperature = ( x_eData.Temperature * 1.8f ) + 32.0f; // (Celsius x 1.8) + 32
x_eData.Pressure = bme.readPressure();
x_eData.Pressure = x_eData.Pressure / 133.3223684f; //converts to mmHg
x_eData.Humidity = bme.readHumidity();
x_eData.IAQ = fCalulate_IAQ_Index( bme.readGas(), x_eData.Humidity );
//log_i( " temperature % f, Pressure % f, Humidity % f IAQ % f", x_eData.Temperature, x_eData.Pressure, x_eData.Humidity, x_eData.IAQ);
xSemaphoreTake( sema_MQTT_KeepAlive, portMAX_DELAY );
if ( MQTTclient.connected() )
{
MQTTclient.publish( topicInsideTemp, String(x_eData.Temperature).c_str() );
vTaskDelay( 3 ); // gives the Raspberry Pi 4 time to receive the message and process
MQTTclient.publish( topicInsideHumidity, String(x_eData.Humidity).c_str() );
vTaskDelay( 3 ); // delay for RPi
MQTTclient.publish( topicInsidePressure, String(x_eData.Pressure).c_str() );
vTaskDelay( 3 ); // delay for RPi
MQTTclient.publish( topicInsideIAQ, String(x_eData.IAQ).c_str() );
}
xSemaphoreGive( sema_MQTT_KeepAlive );
xSemaphoreGive( sema_PublishPM ); // release publish of dust density
xSemaphoreTake( sema_mqttOK, portMAX_DELAY );
mqttOK ++;
xSemaphoreGive( sema_mqttOK );
//
xQueueOverwrite( xQ_eData, (void *) &x_eData );// send data to display
//
xLastWakeTime = xTaskGetTickCount();
vTaskDelayUntil( &xLastWakeTime, xFrequency );
// log_i( "DoTheBME280Thing high watermark % d", uxTaskGetStackHighWaterMark( NULL ) );
}
vTaskDelete ( NULL );
}
////
/*
Important to not set vTaskDelay to less then 10. Errors begin to develop with the MQTT and network connection.
makes the initial wifi/mqtt connection and works to keeps those connections open.
*/
void MQTTkeepalive( void *pvParameters )
{
sema_MQTT_KeepAlive = xSemaphoreCreateBinary();
xSemaphoreGive( sema_MQTT_KeepAlive ); // found keep alive can mess with a publish, stop keep alive during publish
// setting must be set before a mqtt connection is made
MQTTclient.setKeepAlive( 90 ); // setting keep alive to 90 seconds makes for a very reliable connection, must be set before the 1st connection is made.
for (;;)
{
//check for a is-connected and if the WiFi 'thinks' its connected, found checking on both is more realible than just a single check
if ( (wifiClient.connected()) && (WiFi.status() == WL_CONNECTED) )
{
xSemaphoreTake( sema_MQTT_KeepAlive, portMAX_DELAY ); // whiles MQTTlient.loop() is running no other mqtt operations should be in process
MQTTclient.loop();
xSemaphoreGive( sema_MQTT_KeepAlive );
}
else {
log_i( "MQTT keep alive found MQTT status % s WiFi status % s", String(wifiClient.connected()), String(WiFi.status()) );
if ( !(wifiClient.connected()) || !(WiFi.status() == WL_CONNECTED) )
{
connectToWiFi();
}
connectToMQTT();
}
vTaskDelay( 250 ); //task runs approx every 250 mS
}
vTaskDelete ( NULL );
}
////
void connectToMQTT()
{
// create client ID from mac address
byte mac[5];
WiFi.macAddress(mac); // get mac address
//log_i( "mac address % d. % d. % d. % d. % d", mac[0], mac[1], mac[2], mac[3], mac[4] );
String clientID = String(mac[0]) + String(mac[4]) ; // use mac address to create clientID
//log_i( "connect to mqtt as client % s", clientID );
while ( !MQTTclient.connected() )
{
MQTTclient.connect( clientID.c_str(), mqtt_username, mqtt_password );
log_i( "connecting to MQTT" );
vTaskDelay( 250 );
}
MQTTclient.setCallback( mqttCallback );
MQTTclient.subscribe( topicOK );
MQTTclient.subscribe( topicRemainingMoisture_0 );
log_i("MQTT Connected");
} //void connectToMQTT()
void connectToWiFi()
{
int TryCount = 0;
//log_i( "connect to wifi" );
while ( WiFi.status() != WL_CONNECTED )
{
TryCount++;
WiFi.disconnect();
WiFi.begin( SSID, PASSWORD );
//log_i(" waiting on wifi connection" );
vTaskDelay( 4000 );
if ( TryCount == 10 )
{
ESP.restart();
}
}
//log_i( "Connected to WiFi" );
WiFi.onEvent( WiFiEvent );
}
////
void loop() { }
Good luck.
The sky brightness controls the short-current in a solar panel linearly, the voltage is
dependent non-linearly on the brightness, load current and temperature of the panel...
If you want to measure, get a light sensor, not a PV panel!
(short-circuiting a PV panel is not a good idea, it will self-heat a lot).
You dont say what your objective is, and the way you make a measurement would depend on this.
I'm guessing you want to measure the total radiant intensity incident on a plane surface
basically to indicate how much power would be generated by a PV panel.
There are lots of different of photosensors you could use, but your choice would depend on the directionality, sensitivity, spectral response etc.
If my guess above is right we can eliminate some candidates.
Photodiode, phototransistor etc have a very good response over huge differnces in intensity, but are too directional.
A photoresistor has less directionality but is a very poor match to a pv panel for spectral response.
So we are back to using a pv panel. However the sky brightness is not uniform (especially on a sunny day!)
It will only indicate the output of a pv panel with the same orientation
Also as MarkT says the open circuit output voltage is much more dependent on temperature than light intensity, while measuring the short-circuit current - which is a much better representation of light intensity - also has issues.
Given there seems no ideal answer, I'd consider using a silicon photodiode or transistor pointing downwards to a flat white surface; or just put a resistor across a SMALL pv cell and read the voltage.
Perhaps the OP could define "sky brightness".
Consider a solar cell can detect, respond to, and create electricity on a cloudy day. While it is raining my solar cell produces electricity. My solar cells produce more electricity then what seems reasonable during the rain. Why? Modern solar cells can produce power from differing received frequencies. The 'light' seeping through clouds during rain is 'light' we humans cannot see. OP, define "sky brightness".
The solar tracker I built uses 4 photodiodes reversed biased with 1M resistor. My surprise, during the building was where, when the device was in the house, it thought was the brightest light. Not the bulb overhead but the light from a window during the hours of 11AM till dark, then it went back to the lightbulb over head.
I used 4 BPW34 photo diodes placed at the ends of the solar cells. The diodes are mounted below the solar cells edge so as to cast a small shadow onto the cell if it is not pointed directly at the sun.
Solar illumination when overcast is often around 5 to 10% of full sun, but heavily overcast
can be much darker. That's not exactly surprizing surely? Cloud attenuates all usable light
wavelengths pretty much the same, which is why clouds are grey, not blue or red. Its a scattering
phenomenon due to small water droplets.
Idahowalker:
Perhaps the OP could define "sky brightness".
As I mean sky brightness I mean its not precise but the main part is that it is a percentage
(and from the rest)
As I mean sky brightness I mean its not precise but the main part is that it is a percentage
In other words, you want a number that is virtualy meaningless. Thats easy. (but not really science and measurement)
I do not have resistors on hand right now.
OK so just use the arduino uno to measure the voltage across the solar panel. What will it tell you?
It will give you a number that will depend on the level of illumination (a bit) and also on the temperature. And the orientation of the panel, degree of shading, etc etc.
I was figuring the OP could be trying to index a sky brightness level instead of take an actual lumens measurement. OP, there is a way to read lumens from a voltage conversion using a MCU.
Mods can close this thread.
I decided to give up on this project, someday i might use this info later in my life.
This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.