WireLess Gate Shield V1.0

 
#include <RFM69.h>
#include <SPI.h>
#include "RF24.h"
#include <IRremote.h>
#include <Wire.h>
#include "RTClib.h"
 
RF24 radio24(7,8); 
 
RTC_DS1307 RTC;
 
int RECV_PIN = 5;
 
IRrecv irrecv(RECV_PIN);
 
decode_results results;
 
// create a framework for the transmission of values
typedef struct{         
  int SensorID;        // ID sensor
  int CommandTo;       // command module number ...
  int Command;         // command
  // 0 - answer 
  // 1 - get the value
  // 2 - set the value
  int ParamID;         // parameter identifier
  float ParamValue;    // value
  boolean Status;      // status
  // 0 - read-only (RO)
  // 1 -  can change the (RW)
  char Comment[16];    // comment
}
Message;
 
Message sensor; 
 
const uint64_t pipes[2] = { 
  0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
 
volatile boolean waitRF24 = false;
 
#define NODEID      99
#define NETWORKID   100
#define GATEWAYID   1
#define FREQUENCY   RF69_433MHZ //Match this with the version of your Moteino! (others: RF69_433MHZ, RF69_868MHZ)
#define KEY         "thisIsEncryptKey" //has to be same 16 characters/bytes on all nodes, not more not less!
#define LED         6
#define SERIAL_BAUD 115200
#define ACK_TIME    30  // # of ms to wait for an ack
 
#define RFM69_RESET 14  //A0
#define RFM69_NSS 9
#define RFM69_DIO0 3
 
#define BUTTON 15 // A1
 
#define MOSI 11
#define MISO 12
#define SCK 13
 
int TRANSMITPERIOD = 500; //transmit a packet to gateway so often (in ms)
byte sendSize=0;
boolean requestACK = false;
RFM69 radio;
 
int delta=2000;
 
unsigned long blinkStop;
unsigned long timeReady;
 
typedef struct {		
  int           nodeId; //store this nodeId
  unsigned long uptime; //uptime in ms
  float         temp;   //temperature maybe?
} 
Payload;
Payload theData;
 
void setup() {
  Serial.begin(SERIAL_BAUD);
 
  pinMode(LED, OUTPUT);
 
  pinMode(RFM69_NSS, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(MOSI, OUTPUT);
  pinMode(MISO, INPUT);
  pinMode(SCK, OUTPUT);
 
  pinMode(RFM69_RESET, OUTPUT);
  pinMode(RFM69_DIO0, INPUT);
 
  pinMode(BUTTON, INPUT);
 
  digitalWrite(RFM69_NSS, HIGH);
  digitalWrite(7, HIGH);
 
  resetRFM69();
  radio.setCS(RFM69_NSS);
  radio.initialize(FREQUENCY,NODEID,NETWORKID);
 
  //radio.setHighPower(); //uncomment only for RFM69HW!
 
  radio.encrypt(KEY);
  char buff[50];
  sprintf(buff, "\nTransmitting at %d Mhz...", FREQUENCY==RF69_433MHZ ? 433 : FREQUENCY==RF69_868MHZ ? 868 : 915);
  Serial.println(buff);
 
  radio24.begin();
  // optionally, increase the delay between retries & # of retries
  radio24.setRetries(15,15);
  radio24.setChannel(119);
  // по умолчанию СЛУШАЕМ
  radio24.openWritingPipe(pipes[1]);
  radio24.openReadingPipe(1,pipes[0]);
  radio24.startListening();
 
  delay(20);
 
  attachInterrupt(0, isr_RF24, FALLING);
 
  irrecv.enableIRIn();
 
  Wire.begin();
  RTC.begin();
 
  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
}
 
long lastPeriod = -1;
void loop() {
 
  //check for any received packets
  if (radio.receiveDone())
  {
    Serial.print('[');
    Serial.print(radio.SENDERID, DEC);
    Serial.print("] ");
    for (byte i = 0; i < radio.DATALEN; i++)
      Serial.print((char)radio.DATA[i]);
    Serial.print("   [RX_RSSI:");
    Serial.print(radio.readRSSI());
    Serial.print("]");
 
    if (radio.ACK_REQUESTED)
    {
      radio.sendACK();
      Serial.print(" - ACK sent");
      delay(10);
    }
    Serial.println();
  }
 
  int currPeriod = millis()/TRANSMITPERIOD;
  if (currPeriod != lastPeriod)
  {
    //fill in the struct with new values
    theData.nodeId = NODEID;
    theData.uptime = millis();
    theData.temp = radio.readTemperature();//91.23; //it's hot!
 
    Serial.print("Sending struct (");
    Serial.print(sizeof(theData));
    Serial.print(" bytes) ... ");
    if (radio.sendWithRetry(GATEWAYID, (const void*)(&theData), sizeof(theData)))
      Serial.print(" ok!");
    else Serial.print(" nothing...");
    Serial.println();
    lastPeriod=currPeriod;
  }
 
  listenRF24();
 
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
    blinkStop=millis()+100;
    digitalWrite(LED, HIGH);
  }
 
  if (digitalRead(BUTTON)==LOW) {
    blinkStop=millis()+1000;
    digitalWrite(LED, HIGH);
  }
 
  if (millis()>blinkStop) {
    digitalWrite(LED, LOW);
  }
 
  if(millis()>timeReady){
    timeReady=millis()+2000;
    DateTime now = RTC.now();
 
    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(' ');
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
}
}
 
void Blink(byte PIN, int DELAY_MS)
{
  pinMode(PIN, OUTPUT);
  digitalWrite(PIN,HIGH);
  delay(DELAY_MS);
  digitalWrite(PIN,LOW);
}
 
void resetRFM69(){
  digitalWrite(RFM69_RESET, HIGH);
  delay(1);
  digitalWrite(RFM69_RESET, LOW);
  delay(10);
}
 
void isr_RF24(){
  waitRF24 = true;
}
 
void listenRF24() {
  if (waitRF24) {
    waitRF24 = false;
    if ( radio24.available() )
    {
      bool done = false;
      while (!done)
      {
        done = radio24.read( &sensor, sizeof(sensor) );
        if(sensor.Command == 0) {  
          Serial.print(sensor.SensorID);
          Serial.print("  ");
          Serial.print(sensor.ParamID);
          Serial.print("  ");
          Serial.print(sensor.ParamValue);
          Serial.print(" ");
          Serial.println(sensor.Comment);
        }
      }
    }
  }
}

 
#include <RFM69.h>
#include <SPI.h>
 
#define NODEID      1
#define NETWORKID   100
#define FREQUENCY   RF69_433MHZ //Match this with the version of your Moteino! (others: RF69_433MHZ, RF69_868MHZ)
#define KEY         "thisIsEncryptKey" //has to be same 16 characters/bytes on all nodes, not more not less!
#define LED         6
#define SERIAL_BAUD 115200
#define ACK_TIME    30  // # of ms to wait for an ack
 
#define RFM69_RESET 14
 
RFM69 radio;
bool promiscuousMode = false; //set to 'true' to sniff all packets on the same network
 
typedef struct {		
  int           nodeId; //store this nodeId
  unsigned long uptime; //uptime in ms
  float         temp;   //temperature maybe?
} Payload;
Payload theData;
 
void setup() {
  Serial.begin(SERIAL_BAUD);
  pinMode(RFM69_RESET, OUTPUT);
  pinMode(3, INPUT);
  resetRFM69();
  radio.setCS(9);
  //delay(10);
  radio.initialize(FREQUENCY,NODEID,NETWORKID);
 
  //radio.setHighPower(); //uncomment only for RFM69HW!
 
  radio.encrypt(KEY);
  radio.promiscuous(promiscuousMode);
  char buff[50];
  sprintf(buff, "\nListening at %d Mhz...", FREQUENCY==RF69_433MHZ ? 433 : FREQUENCY==RF69_868MHZ ? 868 : 915);
  Serial.println(buff);
}
 
byte ackCount=0;
void loop() {
  //process any serial input
  if (Serial.available() > 0)
  {
    char input = Serial.read();
    if (input == 'r') //d=dump all register values
      radio.readAllRegs();
    if (input == 'E') //E=enable encryption
      radio.encrypt(KEY);
    if (input == 'e') //e=disable encryption
      radio.encrypt(null);
    if (input == 'p')
    {
      promiscuousMode = !promiscuousMode;
      radio.promiscuous(promiscuousMode);
      Serial.print("Promiscuous mode ");Serial.println(promiscuousMode ? "on" : "off");
    }
 
    if (input == 'd') //d=dump flash area
    {
      Serial.println("Flash content:");
      int counter = 0;
 
      while(counter<=256){
        //Serial.print(flash.readByte(counter++), HEX);
        Serial.print('.');
      }
      //while(flash.busy());
      Serial.println();
    }
    if (input == 'D')
    {
      Serial.print("Deleting Flash chip content... ");
      //flash.chipErase();
      //while(flash.busy());
      Serial.println("DONE");
    }
    if (input == 'i')
    {
      Serial.print("DeviceID: ");
      //word jedecid = flash.readDeviceId();
      //Serial.println(jedecid, HEX);
    }
  }
 
  if (radio.receiveDone())
  {
    Serial.print('[');Serial.print(radio.SENDERID, DEC);Serial.print("] ");
    Serial.print(" [RX_RSSI:");Serial.print(radio.readRSSI());Serial.print("]");
    if (promiscuousMode)
	{
      Serial.print("to [");Serial.print(radio.TARGETID, DEC);Serial.print("] ");
    }
 
    if (radio.DATALEN != sizeof(Payload))
      Serial.print("Invalid payload received, not matching Payload struct!");
    else
    {
      theData = *(Payload*)radio.DATA; //assume radio.DATA actually contains our struct and not something else
      Serial.print(" nodeId=");
      Serial.print(theData.nodeId);
      Serial.print(" uptime=");
      Serial.print(theData.uptime);
      Serial.print(" temp=");
      Serial.print(theData.temp);
    }
 
    if (radio.ACK_REQUESTED)
    {
      byte theNodeID = radio.SENDERID;
      radio.sendACK();
      Serial.print(" - ACK sent.");
 
      // When a node requests an ACK, respond to the ACK
      // and also send a packet requesting an ACK (every 3rd one only)
      // This way both TX/RX NODE functions are tested on 1 end at the GATEWAY
      if (ackCount++%3==0)
      {
        Serial.print(" Pinging node ");
        Serial.print(theNodeID);
        Serial.print(" - ACK...");
        delay(3); //need this when sending right after reception .. ?
        if (radio.sendWithRetry(theNodeID, "ACK TEST", 8, 0))  // 0 = only 1 attempt, no retries
          Serial.print("ok!");
        else Serial.print("nothing");
      }
    }
    Serial.println();
    Blink(LED,3);
  }
}
 
void Blink(byte PIN, int DELAY_MS)
{
  pinMode(PIN, OUTPUT);
  digitalWrite(PIN,HIGH);
  delay(DELAY_MS);
  digitalWrite(PIN,LOW);
}
 
void resetRFM69(){
  digitalWrite(RFM69_RESET, HIGH);
  delay(1);
  digitalWrite(RFM69_RESET, LOW);
  delay(10);
}