Lähettimen lähdekoodi V2

Versiohistoria

2.0

Lisätty CRC-16 tarkistussummafunktio. Lähettää singalin 4-10 sekunnin välein, jolla tarkoitus pienentää paristojen kulutusta. Voisi implementoida suoraan virransäästöominaisuudet.

2.1

Poistettu ylimääräiset kommentit

#include <CRC16.h>  // include CRC16 library
#include <RH_ASK.h>  // include RadioHead library

RH_ASK rf_driver(1000, 11, 12, 10); 	// speed = 1000 bits/sec, tx pin = 12

byte data[4];                     // create byte array to store DIP switch values
uint16_t checksumValue;           // variable to store the checksum value

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(A0));   // seed the random number generator with noise from an unconnected analog pin
  pinMode(2, INPUT_PULLUP);     // set DIP switch pins as input pull-up
  pinMode(3, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  pinMode(5, INPUT_PULLUP);

  data[0] = digitalRead(2);      // read DIP switches and store in the array
  data[1] = digitalRead(3);
  data[2] = digitalRead(4);
  data[3] = digitalRead(5);

  CRC16 crc;                     // create an instance of CRC16 class with default parameters (you can customize them if needed)
  crc.add(data, sizeof(data));    // add the DIP switch values to the CRC calculation
  checksumValue = crc.calc();    // calculate CRC-16 checksum value for the DIP switch values

  rf_driver.init();             // initialize the radio driver
}

void loop() {

  rf_driver.send((uint8_t*)&checksumValue, sizeof(checksumValue)); // send the checksum value first
  rf_driver.waitPacketSent();                                     // wait for the packet to be sent
  rf_driver.send(data, sizeof(data)); // then send the DIP switch values
  rf_driver.waitPacketSent();         // wait for the packet to be sent
  delay(random(4000, 10000));          // add random delay of between 4-10 seconds before transmitting again
}

v2.2

Lisätty virransäästöominaisuus. Mitattuna virrankulutus 0.3-0.1A 9V

#include <CRC16.h>  // include CRC16 library
#include <RH_ASK.h>  // include RadioHead library
#include <LowPower.h>  // include LowPower library for sleep functionality

RH_ASK rf_driver(1000, 11, 12,10);   // speed = 1000 bits/sec, tx pin = 12

byte data[4];                     // create byte array to store DIP switch values
uint16_t checksumValue;           // variable to store the checksum value

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(A0));   // seed the random number generator with noise from an unconnected analog pin
  pinMode(2, INPUT_PULLUP);     // set DIP switch pins as input pull-up
  pinMode(3, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  pinMode(5, INPUT_PULLUP);

  data[0] = digitalRead(2);      // read DIP switches and store in the array
  data[1] = digitalRead(3);
  data[2] = digitalRead(4);
  data[3] = digitalRead(5);

  CRC16 crc;                     // create an instance of CRC16 class with default parameters (you can customize them if needed)
  crc.add(data, sizeof(data));    // add the DIP switch values to the CRC calculation
  checksumValue = crc.calc();    // calculate CRC-16 checksum value for the DIP switch values

  if (!rf_driver.init()) {
  //if(rf_driver.init();             // initialize the radio driver
    Serial.println("radioerror");
  }
}

void loop() {
  rf_driver.send((uint8_t*)&checksumValue, sizeof(checksumValue)); // send the checksum value first
  rf_driver.waitPacketSent();                                     // wait for the packet to be sent
  rf_driver.send(data, sizeof(data)); // then send the DIP switch values
  rf_driver.waitPacketSent();         // wait for the packet to be sent

  int sleepTime = random(4000, 10000); // calculate the next sleep time randomly between 4-10 seconds
  while (sleepTime > 8000) {          // if sleep time is greater than 8 seconds
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); // put the microcontroller into deep sleep for 8 seconds
    sleepTime -= 8000;                              // reduce sleep time by 8 seconds
  }

  if (sleepTime > 0) {
    delay(sleepTime);                // delay for the remaining time, if any
  }
}

v2.3

Lisätty lähetysintervalli ja vaihdettu eri Arduino virransäästölibraryyn, lisäksi yhdistetty sekä data,e ttä crc checksum yhteen radiopakettiin (EI TESTATTU)

#include <CRC16.h>
#include <RH_ASK.h>
#include <ArduinoLowPower.h>

// Speed = 1000 bits/sec, TX pin = 12
RH_ASK rf_driver(1000, 11, 12, 10); 

byte data[4];                     
uint16_t checksumValue;           
byte transmitBuffer[6]; // Buffer: [CRC_L, CRC_H, D1, D2, D3, D4]

unsigned long lastTransmissionTime = 0;
const unsigned long firstFiveMinutesInterval = 1000;
const unsigned long thirtySecondsInterval = 30000;
const unsigned long oneHourInterval = 60 * 60 * 1000;
const unsigned long tenMinutesInterval = 10 * 60 * 1000;
const unsigned long deepSleepDuration = 8000;

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(A0));
  
  pinMode(2, INPUT_PULLUP);
  pinMode(3, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  pinMode(5, INPUT_PULLUP);

  // Luetaan DIP switchit
  data[0] = digitalRead(2);
  data[1] = digitalRead(3);
  data[2] = digitalRead(4);
  data[3] = digitalRead(5);

  CRC16 crc;
  crc.add(data, sizeof(data));
  checksumValue = crc.calc();

  if (!rf_driver.init()) {
    Serial.println("Radio init failed!");
  }
}

void loop() {
  unsigned long currentTime = millis();

  // Lähetyslogiikka
  bool shouldTransmit = false;
  if (currentTime - lastTransmissionTime >= firstFiveMinutesInterval && currentTime < 5 * 60 * 1000) {
    shouldTransmit = true;
  } else if (currentTime - lastTransmissionTime >= thirtySecondsInterval && currentTime >= 5 * 60 * 1000 && (currentTime % oneHourInterval >= tenMinutesInterval)) {
    shouldTransmit = true;
  }

  if (shouldTransmit) {
    // Pakataan CRC ja data yhteen 6 tavun bufferiin
    transmitBuffer[0] = (uint8_t)(checksumValue & 0xFF);         // CRC matalin tavu
    transmitBuffer[1] = (uint8_t)((checksumValue >> 8) & 0xFF); // CRC ylin tavu
    transmitBuffer[2] = data[0];
    transmitBuffer[3] = data[1];
    transmitBuffer[4] = data[2];
    transmitBuffer[5] = data[3];

    Serial.println("Sending packet...");
    rf_driver.send(transmitBuffer, sizeof(transmitBuffer));
    rf_driver.waitPacketSent();
    
    lastTransmissionTime = currentTime;
  } 
  // Unen ja aikataulun hallinta
  else if (currentTime - lastTransmissionTime >= oneHourInterval) {
    unsigned long sleepTime = oneHourInterval - (currentTime % oneHourInterval);
    performSleep(sleepTime);
  } else {
    unsigned long nextInterval = (currentTime < 5 * 60 * 1000) ? firstFiveMinutesInterval : thirtySecondsInterval;
    unsigned long sleepTime = nextInterval - (currentTime - lastTransmissionTime);
    if (sleepTime > 0) performSleep(sleepTime);
  }
}

void performSleep(unsigned long sleepTime) {
  while (sleepTime > 0) {
    if (sleepTime > deepSleepDuration) {
      LowPower.deepSleep(deepSleepDuration);
      sleepTime -= deepSleepDuration;
    } else {
      delay(sleepTime);
      break;
    }
  }
}