It will not let me post it all as it's too long, here is the top half of the code above
/*
Copyright (C) 2011 James Coliz, Jr. <maniacbug@ymail.com>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
*/
/**
* Example of a sensor network
*
* This sketch demonstrates how to use the RF24Network library to
* manage a set of low-power sensor nodes which mostly sleep but
* awake regularly to send readings to the base.
*
* The example uses TWO sensors, a 'temperature' sensor and a 'voltage'
* sensor.
*
* To see the underlying frames being relayed, compile RF24Network with
* #define SERIAL_DEBUG.
*
* The logical node address of each node is set in EEPROM. The nodeconfig
* module handles this by listening for a digit (0-9) on the serial port,
* and writing that number to EEPROM.
*/
int rec;
#include <avr/pgmspace.h>
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#include <Tictocs.h>
#include <Button.h>
#include <TictocTimer.h>
#include "nodeconfig.h"
#include "sleep.h"
#include "S_message.h"
#include "printf.h"
// This is for git version tracking. Safe to ignore
#ifdef VERSION_H
#include "version.h"
#else
const char program_version[] = "Unknown";
#endif
// Pin definitions
#ifndef PINS_DEFINED
#define __PLATFORM__ "Getting Started board"
// Pins for radio
const int rf_ce = 9;
const int rf_csn = 10;
// Pins for sensors
const int temp_pin = A2;
const int voltage_pin = A3;
// Pins for status LED, or '0' for no LED connected
const int led_red = 0;
const int led_yellow = 0;
const int led_green = 0;
// Button to control modes
const int button_a = 4;
// What voltage is a reading of 1023?
const unsigned voltage_reference = 5 * 256; // 5.0V
#endif
RF24 radio(rf_ce,rf_csn);
RF24Network network(radio);
// Our node configuration
eeprom_info_t this_node;
// How many measurements to take. 64*1024 = 65536, so 64 is the max we can fit in a uint16_t.
const int num_measurements = 64;
// Sleep constants. In this example, the watchdog timer wakes up
// every 4s, and every single wakeup we power up the radio and send
// a reading. In real use, these numbers which be much higher.
// Try wdt_8s and 7 cycles for one reading per minute.> 1
const wdt_prescalar_e wdt_prescalar = wdt_4s;
const int sleep_cycles_per_transmission = 1;
// Non-sleeping nodes need a timer to regulate their sending interval
Timer send_timer(2000);
// Button controls functionality of the unit
Button ButtonA(button_a);
// Long-press button
Button ButtonLong(button_a,1000);
/**
* Convenience class for handling LEDs. Handles the case where the
* LED may not be populated on the board, so always checks whether
* the pin is valid before setting a value.
*/
class LED
{
private:
int pin;
public:
LED(int _pin): pin(_pin)
{
if (pin > 0)
{
pinMode(pin,OUTPUT);
digitalWrite(pin,LOW);
}
}
void write(bool state) const
{
if (pin > 0)
digitalWrite(pin,state?HIGH:LOW);
}
void operator=(bool state)
{
write(state);
}
};
/**
* Startup LED sequence. Lights up the LEDs in sequence first, then dims
* them in the same sequence.
*/
class StartupLEDs: public Timer
{
private:
const LED** leds;
const LED** current;
const LED** end;
bool state;
protected:
virtual void onFired(void)
{
(*current)->write(state);
++current;
if ( current >= end )
{
if ( state )
{
state = false;
current = leds;
}
else
disable();
}
}
public:
StartupLEDs(const LED** _leds, int _num): Timer(250), leds(_leds), current(_leds), end(_leds+_num), state(true)
{
}
};
/**
* Calibration LED sequence. Flashes all 3 in unison
*/
class CalibrationLEDs: public Timer
{
const LED** leds;
const LED** end;
bool state;
protected:
void write()
{
const LED** current = end;
while (current-- > leds)
(*current)->write(state);
}
virtual void onFired()
{
state = ! state;
write();
}
public:
CalibrationLEDs(const LED** _leds, int _num, unsigned long duration = 500): Timer(duration), leds(_leds), end(_leds+_num), state(false)
{
Timer::disable();
}
void begin()
{
Updatable::begin();
}
void reset()
{
state = true;
write();
Timer::reset();
}
void disable()
{
state = false;
write();
Timer::disable();
}
};
LED Red(led_red), Yellow(led_yellow), Green(led_green);
const LED* leds[] = { &Red, &Yellow, &Green };
const int num_leds = sizeof(leds)/sizeof(leds[0]);
StartupLEDs startup_leds(leds,num_leds);
CalibrationLEDs calibration_leds(leds,num_leds);
// Nodes in test mode do not sleep, but instead constantly try to send
bool test_mode = false;
// Nodes in calibration mode are looking for temperature calibration
bool calibration_mode = false;
void setup(void)
{
//
// Print preamble
//
Serial.begin(57600);
printf_begin();
printf_P(PSTR("\n\rRF24Network/examples/sensornet/\n\r"));
printf_P(PSTR("PLATFORM: " __PLATFORM__ "\n\r"),program_version);
printf_P(PSTR("VERSION: %s\n\r"),program_version);
//
// Pull node address out of eeprom
//
// Which node are we?
this_node = nodeconfig_read();
//
// Prepare sleep parameters
//
// Only the leaves sleep. Nodes 01-05 are presumed to be relay nodes.
if ( ! this_node.relay )
Sleep.begin(wdt_prescalar,sleep_cycles_per_transmission);
//
// Set up board hardware
//
ButtonA.begin();
ButtonLong.begin();
// Sensors use the stable internal 1.1V voltage
#ifdef INTERNAL1V1
analogReference(INTERNAL1V1);
#else
analogReference(INTERNAL);
#endif
// Prepare the startup sequence
send_timer.begin();
startup_leds.begin();
calibration_leds.begin();
//
// Bring up the RF network
//
SPI.begin();
radio.begin();
network.begin(/*channel*/ 92, /*node address*/ this_node.address);
}
Show Posts
| Arduino Forum :: Members :: Jimster