r0ketbeam.c

   1
   2 #include "config.h"
   3 #ifdef HAS_R0KETBEAM_SUPPORT
   4 #include <RF24.h>
   5
   6 #include "r0ketbeam.h"
   7 #include "util.h"
   8 #include "uart.h"
   9
  10 #include <avr/io.h>
  11 #include <avr/pgmspace.h>
  12
  13 #include <string.h>
  14
  15 typedef struct {
  16     uint8_t length;
  17     uint8_t protocol;
  18     uint8_t flags;
  19     uint8_t strength;
  20     uint32_t sequence;
  21     uint32_t id;
  22     uint8_t button1;
  23     uint8_t button2;
  24     uint16_t crc;
  25 } beacon_data_t;
  26
  27 typedef struct {
  28     uint8_t length;
  29     uint8_t protocol;
  30     uint32_t id;
  31     char name[8];
  32     uint16_t crc;
  33 } beacon_name_t;
  34
  35 #if defined(PRINT_NORESPONSE)
  36 int inc;
  37 #endif
  38
  39 void r0ketbeam_setup(void)
  40 {
  41     nrf24_begin();
  42     nrf24_setDataRate(RF24_2MBPS);
  43     nrf24_setChannel(81);
  44     nrf24_setAutoAck(0);
  45     nrf24_setPayloadSize(16);
  46     nrf24_setCRCLength(RF24_CRC_8);
  47     nrf24_openReadingPipe(1, 0x0102030201LL);
  48     nrf24_openWritingPipe(0x0102030201LL);
  49     uart_puts_p(PSTR("RF24 Carrier: "));
  50     uint8_t carrier = nrf24_testCarrier();
  51     uart_putc(carrier?'Y':'N');
  52     uart_putc('\n');
  53     nrf24_startListening();
  54 }
  55
  56 uint16_t flip16(uint16_t number)
  57 {
  58     return number>>8|number<<8;
  59 }
  60
  61 uint16_t crc16(uint8_t* buf, int len)
  62 {
  63     /* code from r0ket/firmware/basic/crc.c */
  64     uint16_t crc = 0xffff;
  65     for (int i=0; i < len; i++)
  66     {
  67         crc = (unsigned char)(crc >> 8) | (crc << 8);
  68         crc ^= buf[i];
  69         crc ^= (unsigned char)(crc & 0xff) >> 4;
  70         crc ^= (crc << 8) << 4;
  71         crc ^= ((crc & 0xff) << 4) << 1;
  72     }
  73     return crc;
  74 }
  75
  76 //CAUTION!!1! "id" is little-endian
  77 void sendNick(uint32_t id, char* name)
  78 {
  79     beacon_name_t pkt;
  80     pkt.length = 16;
  81     pkt.protocol = 0x23;
  82     pkt.id = id;
  83     memset(&pkt.name, 0, sizeof(pkt.name));
  84     strncpy((char*)&pkt.name, name, min(8,strlen(name)));
  85     pkt.crc = flip16(crc16((uint8_t*)&pkt, sizeof(pkt)-2));
  86
  87     nrf24_stopListening();
  88     nrf24_openWritingPipe(0x0102030201LL);
  89     nrf24_write(&pkt, sizeof(pkt));
  90     nrf24_startListening();
  91 }
  92
  93 //CAUTION!!1! "id" and "sequence" are little-endian
  94 void sendDummyPacket(uint32_t id, uint32_t sequence)
  95 {
  96     beacon_data_t pkt;
  97     pkt.length = 16;
  98     pkt.protocol = 0x17;
  99     pkt.id = id;
 100     pkt.sequence = sequence;
 101     pkt.flags = 0x00;
 102     pkt.button1 = 0xFF;
 103     pkt.button2 = 0xFF;
 104
 105     pkt.crc = flip16(crc16((uint8_t*)&pkt, sizeof(pkt)-2));
 106
 107     nrf24_stopListening();
 108     nrf24_write((uint8_t*)&pkt, sizeof(pkt));
 109     nrf24_startListening();
 110 }
 111
 112 int last_sent_packet = 0;
 113 char* nick = "c_leuse";
 114
 115 void r0ketbeam_loop(void)
 116 {
 117     //sorry, since we are not arduino, we do not yet have a millis() function.
 118     //int delta = millis() - last_sent_packet;
 119     /*
 120        if (delta > 1234)
 121        {
 122        last_sent_packet = millis(); //FIXME little endianness, anyone?
 123     //printf("[%i] ", delta);
 124
 125     uint32_t id = 0x78563412UL;
 126
 127     char myNick[9];
 128     sprintf((char*)&myNick, "*[%u]", (unsigned int)millis());
 129     myNick[sizeof(myNick)-1] = '\0';
 130
 131     Serial.print("# Sending nick '");
 132     Serial.print(myNick);
 133     Serial.print("' as 0x");
 134     Serial.print(id, HEX);
 135     Serial.println(" ...");
 136     sendNick(id, (char*)&myNick);
 137
 138     //sendDummyPacket(id, last_sent_packet);
 139     }
 140     */
 141
 142     if (nrf24_available()){
 143         beacon_data_t buf;
 144         nrf24_read(&buf, sizeof(buf));
 145
 146 #ifdef PRINT_NORESPONSE
 147         if (inc > 0){
 148             uart_putc('\n');
 149         }
 150         inc = 0;
 151 #endif
 152         uart_puts_p(PSTR("RF24 RECV "));
 153         uart_puthex_flip_32(buf.id);
 154         uart_putc(':');
 155         uart_putc(' ');
 156         uart_puthex_flip_32(buf.sequence);
 157         uart_putc(' ');
 158         uart_putc('(');
 159         uart_putdec(buf.strength);
 160         uart_putc(')');
 161         uart_putc(' ');
 162         uart_puthex(buf.protocol);
 163         uart_putc('\n');
 164
 165         uint16_t crc = flip16(crc16((uint8_t*)&buf, sizeof(buf)-2));
 166         if (crc != buf.crc){
 167             uart_puts_p(PSTR("RF24 ! CRC mismatch (expected/got): "));
 168             uart_puthex_16(crc);
 169             uart_putc('/');
 170             uart_puthex_16(buf.crc);
 171             uart_putc('\n');
 172         }
 173     }else{
 174 #ifdef PRINT_NORESPONSE
 175         if (inc++ == 80) {
 176             uart_putc('\n');
 177             inc = 0;
 178         }
 179         uart_putc('.');
 180         //_delay_ms(100);
 181 #endif
 182     }
 183 }
 184
 185 #else//HAS_R0KETBEAM_SUPPORT
 186
 187 void r0ketbeam_loop(){}
 188 void r0ketbeam_setup(){}
 189
 190 #endif//HAS_R0KETBEAM_SUPPORT