void forwardPacket() {
// make copies, because rf12_* will change in next rf12_recvDone
byte hdr = rf12_hdr, len = rf12_len;
if (config.multi_node) {
// special case: insert original header (src node ID) as first data byte
// careful with max-length packets in multi-node mode: drop last byte!
// this is necessary because we're inserting an extra byte at the front
if (len >= sizeof buf)
--len;
buf[0]= hdr;
}
memcpy(buf + config.multi_node, (void*) rf12_data, len);
// save these for later as well, same reason as above
byte wantsAck = RF12_WANTS_ACK, ackReply = RF12_ACK_REPLY;
if (config.acks_enable) {
// if we're not supposed to send back ACKs, then don't ask for 'em
wantsAck = false;
hdr &= ~ RF12_HDR_ACK;
}
Serial.print("\n[*]");
// switch to outgoing group
rf12_initialize(config.out_node, code2type(config.freq), config.out_group);
// send our packet, once possible
while (!rf12_canSend())
rf12_recvDone();
rf12_sendStart(hdr, buf, len + config.multi_node, 1);
if (wantsAck) {
ackTimer.set(100); // wait up to 100 ms for a valid ack packet
wantsAck = false;
while (!wantsAck && !ackTimer.poll())
wantsAck = rf12_recvDone() && rf12_crc == 0;
}
// switch back to incoming group
rf12_initialize(config.in_node, code2type(config.freq), config.in_group);
if (wantsAck) {
// copy ack packet to our temp buffer, same reason as above
len = rf12_len;
memcpy(buf, (void*) rf12_data, rf12_len);
// send ACK packet back, once possible
while (!rf12_canSend())
rf12_recvDone();
rf12_sendStart(ackReply, buf, len, 1);
}
}
static void loadConfig() {
byte* p = (byte*) &config;
for (byte i = 0; i < sizeof config; ++i)
p[i] = eeprom_read_byte((byte*) i);
// if loaded config is not valid, replace it with defaults
if (config.magic != 123) {
config.magic = 123;
config.freq = 8;
config.in_group = 5;
config.in_node = 31;
config.out_group = 6;
config.out_node = 30;
config.acks_enable = 1; // 1 to support round-trip ACK relaying
config.multi_node = 1; // 1 to insert orig header byte when relaying
}
config.magic = 123;
config.freq = 8;
config.in_group = 5;
config.in_node = 31;
config.out_group = 5;
config.acks_enable = 0;
config.multi_node = 0;
showConfig();
rf12_initialize(config.in_node, code2type(config.freq), config.in_group);
}
void setup() {
for (int i = 0; i < NUM_COUNTERS; i++) {
counterState[i] = 0;
lastCounterState[i] = 0;
lastCounterMillis[i] = 0;
// initialize the button pin as a input:
pinMode(counterPin[i], INPUT);
digitalWrite(counterPin[i], HIGH);
}
// initialize the LED as an output:
pinMode(LED1, OUTPUT);
rf12_initialize(NODE_ID, RF12_868MHZ, NETGROUP);
rf12_encrypt(RF12_EEPROM_EKEY);
#ifdef DEBUG_ENABLED
// initialize serial communication:
Serial.begin(57600);
Serial.println("[Alis Smartmeter - Transmitter]");
wdt_enable(WDTO_1S);
#else
wdt_enable(WDTO_60MS); // sending a packet of 64bit length takes about ??ms
#endif
}
AQERF_Remote::AQERF_Remote(uint8_t * mac){
transmit_interval = AQERF_SENSOR_DATUM_TRANSMIT_INTERVAL;
memcpy(unit_address, mac, 6);
rf12_initialize('A', RF12_433MHZ);
//TODO: Read the last known Base Address out of EEPROM into base_station_address
eeprom_read_block(base_station_address, (const void *) AQERF_EEPROM_LAST_KNOWN_BASE_ADDRESS, 6);
}
int main(void) {
cpu_init();
P1IFG = 0x00;
uart_init();
delayMs(1000);
__enable_interrupt();
/* Initialize RFM-module */
rf12_initialize(2, RF12_433MHZ, 33);
uint8_t c = 0;
uart_puts("Hello\n");
uint8_t payload[1];
bool sendAck = false;
while (true) {
if (rf12_recvDone() && rf12_crc == 0) {
switch(rf12_data[0]) {
case PACKET_BAT_LEVEL:
uart_puts("BATTERY LEVEL: ");
uart_puts(rf12_data+1);
break;
case PACKET_SIGNAL:
uart_puts("SIGNAL: ");
uart_puts(rf12_data+1);
break;
default:
uart_puts("UNKNOWN");
break;
}
uart_putc('\n');
}
if (uart_getc(&c)) {
if( c == 'I' ) {
uart_putc('O');
uart_putc('\n');
}
}
/* Power down */
// Only power down, if there is nothing to do
if( !isReceiving && rxstate == TXRECV) {
__bis_SR_register(LPM3_bits | GIE);
}
}
return 0;
}
void tools_init_rf24(byte myNodeID, byte network){
delay(100);
rf12_initialize(myNodeID,freq,network); // Initialize RFM12 with settings defined above
rf12_sleep(0); // Put the RFM12 to sleep
rf12_control(0xC691); //bitrate 2.395kbps
// rf12_control(0xC688); // bitrate 4.789kbps
// rf12_control(0xC623); // data rate 9.579kbps
rf12_control(0x94C2); // Rx control 67 kHz bandwidth
rf12_control(0x9820); // Tx control 45 kHz deviation
PRR = bit(PRTIM1); // only keep timer 0 goingh
tools_disable_adc();
}
void sendTempPacket() {
digitalWrite(PIN_LED, HIGH);
#define N 512
#define PIN_TEMP1 2
#define PIN_TEMP2 3
long t1 = 0;
long t2 = 0;
Serial.print("[");
for (int i = 0; i < N; i++) {
if (rf12_recvDone() && rf12_crc == 0) {
forwardPacket();
}
t1 += analogRead(PIN_TEMP1);
t2 += analogRead(PIN_TEMP2);
}
Serial.print(t1 / N * 3300 / 1024);
Serial.print(" ");
Serial.print(t2 / N * 3300 / 1024);
Serial.print(" ");
//long t = ((l2 - l1) * 3300) / 4096;
long t = (t2 - t1) * 3300 * 10 / N / 1024;
Serial.print(t);
rf12_initialize(config.out_node, code2type(config.freq), config.out_group);
Serial.print(" *");
payload[4] = 1;
*((int*)(payload + 5)) = (int) t;
// send our packet, once possible
while (!rf12_canSend())
rf12_recvDone();
Serial.print(" *");
rf12_sendStart(0, payload, sizeof payload, 1);
Serial.println("]");
digitalWrite(PIN_LED, LOW);
}
void RF12Module::setBand(byte band) {
this->nodeId &= 0x1F;
this->nodeId |= (band << 6);
rf12_initialize(nodeId, band, group);
}
AQERF_Base::AQERF_Base(uint8_t * mac){
memcpy(base_station_address, mac, 6);
rf12_initialize('A', RF12_433MHZ); // 'A' is arbitrary, doesn't matter for broadcast
}
//Transceiver functions:
void OpenGardenClass::initRF(void){
rf12_initialize(myNodeID,RF12_433MHZ,100); // (GatewayNodeID,freq,network)
rf12_recvDone();
}
void setup(){
// cli(); // Turn all interrupts off!
sei(); // Turn interrupts on.
_delay_ms(4000); // Wait for startup!
// SPI CS INIT - set all CS lines high!
DDR_RFM_CS |= (1 << BIT_RFM_CS); // Set RFM12B CS to output
PORT_RFM_CS |= (1 << BIT_RFM_CS); // Pull RFM12B CS high
DDR_MEM_SS |= (1 << BIT_MEM_SS); // Set memory CS to output
PORT_MEM_SS |= (1 << BIT_MEM_SS); // Pull memory CS high
DDR_ETH_SS |= (1 << BIT_ETH_SS); // Set Ethernet CS to output
PORT_ETH_SS |= (1 << BIT_ETH_SS); // Pull Ethernet CS high
// SPI CS INIT - set all CS lines high!
// SET ALL LED TO OUTPUT
LED_433RECEIVE_DDR |= (1 << LED_433RECEIVE_BIT); // set output
LED_433SEND_DDR |= (1 << LED_433SEND_BIT); // set output
LED_868RECEIVE_DDR |= (1 << LED_868RECEIVE_BIT); // set output
LED_868SEND_DDR |= (1 << LED_868SEND_BIT); // set output
LED_DCF77_DDR |= (1 << LED_DCF77_BIT); // set output
LED_LCD_DDR |= (1 << LED_LCD_BIT); // set output
// SET ALL LED TO OUTPUT
// TEST LEDS
blinkAllLeds(true); _delay_ms(1000); blinkAllLeds(false);
_delay_ms(500); blinkAllLeds(true); _delay_ms(1000); blinkAllLeds(false);
// TEST LEDS
/* Initialize UART */
uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU));
/* Initialize RFM12B*/
rf12_initialize(NODEID, RF12_868MHZ, NETWORKID); // see http://tools.jeelabs.org/rfm12b
rf12_control(0xC040); // set low-battery level to 2.2V i.s.o. 3.1V
// Initialize library
millis_init();
LED_LCD_PORT |= (1 << LED_LCD_BIT); // set output
/*
GLCD_IO_PIN_A0_1();
GLCD_IO_PIN_RW_1();
GLCD_IO_PIN_E_1();
GLCD_IO_DATA_DIR_OUTPUT();
GLCD_IO_DATA_OUTPUT(0b11111111);
*/
//glcd.init();
//glcd.setFont(&proportional_font);
//glcd.clearDisplay();
//uint8_t ret = glcd.drawPixel(GLCD_INDICATOR_2, 48, 2);
//uart0_putc(ret);
//glcd.drawLine(1, 1, 100,100, GLCD_COLOR_FILLED);
glcd.init();
glcd.setFont(&proportional_font);
glcd.clearDisplay();
log_s("ISA GATEWAY \n\r");
log_s("STARTUP OK! \n\r");
}
