int main() {
_delay_ms(100); //little delay for the rfm12 to initialize properly
rfm12_init(); //init the RFM12
_delay_ms(100);
init_lcd();
init_timer();
sei();
set_orientation(East);
put_string((char*)"Initialising...\n");
char random[120] = "hello aaron rowland, this is a string which should ";
char test[26] = "0123456789012345678901234";
int i = 23456;
char Rpacket[150];
SendPacket(THISDEVICE, random);
// while(1) {
// if(RecievePacket(Rpacket)) {
// put_string("PACKET RECEIVED!!!!!\n");
// put_string(Rpacket);
// }
// }
return 0;
}
int
main(void)
{
uint8_t teststring[] = "teststring\r\n";
uint8_t packettype = 0xEE;
uart_init9600();
rfm12_init();
sei();
while(1)
{
#ifdef SENDER
rfm12_tx (sizeof(teststring), packettype, teststring);
#else
rf
rfm12_rx (sizeof(teststring), packettype, teststring);
teststring[ sizeof(teststring)-1 ] = 0;
printf( "rx: %s\r", teststring );
#endif
rfm12_tick();
}
return 0;
}
int main (void) {
_delay_ms(2000);
sei();
uart_init(UART_BAUD_SELECT_DOUBLE_SPEED(UART_BAUD_RATE, F_CPU));
uart_puts("\r\nrfm12trx http://schoar.de/tinkering/rfm12trx\r\n");
rfm12_init();
rfm12_setfreq(RFM12_FREQ(434.32));
rfm12_setbandwidth(RxBW200, LNA_6, RSSI_79);
rfm12_setbaud(19200);
rfm12_setpower(PWRdB_0, TxBW105);
while(1) {
read();
if (tx_ready != 0) {
tx();
} else {
rx();
}
}
}
int main(void)
{
timeCount = 0;
hardwareInit();
uart0_init(BAUD_SETTING);
/* Initialise timer to divide by 1025, giving 32ms time tick */
timer0Init(0,5);
rfm12_init();
wdtInit();
sei();
indx = 0;
for(;;)
{
wdt_reset();
uint8_t sendMessage = false;
uint16_t character = uart0_getc();
/* Wait for a serial incoming message to be built. */
if (character != UART_NO_DATA)
{
inBuf[indx++] = (uint8_t)(character & 0xFF);
/* Signal to transmit if a CR was received, or string too long. */
sendMessage = ((indx > MAX_MESSAGE) || (character == 0x0D));
}
/* Send a transmission if message is ready to send, or something was
received and time waited is too long. */
if (sendMessage || (timeCount++ > TIMEOUT))
{
/* Wait for the transmit buffer to be freed and message loaded. */
if ((indx > 0) && (rfm12_tx(indx, 0, inBuf) != RFM12_TX_OCCUPIED))
indx = 0;
timeCount = 0;
}
rfm12_tick();
/* If an RF incoming message has been received, take it from the buffer one
character at a time and transmit via the serial port. */
if (rfm12_rx_status() == STATUS_COMPLETE)
{
uint8_t *bufferContents = rfm12_rx_buffer();
uint8_t messageLength = rfm12_rx_len();
uint8_t i;
for (i=0;i<messageLength;i++)
{
uart0_putc(bufferContents[i]);
}
/* Clear the "in use" status of the receive buffer to be available for
rfm12lib. */
rfm12_rx_clear();
}
}
}
int main(void)
{
uint8_t i;
cli();
MCUSR = 0;
wdt_disable();
//TODO replace by an ana comp polling loop
_delay_ms(10);
setup_datastructs();
setup_led();
setup_ar_uart();
setup_adc();
setup_pulse_input();
setup_analog_comparator();
setup_timer0();
setup_timer1();
// initialize the CTRL buffers
ctrlInit();
// initialize the SPI in slave mode
setup_spi(SPI_MODE_0, SPI_MSB, SPI_INTERRUPT, SPI_SLAVE);
// initialize the Si4421/RFM12 radio and buffers
rfm12_init();
// the clk/8 fuse bit is set
clock_prescale_set(clock_div_1);
FLAG_CLR_ICF1();
sei();
for(;;) {
if (spi_status & SPI_NEW_CTRL_MSG) {
ctrlDecode();
spi_status &= ~SPI_NEW_CTRL_MSG;
}
for (i = 0; i < max_analog_sensors; i++) {
if (state[i].flags & STATE_POWER_CALC) {
calculate_power(&state[i]);
state[i].flags &= ~STATE_POWER_CALC;
state[i].flags |= STATE_POWER;
}
}
rfm12_tick();
}
return 0;
}
int main (void) {
/*
* SPI-Modul initialisieren */
spi_init();
/*
* Funkmodul initialisieren */
rfm12_init();
rfm12_rx_on();
/*
* CAN-Bus initialisieren */
mcp2515_init();
/* Interrupts initialisieren */
interrupt_init();
/*
* Hauptprogramm */
while (1) {
if (rfm_new_data) {
rfm_new_data = 0;
cli();
struct rfm_message tmp_rfm_message;
if (rfm_copy_data(&tmp_rfm_message)) {
struct can_message tmp_can_message;
tmp_can_message.typ = tmp_rfm_message.typ;
tmp_can_message.rtr = tmp_rfm_message.rtr;
tmp_can_message.id = tmp_rfm_message.id;
tmp_can_message.length = tmp_rfm_message.length;
for (uint8_t i=0; i<8; i++) {
tmp_can_message.data[i] = tmp_rfm_message.data[i];
}
can_send_message(&tmp_can_message);
}
sei();
}
if (rfm_crc_error != rfm_crc_error_last) {
struct can_message tmp_can_message;
tmp_can_message.typ = Einzelmeldung;
tmp_can_message.id = Funkkoppler_CRC_Error;
tmp_can_message.length = Laenge_Einzelmeldung;
tmp_can_message.data[0] = rfm_crc_error;
can_send_message(&tmp_can_message);
rfm_crc_error_last = rfm_crc_error;
}
set_sleep_mode(SLEEP_MODE_STANDBY);
sleep_mode();
}
}
int main () {
uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,16000000L) );
_delay_ms(100);
rfm12_init();
sei();
uart_puts("String stored in SRAM\n");
for(;;){
send_data();
_delay_ms(5000);
}
}
/* Initialise board */
void bugone_init(application_t* applications) {
char buf[16];
uint8_t i;
uint8_t nb_devices=0;
application_t *app=applications;
led_init();
uart_init();
rfm12_init();
config_init();
/* Count how many devices are declared */
while (!((app->init == NULL) &&
(app->get == NULL) &&
(app->set == NULL) &&
(app->cfg == NULL))) {
nb_devices++;
app++;
}
set_apps(applications,nb_devices);
uart_putstr_P(PSTR("Firmware version "));
uart_putstr_P(PSTR(FWVERSION_STR));
uart_putstr_P(PSTR("\r\n"));
uart_putstr_P(PSTR("Node address : "));
itoa(config.address,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
for (i=0 ; i < nb_devices; i++) {
uart_putc('*');
if (applications[i].init == NULL) { continue; }
applications[i].init(applications[i].cfg);
}
timer1_init();
sei();
uart_putstr_P(PSTR("AVR init complete\r\n"));
//clr_output(LED1);
//clr_output(LED2);
}
void init()
{
#if 0
tft::init();
tftout = tft::devout();
#endif
#if 1
uart0_init();
stdout = uart0_fd();
stdin = uart0_fd();
#endif
_delay_ms(1000);
rfm12_init();
_delay_ms(1000);
sei();
sampler_init();
pwm2_init();
sampler_enable(1);
pwm2_enable(1);
}
int main(void)
{
#ifdef BOOTLOADER_SUPPORT
_IVREG = _BV(IVCE); /* prepare ivec change */
_IVREG = _BV(IVSEL); /* change ivec to bootloader */
#endif
/* Clear the MCUSR Register to avoid endless wdreset loops */
unsigned char reset_reason = 0;
#ifdef MCUCSR
reset_reason = MCUCSR;
MCUCSR = 0;
#else
#ifdef MCUSR
reset_reason = MCUSR;
MCUSR = 0;
#endif
#endif
/* Default DDR Config */
#if IO_HARD_PORTS == 4 && DDR_MASK_A != 0
DDRA = DDR_MASK_A;
#endif
#if DDR_MASK_B != 0
DDRB = DDR_MASK_B;
#endif
#if DDR_MASK_C != 0
DDRC = DDR_MASK_C;
#endif
#if DDR_MASK_D != 0
DDRD = DDR_MASK_D;
#endif
#if IO_HARD_PORTS == 6
#if DDR_MASK_E != 0
DDRE = DDR_MASK_E;
#endif
#if DDR_MASK_F != 0
DDRF = DDR_MASK_F;
#endif
#endif
#ifdef STATUSLED_POWER_SUPPORT
PIN_SET(STATUSLED_POWER);
#endif
//FIXME: zum ethersex meta system hinzufügen, aber vor allem anderem initalisieren
debug_init();
debug_printf("Ethersex " VERSION_STRING " (Debug mode)\n");
#ifdef DEBUG_RESET_REASON
if (bit_is_set(reset_reason, BORF)) debug_printf("reset: Brown-out\n");
else if (bit_is_set(reset_reason, PORF)) debug_printf("reset: Power on\n");
else if (bit_is_set(reset_reason, WDRF)) debug_printf("reset: Watchdog\n");
else if (bit_is_set(reset_reason, EXTRF)) debug_printf("reset: Extern\n");
else debug_printf("reset: Unknown\n");
#endif
#ifdef BOOTLOADER_SUPPORT
/* disable interrupts */
cli();
#else
/* enable interrupts */
sei();
#endif //BOOTLOADER_SUPPORT
#ifdef USE_WATCHDOG
debug_printf("enabling watchdog\n");
#ifdef DEBUG
/* for debugging, test reset cause and jump to bootloader */
if (MCUSR & _BV(WDRF)) {
debug_printf("bootloader...\n");
jump_to_bootloader();
}
#endif
/* set watchdog to 2 seconds */
wdt_enable(WDTO_2S);
wdt_kick();
#else //USE_WATCHDOG
debug_printf("disabling watchdog\n");
wdt_disable();
#endif //USE_WATCHDOG
#ifdef ADC_SUPPORT
/* ADC Prescaler to 64 */
ADCSRA = _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1);
/* ADC set Voltage Reference to extern*/
/* FIXME: move config to the right place */
ADMUX = ADC_REF; //_BV(REFS0) | _BV(REFS1);
#endif
#if defined(RFM12_SUPPORT) || defined(ENC28J60_SUPPORT) \
|| defined(DATAFLASH_SUPPORT)
spi_init();
#endif
ethersex_meta_init();
#ifdef RFM12_SUPPORT
rfm12_init();
#ifdef TEENSY_SUPPORT
cli ();
rfm12_trans (0xa620); /* rfm12_setfreq(RFM12FREQ(433.92)); */
rfm12_trans (0x94ac); /* rfm12_setbandwidth(5, 1, 4); */
#ifdef RFM12_IP_SUPPORT
rfm12_trans (0xc610); /* rfm12_setbaud(192); */
rfm12_trans (0x9820); /* rfm12_setpower(0, 2); */
rfm12_rxstart();
#endif /* RFM12_IP_SUPPORT */
sei ();
#else /* TEENSY_SUPPORT */
rfm12_setfreq(RFM12FREQ(433.92));
rfm12_setbandwidth(5, 1, 4);
#ifdef RFM12_IP_SUPPORT
rfm12_setbaud(CONF_RFM12_BAUD / 100);
rfm12_setpower(0, 2);
rfm12_rxstart();
#endif /* RFM12_IP_SUPPORT */
#endif /* not TEENSY_SUPPORT */
#endif /* RFM12_SUPPORT */
/* must be called AFTER all other initialization */
#ifdef PORTIO_SUPPORT
portio_init();
#elif defined(NAMED_PIN_SUPPORT)
np_simple_init();
#endif
#ifdef ENC28J60_SUPPORT
debug_printf("enc28j60 revision 0x%x\n", read_control_register(REG_EREVID));
debug_printf("mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
uip_ethaddr.addr[0],
uip_ethaddr.addr[1],
uip_ethaddr.addr[2],
uip_ethaddr.addr[3],
uip_ethaddr.addr[4],
uip_ethaddr.addr[5]
);
#endif
#ifdef STATUSLED_BOOTED_SUPPORT
PIN_SET(STATUSLED_BOOTED);
#endif
ethersex_meta_startup();
/* main loop */
while(1) {
wdt_kick();
ethersex_meta_mainloop();
#ifdef SD_READER_SUPPORT
if (sd_active_partition == NULL) {
if (! sd_try_init ())
vfs_sd_try_open_rootnode ();
wdt_kick();
}
#endif
#ifndef BOOTLOAD_SUPPORT
if(status.request_bootloader) {
#ifdef CLOCK_CRYSTAL_SUPPORT
_TIMSK_TIMER2 &= ~_BV(TOIE2);
#endif
#ifdef DCF77_SUPPORT
ACSR &= ~_BV(ACIE);
#endif
cli();
jump_to_bootloader();
}
#ifndef TEENSY_SUPPORT
if(status.request_wdreset) {
cli();
wdt_enable(WDTO_15MS);
for(;;);
}
#endif
if(status.request_reset) {
cli();
void (* reset)(void) = NULL;
reset();
}
#endif
}
}
int16_t
parse_cmd_rfm12_reinit(char *cmd, char *output, uint16_t len)
{
rfm12_init();
return ECMD_FINAL_OK;
}
int main(void)
{
uint8_t aes_key_nr;
uint8_t loop = 0;
uint8_t loop2 = 0;
// delay 1s to avoid further communication with uart or RFM12 when my programmer resets the MC after 500ms...
_delay_ms(1000);
util_init();
check_eeprom_compatibility(DEVICETYPE_BASESTATION);
request_queue_init();
// read packetcounter, increase by cycle and write back
packetcounter = e2p_generic_get_packetcounter() + PACKET_COUNTER_WRITE_CYCLE;
e2p_generic_set_packetcounter(packetcounter);
// read device specific config
aes_key_count = e2p_basestation_get_aeskeycount();
device_id = e2p_generic_get_deviceid();
uart_init();
UART_PUTS("\r\n");
UART_PUTF4("smarthomatic Base Station v%u.%u.%u (%08lx)\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_HASH);
UART_PUTS("(c) 2012..2014 Uwe Freese, www.smarthomatic.org\r\n");
UART_PUTF("Device ID: %u\r\n", device_id);
UART_PUTF("Packet counter: %lu\r\n", packetcounter);
UART_PUTF("AES key count: %u\r\n", aes_key_count);
UART_PUTS("Waiting for incoming data. Press h for help.\r\n\r\n");
led_blink(500, 500, 3);
rfm12_init();
sei();
// ENCODE TEST (Move to unit test some day...)
/*
uint8_t testlen = 32;
uint8_t aes_key_num = 0;
memset(&bufx[0], 0, sizeof(bufx));
bufx[0] = 0xff;
bufx[1] = 0xb0;
bufx[2] = 0xa0;
bufx[3] = 0x3f;
bufx[4] = 0x01;
bufx[5] = 0x70;
bufx[6] = 0x00;
bufx[7] = 0x0c;
bufx[8] = 0xa8;
bufx[9] = 0x00;
bufx[10] = 0x20;
bufx[20] = 0x20;
eeprom_read_block (aes_key, (uint8_t *)(EEPROM_AESKEYS_BYTE + aes_key_num * 32), 32);
UART_PUTS("Using AES key ");
print_bytearray((uint8_t *)aes_key, 32);
UART_PUTS("Before encryption: ");
print_bytearray(bufx, testlen);
uint8_t aes_byte_count = aes256_encrypt_cbc(bufx, testlen);
UART_PUTF("byte count = %u\r\n", aes_byte_count);
UART_PUTS("After encryption: ");
print_bytearray(bufx, aes_byte_count);
aes256_decrypt_cbc(bufx, aes_byte_count);
UART_PUTS("After decryption: ");
print_bytearray(bufx, testlen);
while(1);
*/
while (42)
{
if (rfm12_rx_status() == STATUS_COMPLETE)
{
uint8_t len = rfm12_rx_len();
if ((len == 0) || (len % 16 != 0))
{
UART_PUTF("Received garbage (%u bytes not multiple of 16): ", len);
print_bytearray(bufx, len);
}
else // try to decrypt with all keys stored in EEPROM
{
bool crcok = false;
for (aes_key_nr = 0; aes_key_nr < aes_key_count ; aes_key_nr++)
{
memcpy(bufx, rfm12_rx_buffer(), len);
/*if (aes_key_nr == 0)
{
UART_PUTS("Before decryption: ");
print_bytearray(bufx, len);
}*/
e2p_basestation_get_aeskey(aes_key_nr, aes_key);
//UART_PUTS("Trying AES key 2 ");
//print_bytearray((uint8_t *)aes_key, 32);
aes256_decrypt_cbc(bufx, len);
//UART_PUTS("Decrypted bytes: ");
//print_bytearray(bufx, len);
crcok = pkg_header_check_crc32(len);
if (crcok)
{
//UART_PUTS("CRC correct, AES key found!\r\n");
UART_PUTF("Received (AES key %u): ", aes_key_nr);
print_bytearray(bufx, len);
decode_data(len);
break;
}
}
if (!crcok)
{
UART_PUTS("Received garbage (CRC wrong after decryption): ");
memcpy(bufx, rfm12_rx_buffer(), len);
print_bytearray(bufx, len);
}
UART_PUTS("\r\n");
}
//uart_hexdump((char *)bufcontents, rfm12_rx_len());
//UART_PUTS("\r\n");
// tell the implementation that the buffer can be reused for the next data.
rfm12_rx_clear();
}
// send data, if waiting in send buffer
if (send_data_avail)
{
uint8_t i;
// set AES key nr
aes_key_nr = hex_to_uint8((uint8_t *)cmdbuf, 1);
//UART_PUTF("AES KEY = %u\r\n", aes_key_nr);
// init packet buffer
memset(&bufx[0], 0, sizeof(bufx));
// set message type
uint8_t message_type = hex_to_uint8((uint8_t *)cmdbuf, 3);
pkg_header_set_messagetype(message_type);
pkg_header_adjust_offset();
//UART_PUTF("MessageType = %u\r\n", message_type);
uint8_t string_offset_data = 0;
/*
UART_PUTS("sKK00RRRRGGMM.............Get\r\n");
UART_PUTS("sKK01RRRRGGMMDD...........Set\r\n");
UART_PUTS("sKK02RRRRGGMMDD...........SetGet\r\n");
UART_PUTS("sKK08GGMMDD...............Status\r\n");
UART_PUTS("sKK09SSSSPPPPPPEE.........Ack\r\n");
UART_PUTS("sKK0ASSSSPPPPPPEEGGMMDD...AckStatus\r\n");
*/
// set header extension fields to the values given as hex string in the user input
switch (message_type)
{
case MESSAGETYPE_GET:
case MESSAGETYPE_SET:
case MESSAGETYPE_SETGET:
pkg_headerext_common_set_receiverid(hex_to_uint16((uint8_t *)cmdbuf, 5));
pkg_headerext_common_set_messagegroupid(hex_to_uint8((uint8_t *)cmdbuf, 9));
pkg_headerext_common_set_messageid(hex_to_uint8((uint8_t *)cmdbuf, 11));
string_offset_data = 12;
break;
case MESSAGETYPE_STATUS:
pkg_headerext_common_set_messagegroupid(hex_to_uint8((uint8_t *)cmdbuf, 5));
pkg_headerext_common_set_messageid(hex_to_uint8((uint8_t *)cmdbuf, 7));
string_offset_data = 8;
break;
case MESSAGETYPE_ACK:
pkg_headerext_common_set_acksenderid(hex_to_uint16((uint8_t *)cmdbuf, 5));
pkg_headerext_common_set_ackpacketcounter(hex_to_uint24((uint8_t *)cmdbuf, 9));
pkg_headerext_common_set_error(hex_to_uint8((uint8_t *)cmdbuf, 15));
// fallthrough!
case MESSAGETYPE_ACKSTATUS:
pkg_headerext_common_set_messagegroupid(hex_to_uint8((uint8_t *)cmdbuf, 17));
pkg_headerext_common_set_messageid(hex_to_uint8((uint8_t *)cmdbuf, 19));
string_offset_data = 20;
break;
}
uint8_t data_len_raw = 0;
// copy message data, which exists in all packets except in Get and Ack packets
if ((message_type != MESSAGETYPE_GET) && (message_type != MESSAGETYPE_ACK))
{
uint8_t data_len_raw = (strlen(cmdbuf) - 1 - string_offset_data) / 2;
//UART_PUTF("Data bytes = %u\r\n", data_len_raw);
uint8_t start = __HEADEROFFSETBITS / 8;
uint8_t shift = __HEADEROFFSETBITS % 8;
// copy message data, using __HEADEROFFSETBITS value and string_offset_data
for (i = 0; i < data_len_raw; i++)
{
uint8_t val = hex_to_uint8((uint8_t *)cmdbuf, string_offset_data + 2 * i + 1);
array_write_UIntValue(start + i, shift, 8, val, bufx);
}
}
// round packet length to x * 16 bytes
uint8_t packet_len = ((uint16_t)__HEADEROFFSETBITS + (uint16_t)data_len_raw * 8) / 8;
packet_len = ((packet_len - 1) / 16 + 1) * 16;
// send packet which doesn't require an acknowledge immediately
if ((message_type != MESSAGETYPE_GET) && (message_type != MESSAGETYPE_SET) && (message_type != MESSAGETYPE_SETGET))
{
send_packet(aes_key_nr, packet_len);
}
else // enqueue request (don't send immediately)
{
// header size = 9 bytes!
if (queue_request(pkg_headerext_common_get_receiverid(), message_type, aes_key_nr, bufx + 9, packet_len - 9))
{
UART_PUTF("Request added to queue (%u bytes packet).\r\n", packet_len);
}
else
{
UART_PUTS("Warning! Request queue full. Packet will not be sent.\r\n");
}
print_request_queue();
}
// clear cmdbuf to receive more input from UART
send_data_avail = false;
rfm12_tick();
led_blink(200, 0, 1);
}
// flash LED every second to show the device is alive
if (loop == 50)
{
led_blink(10, 10, 1);
loop = 0;
request_t* request = find_request_to_repeat(packetcounter + 1);
if (request != 0) // if request to repeat was found in queue
{
UART_PUTS("Repeating request.\r\n");
send_packet((*request).aes_key, (*request).data_bytes + 9); // header size = 9 bytes!
print_request_queue();
}
// Auto-send something for debugging purposes...
if (loop2 == 50)
{
//strcpy(cmdbuf, "s000102828300");
//send_data_avail = true;
loop2 = 0;
}
else
{
loop2++;
}
}
else
{
_delay_ms(20);
}
rfm12_tick();
loop++;
process_rxbuf();
if (uart_timeout > 0)
{
uart_timeout--;
if (uart_timeout == 0)
{
UART_PUTS("*** UART user timeout. Input was ignored. ***\r\n");
}
}
}
// never called
// aes256_done(&aes_ctx);
}
int main ( void )
{
uint8_t aes_key_nr;
uint8_t loop = 0;
uint8_t loop2 = 0;
uint8_t data[22];
sbi(LED_DDR, LED_PIN);
// delay 1s to avoid further communication with uart or RFM12 when my programmer resets the MC after 500ms...
_delay_ms(1000);
request_queue_init();
// read packetcounter, increase by cycle and write back
packetcounter = eeprom_read_dword((uint32_t*)EEPROM_POS_PACKET_COUNTER) + PACKET_COUNTER_WRITE_CYCLE;
eeprom_write_dword((uint32_t*)0, packetcounter);
uart_init(true);
UART_PUTS ("\r\n");
UART_PUTS ("Open Home Control Base Station V1.0\r\n");
UART_PUTS ("(c) 2012 Uwe Freese, www.open-home-control.com\r\n");
UART_PUTF ("Packet counter: %lu\r\n", packetcounter);
UART_PUTS ("Waiting for incoming data. Press h for help.\r\n");
rfm12_init();
sei();
// ENCODE TEST
/*
uint8_t testlen = 64;
eeprom_read_block (aes_key, (uint8_t *)EEPROM_POS_AES_KEY, 32);
UART_PUTS("Using AES key ");
printbytearray((uint8_t *)aes_key, 32);
UART_PUTS("Before encryption: ");
printbytearray(bufx, testlen);
unsigned long crc = crc32(bufx, testlen);
UART_PUTF("CRC32 is %lx (added as last 4 bytes)\r\n", crc);
UART_PUTS("1\r\n");
crc = crc32(bufx, testlen - 4);
UART_PUTS("2\r\n");
setBuf32(testlen - 4, crc);
UART_PUTS("Before encryption (CRC added): ");
printbytearray(bufx, testlen);
UART_PUTS("1\r\n");
uint8_t aes_byte_count = aes256_encrypt_cbc(bufx, testlen);
UART_PUTS("2\r\n");
UART_PUTS("After encryption: ");
printbytearray(bufx, aes_byte_count);
UART_PUTF("String len = %u\r\n", aes_byte_count);
UART_PUTS("1\r\n");
aes256_decrypt_cbc(bufx, aes_byte_count);
UART_PUTS("2\r\n");
UART_PUTS("After decryption: ");
printbytearray(bufx, testlen);
crc = getBuf32(testlen - 4);
UART_PUTF("CRC32 is %lx (last 4 bytes from decrypted message)\r\n", crc);
printbytearray(bufx, testlen);
UART_PUTS("After decryption (CRC removed): ");
printbytearray(bufx, testlen);
UART_PUTF("String len = %u\r\n", testlen);
while(1);
*/
while (42)
{
if (rfm12_rx_status() == STATUS_COMPLETE)
{
uint8_t len = rfm12_rx_len();
if ((len == 0) || (len % 16 != 0))
{
UART_PUTF("Received garbage (%u bytes not multiple of 16): ", len);
printbytearray(bufx, len);
}
else // try to decrypt with all keys stored in EEPROM
{
uint32_t assumed_crc;
uint32_t actual_crc;
for(aes_key_nr = 0; aes_key_nr < AES_KEY_EEPROM_COUNT ; aes_key_nr++)
{
//strncpy((char *)bufx, (char *)rfm12_rx_buffer(), len);
memcpy(bufx, rfm12_rx_buffer(), len);
/*if (aes_key_nr == 0)
{
UART_PUTS("Before decryption: ");
printbytearray(bufx, len);
}*/
eeprom_read_block (aes_key, (uint8_t *)(EEPROM_POS_AES_KEY + aes_key_nr * 32), 32);
//UART_PUTS("Trying AES key ");
//printbytearray((uint8_t *)aes_key, 32);
aes256_decrypt_cbc(bufx, len);
//UART_PUTS("Decrypted bytes: ");
//printbytearray(bufx, len);
assumed_crc = getBuf32(len - 4);
actual_crc = crc32(bufx, len - 4);
//UART_PUTF("Received CRC32 would be %lx\r\n", assumed_crc);
//UART_PUTF("Re-calculated CRC32 is %lx\r\n", actual_crc);
if (assumed_crc == actual_crc)
{
//UART_PUTS("CRC correct, AES key found!\r\n");
UART_PUTF("Received (AES key %u): ", aes_key_nr);
printbytearray(bufx, len - 4);
decode_data(len - 4);
break;
}
}
if (assumed_crc != actual_crc)
{
UART_PUTS("Received garbage (CRC wrong after decryption).\r\n");
}
UART_PUTS("\r\n");
}
//uart_hexdump((char *)bufcontents, rfm12_rx_len());
//UART_PUTS("\r\n");
// tell the implementation that the buffer can be reused for the next data.
rfm12_rx_clear();
}
// send data, if waiting in send buffer
if (send_data_avail)
{
uint8_t i;
uint8_t data_len_raw = strlen(sendbuf) / 2 - 2;
// round data length to 6 + 16 bytes (including padding bytes)
uint8_t data_len = (((data_len_raw + 9) / 16) + 1) * 16 - 10;
// set aes key nr
aes_key_nr = hex_to_uint8((uint8_t *)sendbuf, 0);
//UART_PUTF("AES KEY = %u\r\n", aes_key_nr);
// set command id
uint8_t command_id = hex_to_uint8((uint8_t *)sendbuf, 2);
// set data
for (i = 0; i < data_len_raw; i++)
{
data[i] = hex_to_uint8((uint8_t *)sendbuf, 4 + 2 * i);
}
// set padding bytes
for (i = data_len_raw; i < data_len; i++)
{
data[i] = 0;
}
// send status packet immediately (command IDs are less than 128)
if (command_id < 128)
{
// set command id
bufx[5] = command_id;
// set data
memcpy(bufx + 6, data, data_len);
send_packet(aes_key_nr, data_len);
}
else // enqueue request (don't send immediately)
{
if (queue_request(data[0], command_id, aes_key_nr, data + 1))
{
UART_PUTS("Adding request to queue.\r\n");
}
else
{
UART_PUTS("Warning! Request queue full. Packet will not be sent.\r\n");
}
print_request_queue();
}
// clear send text buffer
send_data_avail = false;
rfm12_tick();
led_blink(200, 0, 1);
}
// flash LED every second to show the device is alive
if (loop == 50)
{
led_blink(10, 10, 1);
loop = 0;
if (set_repeat_request(packetcounter + 1)) // if request to repeat was found in queue
{
UART_PUTS("Repeating request.\r\n");
send_packet(0, 6);
print_request_queue();
}
// Auto-send something for debugging purposes...
if (loop2 == 50)
{
//strcpy(sendbuf, "008c0001003d");
//send_data_avail = true;
loop2 = 0;
}
else
{
loop2++;
}
}
else
{
_delay_ms(20);
}
rfm12_tick();
loop++;
process_rxbuf();
if (uart_timeout > 0)
{
uart_timeout--;
if (uart_timeout == 0)
{
UART_PUTS("*** UART user timeout. Input was ignored. ***\r\n");
}
}
}
// never called
// aes256_done(&aes_ctx);
}
int main(void)
{
uint16_t send_status_timeout = 25;
uint32_t station_packetcounter;
uint32_t pos;
uint8_t button_state = 0;
uint8_t manual_dim_direction = 0;
// delay 1s to avoid further communication with uart or RFM12 when my programmer resets the MC after 500ms...
_delay_ms(1000);
util_init();
check_eeprom_compatibility(DEVICE_TYPE_DIMMER);
osccal_init();
// read packetcounter, increase by cycle and write back
packetcounter = eeprom_read_dword((uint32_t*)EEPROM_POS_PACKET_COUNTER) + PACKET_COUNTER_WRITE_CYCLE;
eeprom_write_dword((uint32_t*)EEPROM_POS_PACKET_COUNTER, packetcounter);
// read device id and write to send buffer
device_id = eeprom_read_byte((uint8_t*)EEPROM_POS_DEVICE_ID);
use_pwm_translation = 1; //eeprom_read_byte((uint8_t*)EEPROM_POS_USE_PWM_TRANSLATION);
// TODO: read (saved) dimmer state from before the eventual powerloss
/*for (i = 0; i < SWITCH_COUNT; i++)
{
uint16_t u16 = eeprom_read_word((uint16_t*)EEPROM_POS_SWITCH_STATE + i * 2);
switch_state[i] = (uint8_t)(u16 & 0b1);
switch_timeout[i] = u16 >> 1;
}*/
// read last received station packetcounter
station_packetcounter = eeprom_read_dword((uint32_t*)EEPROM_POS_STATION_PACKET_COUNTER);
led_blink(200, 200, 5);
#ifdef UART_DEBUG
uart_init(false);
UART_PUTS ("\r\n");
UART_PUTS ("smarthomatic Dimmer V1.0 (c) 2013 Uwe Freese, www.smarthomatic.org\r\n");
osccal_info();
UART_PUTF ("Device ID: %u\r\n", device_id);
UART_PUTF ("Packet counter: %lu\r\n", packetcounter);
UART_PUTF ("Use PWM translation table: %u\r\n", use_pwm_translation);
UART_PUTF ("Last received station packet counter: %u\r\n\r\n", station_packetcounter);
#endif
// init AES key
eeprom_read_block (aes_key, (uint8_t *)EEPROM_POS_AES_KEY, 32);
rfm12_init();
PWM_init();
io_init();
setPWMDutyCycle(0);
timer0_init();
// DEMO to measure the voltages of different PWM settings to calculate the pwm_lookup table
/*while (42)
{
uint16_t i;
for (i = 0; i <= 1024; i = i + 100)
{
UART_PUTF ("PWM value OCR1A: %u\r\n", i);
OCR1A = i;
led_blink(500, 6500, 1);
}
}*/
// DEMO 0..100..0%, using the pwm_lookup table and the translation table in EEPROM.
/*while (42)
{
float i;
for (i = 0; i <= 100; i = i + 0.05)
{
led_blink(10, 10, 1);
setPWMDutyCycle(i);
}
for (i = 99.95; i > 0; i = i - 0.05)
{
led_blink(10, 10, 1);
setPWMDutyCycle(i);
}
}*/
// set initial switch state
/*for (i = 0; i < SWITCH_COUNT; i++)
{
switchRelais(i, switch_state[i]);
}*/
sei();
// DEMO 30s
/*animation_length = 30;
animation_length = (uint32_t)((float)animation_length * 1000 / ANIMATION_CYCLE_MS);
start_brightness = 0;
end_brightness = 255;
animation_position = 0;*/
while (42)
{
if (rfm12_rx_status() == STATUS_COMPLETE)
{
uint8_t len = rfm12_rx_len();
if ((len == 0) || (len % 16 != 0))
{
UART_PUTF("Received garbage (%u bytes not multiple of 16): ", len);
printbytearray(bufx, len);
}
else // try to decrypt with all keys stored in EEPROM
{
memcpy(bufx, rfm12_rx_buffer(), len);
//UART_PUTS("Before decryption: ");
//printbytearray(bufx, len);
aes256_decrypt_cbc(bufx, len);
//UART_PUTS("Decrypted bytes: ");
//printbytearray(bufx, len);
uint32_t assumed_crc = getBuf32(len - 4);
uint32_t actual_crc = crc32(bufx, len - 4);
//UART_PUTF("Received CRC32 would be %lx\r\n", assumed_crc);
//UART_PUTF("Re-calculated CRC32 is %lx\r\n", actual_crc);
if (assumed_crc != actual_crc)
{
UART_PUTS("Received garbage (CRC wrong after decryption).\r\n");
}
else
{
//UART_PUTS("CRC correct, AES key found!\r\n");
UART_PUTS(" Received: ");
printbytearray(bufx, len - 4);
// decode command and react
uint8_t sender = bufx[0];
UART_PUTF(" Sender: %u\r\n", sender);
if (sender != 0)
{
UART_PUTF("Packet not from base station. Ignoring (Sender ID was: %u).\r\n", sender);
}
else
{
uint32_t packcnt = getBuf32(1);
UART_PUTF(" Packet Counter: %lu\r\n", packcnt);
// check received counter
if (0) //packcnt <= station_packetcounter)
{
UART_PUTF2("Received packet counter %lu is lower than last received counter %lu. Ignoring packet.\r\n", packcnt, station_packetcounter);
}
else
{
// write received counter
station_packetcounter = packcnt;
eeprom_write_dword((uint32_t*)EEPROM_POS_STATION_PACKET_COUNTER, station_packetcounter);
// check command ID
uint8_t cmd = bufx[5];
UART_PUTF(" Command ID: %u\r\n", cmd);
if (cmd != 141) // ID 141 == Dimmer Request
{
UART_PUTF("Received unknown command ID %u. Ignoring packet.\r\n", cmd);
}
else
{
// check device id
uint8_t rcv_id = bufx[6];
UART_PUTF(" Receiver ID: %u\r\n", rcv_id);
if (rcv_id != device_id)
{
UART_PUTF("Device ID %u does not match. Ignoring packet.\r\n", rcv_id);
}
else
{
// read animation mode and parameters
uint8_t animation_mode = bufx[7] >> 5;
// TODO: Implement support for multiple dimmers (e.g. RGB)
// uint8_t dimmer_bitmask = bufx[7] & 0b111;
animation_length = getBuf16(8);
start_brightness = bufx[10];
end_brightness = bufx[11];
UART_PUTF(" Animation Mode: %u\r\n", animation_mode); // TODO: Set binary mode like 00010110
//UART_PUTF(" Dimmer Bitmask: %u\r\n", dimmer_bitmask);
UART_PUTF(" Animation Time: %us\r\n", animation_length);
UART_PUTF(" Start Brightness: %u\r\n", start_brightness);
UART_PUTF(" End Brightness: %u\r\n", end_brightness);
animation_length = (uint32_t)((float)animation_length * 1000 / ANIMATION_CYCLE_MS);
animation_position = 0;
/* TODO: Write to EEPROM (?)
// write back switch state to EEPROM
switch_state[i] = req_state;
switch_timeout[i] = req_timeout;
eeprom_write_word((uint16_t*)EEPROM_POS_SWITCH_STATE + i * 2, u16);
*/
// send acknowledge
UART_PUTS("Sending ACK:\r\n");
// set device ID (base station has ID 0 by definition)
bufx[0] = device_id;
// update packet counter
packetcounter++;
if (packetcounter % PACKET_COUNTER_WRITE_CYCLE == 0)
{
eeprom_write_dword((uint32_t*)0, packetcounter);
}
setBuf32(1, packetcounter);
// set command ID "Generic Acknowledge"
bufx[5] = 1;
// set sender ID of request
bufx[6] = sender;
// set Packet counter of request
setBuf32(7, station_packetcounter);
// zero unused bytes
bufx[11] = 0;
// set CRC32
uint32_t crc = crc32(bufx, 12);
setBuf32(12, crc);
// show info
UART_PUTF(" CRC32: %lx\r\n", crc);
uart_putstr(" Unencrypted: ");
printbytearray(bufx, 16);
rfm12_sendbuf();
UART_PUTS(" Send encrypted: ");
printbytearray(bufx, 16);
UART_PUTS("\r\n");
rfm12_tick();
led_blink(200, 0, 1);
send_status_timeout = 25;
}
}
}
}
}
}
// tell the implementation that the buffer can be reused for the next data.
rfm12_rx_clear();
}
_delay_ms(ANIMATION_UPDATE_MS);
// React on button press.
// - abort animation
// - switch off, when brightness > 0
// - switch on otherwise
if (!(BUTTON_PORT & (1 << BUTTON_PIN))) // button press
{
if (button_state == 0)
{
UART_PUTS("Button pressed\r\n");
animation_length = 0;
animation_position = 0;
}
if (button_state < 5)
{
button_state++;
}
else // manual dimming
{
if (manual_dim_direction) // UP
{
if (current_brightness < 100)
{
current_brightness = (uint8_t)current_brightness / 2 * 2 + 2;
setPWMDutyCycle(current_brightness);
}
else
{
UART_PUTS("manual dimming DOWN\r\n");
manual_dim_direction = 0;
}
}
else // DOWN
{
if (current_brightness > 0)
{
current_brightness = (((uint8_t)current_brightness - 1) / 2) * 2;
setPWMDutyCycle(current_brightness);
}
else
{
UART_PUTS("manual dimming UP\r\n");
manual_dim_direction = 1;
}
}
}
}
else if (button_state && (BUTTON_PORT & (1 << BUTTON_PIN))) // button release
{
UART_PUTS("Button released\r\n");
if (button_state < 5) // short button press
{
if (current_brightness > 0)
{
UART_PUTS(" -> 0%\r\n");
setPWMDutyCycle(0);
}
else
{
UART_PUTS(" -> 100%\r\n");
setPWMDutyCycle(100);
}
}
else
{
// reverse dim direction
manual_dim_direction = !manual_dim_direction;
}
button_state = 0;
}
// update brightness according animation_position, updated by timer0
if (animation_length > 0)
{
pos = animation_position; // copy value to avoid that it changes in between by timer interrupt
UART_PUTF2("%lu/%lu, ", pos, animation_length);
if (pos == animation_length)
{
UART_PUTF("END Brightness %u%%, ", end_brightness * 100 / 255);
setPWMDutyCycle((float)end_brightness * 100 / 255);
animation_length = 0;
animation_position = 0;
}
else
{
float brightness = (start_brightness + ((float)end_brightness - start_brightness) * pos / animation_length) * 100 / 255;
UART_PUTF("Br.%u%%, ", (uint32_t)(brightness));
setPWMDutyCycle(brightness);
}
}
// send status from time to time
if (send_status_timeout == 0)
{
send_status_timeout = SEND_STATUS_EVERY_SEC * (1000 / ANIMATION_UPDATE_MS);
send_dimmer_status();
led_blink(200, 0, 1);
}
rfm12_tick();
send_status_timeout--;
checkSwitchOff();
}
// Initialisierung
void rfm12_layer2_init()
{
rfm12_send_state = send_idle;
rfm12_receive_state = receive_idle;
rfm12_init();
}
int main(void)
{
uint8_t i;
uint16_t wakeup_sec;
bool send;
// delay 1s to avoid further communication with uart or RFM12 when my programmer resets the MC after 500ms...
_delay_ms(1000);
util_init();
check_eeprom_compatibility(DEVICETYPE_SOILMOISTUREMETER);
// configure power pin for 74HC14D as output
sbi(TRIGGERPWR_DDR, TRIGGERPWR_PIN);
// read packetcounter, increase by cycle and write back
packetcounter = e2p_generic_get_packetcounter() + PACKET_COUNTER_WRITE_CYCLE;
e2p_generic_set_packetcounter(packetcounter);
// read device id
device_id = e2p_generic_get_deviceid();
dry_thr = e2p_soilmoisturemeter_get_drythreshold();
if (dry_thr == 0) // set default value if never initialized
{
dry_thr = 40000;
}
counter_min = e2p_soilmoisturemeter_get_minval();
if (counter_min == 0) // set default value if never initialized
{
counter_min = 30000;
}
avgIntInit = e2p_soilmoisturemeter_get_averagingintervalinit();
avgInt = e2p_soilmoisturemeter_get_averaginginterval();
smoothing_percentage = e2p_soilmoisturemeter_get_smoothingpercentage();
osccal_init();
uart_init();
UART_PUTS ("\r\n");
UART_PUTF4("smarthomatic Soil Moisture Meter v%u.%u.%u (%08lx)\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_HASH);
UART_PUTS("(c) 2014..2015 Uwe Freese, www.smarthomatic.org\r\n");
osccal_info();
UART_PUTF ("DeviceID: %u\r\n", device_id);
UART_PUTF ("PacketCounter: %lu\r\n", packetcounter);
UART_PUTF ("AveragingInterval for initialization: %u\r\n", avgIntInit);
UART_PUTF ("AveragingInterval for normal operation: %u\r\n", avgInt);
UART_PUTF ("Dry threshold: %u\r\n", dry_thr);
UART_PUTF ("Min value: %u\r\n", counter_min);
UART_PUTF ("Smoothing percentage: %u\r\n", smoothing_percentage);
adc_init();
// init AES key
e2p_generic_get_aeskey(aes_key);
// set pull-up for BUTTON_DDR
sbi(BUTTON_PORT, BUTTON_PIN);
_delay_ms(10);
// set DIDR for all ADC channels and AINs, switch off digital input buffers to reduce ADC noise and to save power
DIDR0 = 63;
DIDR1 = 3;
// If button pressed at start up, go to sleep for idle power consumption test.
// Don't communicate with RFM12, which may not have been connected yet.
if (BUTTON)
{
led_blink(50, 50, 20);
power_down(true);
}
led_blink(500, 500, 3);
rfm12_init();
wakeup_sec = init_wakeup();
// init interrupt for button (falling edge)
sbi(EICRA, ISC11);
sbi(EIMSK, INT1);
sei();
for (i = 0; i < SEND_STATUS_TIMES_AT_STARTUP; i++)
{
prepare_deviceinfo_status();
send_prepared_message();
_delay_ms(800);
prepare_battery_status();
send_prepared_message();
_delay_ms(800);
}
while (42)
{
if (BUTTON)
{
led_blink(100, 0, 1);
UART_PUTS("Button pressed!\r\n");
uint8_t cnt = 0;
while (BUTTON && (cnt < 250))
{
_delay_ms(10);
cnt++;
}
if (cnt == 250)
{
UART_PUTS("Long press -> initiate measure mode!\r\n");
while (BUTTON)
{
led_blink(100, 100, 1);
}
init_mode = true;
wupCnt = 0;
counter_meas = 0;
init_wakeup(); // to usually shorter value
UART_PUTS("Button released!\r\n");
_delay_ms(10);
}
}
else
{
send = true;
//UART_PUTF("version_status_cycle = %u\r\n", version_status_cycle);
if (!measure_humidity())
{
if (battery_status_cycle > 0)
battery_status_cycle--;
if (version_status_cycle > 0)
version_status_cycle--;
if (version_status_cycle == 0)
{
version_status_cycle = SEND_VERSION_STATUS_CYCLE;
prepare_deviceinfo_status();
}
else if (battery_status_cycle == 0)
{
battery_status_cycle = SEND_BATTERY_STATUS_CYCLE;
prepare_battery_status();
}
else
{
send = false;
}
}
if (send)
{
send_prepared_message();
}
}
power_down(true);
}
// never called
// aes256_done(&aes_ctx);
}
/***
*
* constructor
* initialise the module
*
***/
megaRF::megaRF(){
rfm12_init();
//rfm12_rx_clear();
rfm12_tick();
}
void
rfm12_ask_external_filter_deinit(void)
{
rfm12_init();
}
int main(void)
{
uint16_t send_status_timeout = 25;
uint32_t pos;
uint8_t button_state = 0;
uint8_t manual_dim_direction = 0;
// delay 1s to avoid further communication with uart or RFM12 when my programmer resets the MC after 500ms...
_delay_ms(1000);
util_init();
check_eeprom_compatibility(DEVICETYPE_DIMMER);
// read packetcounter, increase by cycle and write back
packetcounter = e2p_generic_get_packetcounter() + PACKET_COUNTER_WRITE_CYCLE;
e2p_generic_set_packetcounter(packetcounter);
// read device id
device_id = e2p_generic_get_deviceid();
// pwm translation table is not used if first byte is 0xFF
use_pwm_translation = (0xFF != eeprom_read_UIntValue8(EEPROM_BRIGHTNESSTRANSLATIONTABLE_BYTE,
EEPROM_BRIGHTNESSTRANSLATIONTABLE_BIT, 8, 0, 0xFF));
// TODO: read (saved) dimmer state from before the eventual powerloss
/*for (i = 0; i < SWITCH_COUNT; i++)
{
uint16_t u16 = eeprom_read_word((uint16_t*)EEPROM_POS_SWITCH_STATE + i * 2);
switch_state[i] = (uint8_t)(u16 & 0b1);
switch_timeout[i] = u16 >> 1;
}*/
// read last received station packetcounter
station_packetcounter = e2p_dimmer_get_basestationpacketcounter();
led_blink(500, 500, 3);
osccal_init();
uart_init();
UART_PUTS ("\r\n");
UART_PUTF4("smarthomatic Dimmer v%u.%u.%u (%08lx)\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_HASH);
UART_PUTS("(c) 2013..2014 Uwe Freese, www.smarthomatic.org\r\n");
osccal_info();
UART_PUTF ("DeviceID: %u\r\n", device_id);
UART_PUTF ("PacketCounter: %lu\r\n", packetcounter);
UART_PUTF ("Use PWM translation table: %u\r\n", use_pwm_translation);
UART_PUTF ("Last received base station PacketCounter: %u\r\n\r\n", station_packetcounter);
// init AES key
eeprom_read_block (aes_key, (uint8_t *)EEPROM_AESKEY_BYTE, 32);
rfm12_init();
PWM_init();
io_init();
setPWMDutyCyclePercent(0);
timer0_init();
// DEMO to measure the voltages of different PWM settings to calculate the pwm_lookup table
/*while (42)
{
uint16_t i;
for (i = 0; i <= 1024; i = i + 100)
{
UART_PUTF ("PWM value OCR1A: %u\r\n", i);
OCR1A = i;
led_blink(500, 6500, 1);
}
}*/
// DEMO 0..100..0%, using the pwm_lookup table and the translation table in EEPROM.
/*while (42)
{
float i;
for (i = 0; i <= 100; i = i + 0.05)
{
led_blink(10, 10, 1);
setPWMDutyCycle(i);
}
for (i = 99.95; i > 0; i = i - 0.05)
{
led_blink(10, 10, 1);
setPWMDutyCycle(i);
}
}*/
// set initial switch state
/*for (i = 0; i < SWITCH_COUNT; i++)
{
switchRelais(i, switch_state[i]);
}*/
sei();
// DEMO 30s
/*animation_length = 30;
animation_length = (uint32_t)((float)animation_length * 1000 / ANIMATION_CYCLE_MS);
start_brightness = 0;
end_brightness = 255;
animation_position = 0;*/
while (42)
{
if (rfm12_rx_status() == STATUS_COMPLETE)
{
uint8_t len = rfm12_rx_len();
if ((len == 0) || (len % 16 != 0))
{
UART_PUTF("Received garbage (%u bytes not multiple of 16): ", len);
print_bytearray(bufx, len);
}
else // try to decrypt with all keys stored in EEPROM
{
memcpy(bufx, rfm12_rx_buffer(), len);
UART_PUTS("Before decryption: ");
print_bytearray(bufx, len);
aes256_decrypt_cbc(bufx, len);
UART_PUTS("Decrypted bytes: ");
print_bytearray(bufx, len);
if (!pkg_header_check_crc32(len))
{
UART_PUTS("Received garbage (CRC wrong after decryption).\r\n");
}
else
{
process_packet(len);
}
}
// tell the implementation that the buffer can be reused for the next data.
rfm12_rx_clear();
}
_delay_ms(ANIMATION_UPDATE_MS);
// React on button press.
// - abort animation
// - switch off, when brightness > 0
// - switch on otherwise
if (!(BUTTON_PORT & (1 << BUTTON_PIN))) // button press
{
if (button_state == 0)
{
UART_PUTS("Button pressed\r\n");
animation_length = 0;
animation_position = 0;
}
if (button_state < 5)
{
button_state++;
}
else // manual dimming
{
if (manual_dim_direction) // UP
{
if (current_brightness < 100)
{
current_brightness = (uint8_t)current_brightness / 2 * 2 + 2;
setPWMDutyCyclePercent(current_brightness);
}
else
{
UART_PUTS("manual dimming DOWN\r\n");
manual_dim_direction = 0;
}
}
else // DOWN
{
if (current_brightness > 0)
{
current_brightness = (((uint8_t)current_brightness - 1) / 2) * 2;
setPWMDutyCyclePercent(current_brightness);
}
else
{
UART_PUTS("manual dimming UP\r\n");
manual_dim_direction = 1;
}
}
}
}
else if (button_state && (BUTTON_PORT & (1 << BUTTON_PIN))) // button release
{
UART_PUTS("Button released\r\n");
if (button_state < 5) // short button press
{
if (current_brightness > 0)
{
UART_PUTS(" -> 0%\r\n");
setPWMDutyCyclePercent(0);
}
else
{
UART_PUTS(" -> 100%\r\n");
setPWMDutyCyclePercent(100);
}
}
else
{
// reverse dim direction
manual_dim_direction = !manual_dim_direction;
}
button_state = 0;
}
// update brightness according animation_position, updated by timer0
if (animation_length > 0)
{
pos = animation_position; // copy value to avoid that it changes in between by timer interrupt
UART_PUTF2("%lu/%lu, ", pos, animation_length);
if (pos == animation_length)
{
UART_PUTF("END Brightness %u%%, ", end_brightness);
setPWMDutyCyclePercent((float)end_brightness);
animation_length = 0;
animation_position = 0;
}
else
{
float brightness = (start_brightness + ((float)end_brightness - start_brightness) * pos / animation_length);
UART_PUTF("Br.%u%%, ", (uint32_t)(brightness));
setPWMDutyCyclePercent(brightness);
}
}
// send status from time to time
if (send_status_timeout == 0)
{
send_status_timeout = SEND_STATUS_EVERY_SEC * (1000 / ANIMATION_UPDATE_MS);
send_dimmer_status();
led_blink(200, 0, 1);
}
else if (version_status_cycle >= SEND_VERSION_STATUS_CYCLE)
{
version_status_cycle = 0;
send_version_status();
led_blink(200, 0, 1);
}
rfm12_tick();
send_status_timeout--;
checkSwitchOff();
}
// never called
// aes256_done(&aes_ctx);
}
void initCommunication(){
rfm12_init(); // initialize the library
sei();
rfm12_rx_clear();
}
int main(UNUSED(int argc), UNUSED(char** argv))
{
uint32_t tso = rdtsc32();
stdio_mode(STDIO_MODE_CANON);
// initialize mraa and software SPI
mraa_init();
printf("MRAA paltform %s, version %s\n", mraa_get_platform_name(), mraa_get_version());
mraa_spi_sw_context spi = sw_spi_init(MRAA_SCK, MRAA_MOSI, MRAA_MISO);
// initialize RFM12BS
rfm12_t rfm;
memset(&rfm, 0, sizeof(rfm));
rfm12_init_spi(&rfm, spi, MRAA_CS1, MRAA_GP047);
rfm12_init(&rfm, 0xD4, RFM12_BAND_868, 868.0, RFM12_BPS_9600);
rfm12_set_mode(&rfm, RFM_MODE_RX);
printf("started up in %u msec\n", millis(tso));
// default application configuration
cfg.flags |= APPF_ECHO_DAN;
cfg.rfm = &rfm;
// initialize command line interface
console_io_t cli;
memset(&cli, 0, sizeof(cli));
cli.prompt = '>';
cli.data = &cfg;
stdio_init(&cli, stdio_cmd_handler);
stdio_mode(STDIO_MODE_RAW);
dnode_t node;
while(!cli.stop) {
cli.interact(&cli, cli_cmd);
if (rfm12_receive_data(&rfm, &node, sizeof(node), cfg.flags & RFM_RX_DEBUG) == sizeof(node)) {
rfm12_set_mode(&rfm, RFM_MODE_RX);
if (node.nid == NODE_TSYNC) {
tso = rdtsc32();
ts_unpack(&node);
cfg.rtc_hour = node.hour;
cfg.rtc_min = node.min;
cfg.rtc_sec = node.sec;
}
if (cfg.flags & APPF_ECHO_DAN)
print_node(&cli, &node);
}
if (millis(tso) >= 1000) {
tso = rdtsc32();
if (++cfg.rtc_sec == 60) {
cfg.rtc_sec = 0;
if (++cfg.rtc_min == 60) {
cfg.rtc_min = 0;
if (++cfg.rtc_hour == 24)
cfg.rtc_hour = 0;
}
}
}
usleep(1); // be nice
}
stdio_mode(STDIO_MODE_CANON);
rfm12_close_spi(&rfm);
sw_spi_close(spi);
mraa_deinit();
}