soligen2010 / encoder Goto Github PK

- Button: 3 held
millisPressed: 7174
- Button: 3 held
millisPressed: 7213
- Button: 4 released
millisReleased: 7246
- time held = 33

#include <ClickEncoder.h>
#include <TimerOne.h>

int16_t oldEncPos, encPos;
uint8_t buttonState;
uint8_t lastButtonState;

#define pinA 3
#define pinB 2
#define pinSw 4 //switch
#define STEPS 4
unsigned long millisPressed;
unsigned long millisReleased;

ClickEncoder encoder(pinA, pinB, pinSw, STEPS);

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

  Timer1.initialize(1000);
  Timer1.attachInterrupt(timerIsr);

  encoder.setAccelerationEnabled(true);

  Serial.print("Acceleration is ");
  Serial.println((encoder.getAccelerationEnabled()) ? "enabled" : "disabled");

  oldEncPos = -1;
}

void loop() {
  encPos += encoder.getValue();

  if (encPos != oldEncPos) {
    oldEncPos = encPos;
    Serial.print("Encoder Value: ");
    Serial.println(encPos);
  }

  buttonState = encoder.getButton();


  if (buttonState != 0) {
//    if (buttonState != lastButtonState) {
//      millisPressed = millis();
//      lastButtonState = buttonState;
//    }
    Serial.print("Button: "); Serial.println(buttonState);
    switch (buttonState) {
      case ClickEncoder::Open:          //0
        break;

      case ClickEncoder::Closed:        //1
        break;

      case ClickEncoder::Pressed:       //2
        break;

      case ClickEncoder::Held:          //3
        Serial.println("held");
        millisPressed = millis();
        Serial.print("millisPressed: "); Serial.println(millisPressed);
        break;

      case ClickEncoder::Released:      //4
        millisReleased = millis();
        Serial.print("millisReleased: "); Serial.println(millisReleased);
        Serial.print("time held = "); Serial.println(millisReleased - millisPressed);
        break;

      case ClickEncoder::Clicked:       //5
        break;

      case ClickEncoder::DoubleClicked: //6
        break;
    }
  }
}

void timerIsr() {
  encoder.service();
}

Mon Oct 14 13:49:05 (master)> platformio.exe device monitor                              
Miniterm on COM4  115200,8,N,1                                            
Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H                    
Encoder Value: 0                                                                         
Encoder Value: -1                                                                        
Encoder Value: 0                                                                         
Encoder Value: -1                                                                        
Encoder Value: 0                                    
Encoder Value: -1                                                                        
Encoder Value: 0                                                                         
Encoder Value: -1                                                                        
Encoder Value: 0                                                                         
Encoder Value: -1                                                                        
Encoder Value: 0                                                                         
Encoder Value: -1

#include <ClickEncoder.h>
#include <TimerOne.h>

ClickEncoder *encoder;
int16_t last, value;
#define ENCODER_PIN_A    5
#define ENCODER_PIN_B    6
#define WITHOUT_BUTTON 1
/* #define ENCODER_PUSH_BUTTON A3 */
#define ENC_HALFSTEP 1

void timerIsr() {
  encoder->service();
}

void setup() {
  Serial.begin(115200);
  /* encoder = new ClickEncoder(ENCODER_PIN_A, ENCODER_PIN_B, ENCODER_PUSH_BUTTON,1); */
  encoder = new ClickEncoder(ENCODER_PIN_A, ENCODER_PIN_B,-1);

  Timer1.initialize(1000);
  Timer1.attachInterrupt(timerIsr); 

  last = -1;
}

void loop() {  
  value += encoder->getValue();

  if (value != last) {
    last = value;
    Serial.print("Encoder Value: ");
    Serial.println(value);
  }

  ClickEncoder::Button b = encoder->getButton();
  if (b != ClickEncoder::Open) {
    Serial.print("Button: ");
    #define VERBOSECASE(label) case label: Serial.println(#label); break;
    switch (b) {
      VERBOSECASE(ClickEncoder::Pressed);
      VERBOSECASE(ClickEncoder::Held)
      VERBOSECASE(ClickEncoder::Released)
      VERBOSECASE(ClickEncoder::Clicked)
      case ClickEncoder::DoubleClicked:
          Serial.println("ClickEncoder::DoubleClicked");
          encoder->setAccelerationEnabled(!encoder->getAccelerationEnabled());
          Serial.print("  Acceleration is ");
          Serial.println((encoder->getAccelerationEnabled()) ? "enabled" : "disabled");
        break;
    }
  }    
}

Mon Oct 14 13:48:19 (master)> platformio run -e uno --target upload
Processing uno (platform: atmelavr; board: nanoatmega328; framework: arduino)
-----------------------------------------------------------------------------------------------------------------------------------------------------------

Verbose mode can be enabled via `-v, --verbose` option
CONFIGURATION: https://docs.platformio.org/page/boards/atmelavr/nanoatmega328.html
PLATFORM: Atmel AVR 1.15.0 > Arduino Nano ATmega328
HARDWARE: ATMEGA328P 16MHz, 2KB RAM, 30KB Flash
PACKAGES: toolchain-atmelavr 1.50400.190710 (5.4.0), framework-arduinoavr 4.1.2, tool-avrdude 1.60300.190424 (6.3.0)
Converting encoder.ino
LDF: Library Dependency Finder -> http://bit.ly/configure-pio-ldf
LDF Modes: Finder ~ chain, Compatibility ~ soft
Found 11 compatible libraries
Scanning dependencies...
Dependency Graph
|-- <ClickEncoder>
|-- <TimerOne>
Compiling .pio\build\uno\src\encoder.ino.cpp.o
C:/Users/Marco/work/TonUINO/src/encoder.ino: In function 'void loop()':
C:/Users/Marco/work/TonUINO/src/encoder.ino:40:12: warning: enumeration value 'Open' not handled in switch [-Wswitch]
     switch (b) {
            ^
C:/Users/Marco/work/TonUINO/src/encoder.ino:40:12: warning: enumeration value 'Closed' not handled in switch [-Wswitch]
Linking .pio\build\uno\firmware.elf
Checking size .pio\build\uno\firmware.elf
Building .pio\build\uno\firmware.hex
Memory Usage -> http://bit.ly/pio-memory-usage
DATA:    [==        ]  18.6% (used 380 bytes from 2048 bytes)
PROGRAM: [=         ]  13.6% (used 4174 bytes from 30720 bytes)
Configuring upload protocol...
AVAILABLE: arduino
CURRENT: upload_protocol = arduino
Looking for upload port...
Use manually specified: COM4
Uploading .pio\build\uno\firmware.hex

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: reading input file ".pio\build\uno\firmware.hex"
avrdude: writing flash (4174 bytes):

Writing | ################################################## | 100% 1.19s

avrdude: 4174 bytes of flash written
avrdude: verifying flash memory against .pio\build\uno\firmware.hex:
avrdude: load data flash data from input file .pio\build\uno\firmware.hex:
avrdude: input file .pio\build\uno\firmware.hex contains 4174 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.91s

avrdude: verifying ...
avrdude: 4174 bytes of flash verified

avrdude: safemode: Fuses OK (E:00, H:00, L:00)

avrdude done.  Thank you.

=============================================================== [SUCCESS] Took 8.94 seconds ===============================================================

const byte pinA = 3; // Pin on encoder, CLK
const byte pinB = 4; // Pin on encoder, DT
void setup(){
    // Encoder setup
    pinMode(pinA, INPUT);
    pinMode(pinB, INPUT);
    attachInterrupt(digitalPinToInterrupt(pinA), InterruptEncoder, LOW); // Attach the routine to service the interrupts
    ...
}

void InterruptEncoder(){ // Encoder interrupt
    ???
}

static uint32_t lastService = 0;

if (lastService + 1000 < micros()) {
       lastService = micros();
       encoder.service();
}

 if (micros() < encoderLastService) {   // micros() has gone back to zero
    encoderLastService = micros();
  } else if (micros() > (encoderLastService + 1000)) { // Update only once every 1 ms  
    encoderLastService = micros();                
    encoder.service();  
  }

#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <RunningMedian.h>
#include <SHT1x.h>
#include<CountUpDownTimer.h>
#include <Adafruit_SSD1306.h>
#include <ClickEncoder.h>


#define ENCODER_PINA     16  //D0 
#define ENCODER_PINB     12  //D6
#define ENCODER_BTN      0   //D3

#define ENCODER_STEPS_PER_NOTCH    4   // Change this depending on which encoder is used

ClickEncoder encoder = ClickEncoder(ENCODER_PINA,ENCODER_PINB,ENCODER_BTN,ENCODER_STEPS_PER_NOTCH);

static int16_t last, value;

#define OLED_RESET LED_BUILTIN //4
Adafruit_SSD1306 display(OLED_RESET);

// Specify data and clock connections and instantiate SHT1x object
#define dataPin  2
#define clockPin 14
SHT1x sht1x(dataPin, clockPin);

float temp_c , wbt; 
float humidity;
char payload[8];
String send_data;
char attributes[100];

CountUpDownTimer sensor_timer(UP, HIGH); 
CountUpDownTimer send_data_timer(UP, HIGH); 


#define TOKEN "123"

const char* ssid = "Pandora-LR";
const char* password = "123";
const char* mqtt_server = "demo.thingsboard.io";
const char* esp_hostname = "esptest";

// Static IP's
IPAddress arduino_ip ( 10,  64,   9,  229);
IPAddress dns_ip     ( 10,  64,   9,   20);
IPAddress gateway_ip ( 10,  64,   9,   20);
IPAddress subnet_mask(255, 255, 255,   0);

WiFiClient espClient;
PubSubClient client(espClient);


long lastMsg = 0;
char msg[50];


const char* outTopic = "espout";
const char* inTopic = "espin";

//d7 (13) en d8 (15) is ok op reboot.

int feeder_relay_pin = 15;
int stoker_relay_pin = 13;
bool relayState = LOW;

// RH Smoothing vars
RunningMedian s_rh = RunningMedian(10); //Smooth RH probe 1
RunningMedian s_temp = RunningMedian(10); //Smooth Stoker Temp probe 1


//RH Constants
float svp_0 = 610.7; // saturated vapour pressure [Pa], water, at 0 Celcius
float aa = 7.5;
float bb = 237.3; // [K]
float Gamma = 66; // [Pa/K]

void setup_wifi() {
  delay(10);
  display.clearDisplay();  
  display.setTextSize(1);
  display.setCursor(0,0);
  display.println("Connecting to ");  
  display.println(ssid); 
  display.display();
  

  while (WiFi.status() != WL_CONNECTED) {    
    for (int i = 0; i < 500; i++) {     
      delay(1);
    }
    Serial.print(".");
    display.print(".");
    display.display();    
  }

  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.hostname(esp_hostname);
  WiFi.config(arduino_ip, gateway_ip, subnet_mask); 
  WiFi.begin(ssid, password);

  display.println("WiFi connected");   
  display.display();
  //delay(10000);
 
}

void on_message(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  // Switch on the LED if an 1 was received as first character
  if ((char)payload[0] == '0') {
    digitalWrite(feeder_relay_pin, LOW);   // Turn the LED on (Note that LOW is the voltage level
    Serial.println("relay_pin -> LOW");
    client.publish(outTopic, "OFF");
    digitalWrite(2, HIGH);
    relayState = LOW;
    //EEPROM.write(0, relayState);    // Write state to EEPROM
    //EEPROM.commit();
  } else if ((char)payload[0] == '1') {
    digitalWrite(feeder_relay_pin, HIGH);  // Turn the LED off by making the voltage HIGH
    Serial.println("ON");
    client.publish(outTopic, "ON");
    digitalWrite(2, LOW);
    relayState = HIGH;   
    delay(3500);
    digitalWrite(feeder_relay_pin, LOW);
    client.publish(outTopic, "OFF");
    digitalWrite(2, HIGH);
  } else if ((char)payload[0] == '2') {
    relayState = !relayState;
    digitalWrite(feeder_relay_pin, relayState);  // Turn the LED off by making the voltage HIGH
    digitalWrite(2, !relayState);
    Serial.print("relay_pin -> switched to ");
    client.publish(outTopic, "relay_pin -> switched to");
    Serial.println(relayState);
    
  }
}



void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Connecting to ThingsBoard node ...");
    // Attempt to connect (clientId, username, password)
    if ( client.connect("ESP8266Client", TOKEN, NULL) ) {
      Serial.println( "[DONE]" );
    } else {
      Serial.print( "[FAILED] [ rc = " );
      Serial.print( client.state() );
      Serial.println( " : retrying in 5 seconds]" );
      // Wait 5 seconds before retrying
      delay( 5000 );
    }
  }
}



void setup() {

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.print("RH Control");  
  display.display();
  delay(1000);
 
  pinMode(feeder_relay_pin, OUTPUT);     // Initialize the relay pin as an output
  pinMode(stoker_relay_pin, OUTPUT);     // Initialize the relay pin as an output
  pinMode(16, INPUT);   
  pinMode(12, INPUT);
  pinMode(0, INPUT);
  
 
  encoder.setButtonHeldEnabled(true);
  encoder.setDoubleClickEnabled(true);
  
  // Enable the button to be on pin 0.  Normally pin 0 is not recognized as a valid pin for a button,
  // this is to maintain backward compatibility with an old version of the library
  // This version can have the button on pin zero, and this call enables the feature.
  // in this version best to use pin -1 instead of 0 to disable button functions
  encoder.setButtonOnPinZeroEnabled(true);
  
  Serial.begin(115200);
  setup_wifi();                   // Connect to wifi
  client.setServer(mqtt_server, 1883);
  client.setCallback(on_message);

  sensor_timer.StartTimer();
  send_data_timer.StartTimer();

  
  
}

void loop() {

  sensor_timer.Timer();
  send_data_timer.Timer();

  if (!client.connected()) {
    reconnect();
  }
  client.loop();




  if (sensor_timer.TimeHasChanged() ) // this prevents the time from being constantly shown.
  {   
     if(sensor_timer.ShowSeconds() >= 2) {

       //digitalWrite(2, HIGH);
        
        // Read values from the sensor        
        humidity = sht1x.readHumidity();
        temp_c = sht1x.retrieveTemperatureC(); 
        if(temp_c <= 0){
          humidity = sht1x.readHumidity();
          temp_c = sht1x.retrieveTemperatureC(); 
        }


       s_rh.add(humidity);
       humidity = s_rh.getMedian();

       s_temp.add(temp_c);
       temp_c = s_temp.getMedian();
 


        //Calculate the Wet Bulb
        wbt = CalcWetBulb(temp_c , humidity);
  
        
        Serial.print("RH :");
        Serial.println(humidity , 2);
        Serial.print("Temp :");
        Serial.println(temp_c , 2);   
        Serial.print("Wet Bulb :");
        Serial.println(wbt , 2);
        
        sensor_timer.ResetTimer();

        display.clearDisplay();  
        display.setTextSize(1);
        display.setTextColor(WHITE);
        display.setCursor(0,0);
        display.print("RH % :"  + String(humidity));  
        display.setCursor(0,10);
        display.print("DB Temp :"  + String(temp_c));        
        display.setCursor(0,20);
        display.print("WB Temp :"  + String(wbt));
        display.display();

        //digitalWrite(2, LOW);
     }

  }

  //Send the data every 20 seconds
  if(send_data_timer.ShowSeconds() >= 20) {     
      //Send all the values via MQTT            
      // Prepare a JSON payload string
      String payload1 = "{";
      payload1 += "\"temperature\":"; payload1 += temp_c; payload1 += ",";
      payload1 += "\"humidity\":"; payload1+= humidity; payload1 += ",";
      payload1 += "\"wbt\":"; payload1+= wbt;
      payload1 += "}";

      // Send payload
      char attributes1[100];
      payload1.toCharArray( attributes1, 100 );
      client.publish( "v1/devices/me/telemetry", attributes1 );
      Serial.println( attributes1 );
      send_data_timer.ResetTimer();
            
    }


  //Switch the relay
  if(wbt <= 18){
     digitalWrite(feeder_relay_pin, HIGH);
     digitalWrite(stoker_relay_pin, HIGH);
     //client.publish(outTopic, "ON");
  }
  else{
    digitalWrite(feeder_relay_pin, LOW);
    digitalWrite(stoker_relay_pin, LOW);
    //client.publish(outTopic, "OFF");
  }


  //Encoder Code
  //Call Service in loop becasue using timer interrupts may affect ESP8266 WIFI
  //however call no more than 1 time per millisecond to reduce encoder bounce
  static uint32_t lastService = 0;
  if (lastService + 1000 < micros()) {
    lastService = micros();                
    encoder.service();  
  }
 
  value += encoder.getValue();
  
  if (value != last) {
    last = value;
    Serial.print("Encoder Value: ");
    Serial.println(value);
    display.setCursor(0,30);
    display.print("Value :"  + String(value));
    display.display();

  }
  
  ClickEncoder::Button b = encoder.getButton();
  if (b != ClickEncoder::Open) {
    Serial.print("Button: ");
    #define VERBOSECASE(label) case label: Serial.println(#label); break;
    switch (b) {
      VERBOSECASE(ClickEncoder::Pressed);
      VERBOSECASE(ClickEncoder::Held)
      VERBOSECASE(ClickEncoder::Released)
      VERBOSECASE(ClickEncoder::Clicked)
      VERBOSECASE(ClickEncoder::DoubleClicked)
    }
  } 



   
  
}

//Calculate the wet bulb temperature
float CalcWetBulb(float DB , float RH){
  float Tw;

  Tw = DB * atan(0.151977 * sqrt(RH + 8.313659))
       + atan(DB + RH) - atan(RH - 1.676331)
       + 0.00391838 * pow(RH , 3./2.) * atan(0.023101 * RH)
       - 4.686035;

  return Tw;
  
}



// calc saturated vapour pressure at Celcius-temp T:
float CalcSVP(float T) {
  float tmp = aa * T / (bb+T);
  return svp_0 * pow(10,tmp);
}

// calc partial vapour pressure at Celcius-temp T, given wet-bulb Tw:
float CalcVapPress(float T,float Tw) {
  float A = 66.87 * (1+0.00115 * Tw); // at 1 atm!!
  return CalcSVP(Tw) - A * (T-Tw);
}

// calc relative humidity at Celcius-temp T, given wet-bulb Tw:
float CalcRH(float T,float Tw) {
  float tmp = (CalcVapPress(T,Tw)/CalcSVP(T)*1000+0.5)/10;
  if (tmp<0) {   
    return 0;
  }
  else {
    return tmp;
  }
}

ClickEncoder myRE;
buttonState = myRE.getButton();