602 lines
14 KiB
C
602 lines
14 KiB
C
/****************************************************************************
|
||
* apps/examples/nrf24l01_btle/nrf24l01_btle.c
|
||
*
|
||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||
* contributor license agreements. See the NOTICE file distributed with
|
||
* this work for additional information regarding copyright ownership. The
|
||
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
||
* "License"); you may not use this file except in compliance with the
|
||
* License. You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||
* License for the specific language governing permissions and limitations
|
||
* under the License.
|
||
*
|
||
****************************************************************************/
|
||
|
||
/****************************************************************************
|
||
* Included Files
|
||
****************************************************************************/
|
||
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/ioctl.h>
|
||
#include <debug.h>
|
||
|
||
#include <nuttx/signal.h>
|
||
#include <nuttx/sensors/dhtxx.h>
|
||
#include <nuttx/wireless/nrf24l01.h>
|
||
|
||
#include <errno.h>
|
||
#include <stdio.h>
|
||
#include <poll.h>
|
||
#include <fcntl.h>
|
||
|
||
#include "nrf24l01_btle.h"
|
||
|
||
/****************************************************************************
|
||
* Private Data
|
||
****************************************************************************/
|
||
|
||
#define DEV_NAME "/dev/nrf24l01"
|
||
|
||
#ifndef STDIN_FILENO
|
||
# define STDIN_FILENO 0
|
||
#endif
|
||
|
||
#ifdef CONFIG_DEBUG_WIRELESS
|
||
# define nrf24_dumpbuffer(m,b,s) lib_dumpbuffer(m,b,s)
|
||
#endif
|
||
|
||
#ifdef CONFIG_WL_NRF24L01_RXSUPPORT
|
||
/* If RX support is enabled, poll both stdin and the message reception */
|
||
# define N_PFDS 2
|
||
#else
|
||
/* If RX support is not enabled, we cannot poll the wireless device */
|
||
# define N_PFDS 1
|
||
#endif
|
||
|
||
static struct pollfd pfds[N_PFDS];
|
||
#define DEFAULT_TXPOWER -6 /* (0, -6, -12, or -18 dBm) */
|
||
|
||
static uint8_t mac[6] =
|
||
{
|
||
0x79, 0x6a, 0x64, 0x77, 0x62, 0x6a
|
||
};
|
||
|
||
/* logical BTLE channel number (37-39) */
|
||
|
||
const uint8_t channel[3] =
|
||
{
|
||
37, 38, 39
|
||
};
|
||
|
||
/* physical frequency (2400+x MHz) */
|
||
|
||
const uint8_t frequency[3] =
|
||
{
|
||
2, 26, 80
|
||
};
|
||
|
||
const uint8_t adve_name[5] =
|
||
{
|
||
'n', 'R', 'F', '2', '4'
|
||
};
|
||
|
||
struct btle_adv_pdu buffer;
|
||
volatile bool quit;
|
||
|
||
uint8_t current = 0;
|
||
|
||
/****************************************************************************
|
||
* Private Functions
|
||
****************************************************************************/
|
||
|
||
uint8_t swapbits(uint8_t a)
|
||
{
|
||
/* reverse the bit order in a single byte */
|
||
|
||
uint8_t v = 0;
|
||
if (a & 0x80) v |= 0x01;
|
||
if (a & 0x40) v |= 0x02;
|
||
if (a & 0x20) v |= 0x04;
|
||
if (a & 0x10) v |= 0x08;
|
||
if (a & 0x08) v |= 0x10;
|
||
if (a & 0x04) v |= 0x20;
|
||
if (a & 0x02) v |= 0x40;
|
||
if (a & 0x01) v |= 0x80;
|
||
return v;
|
||
}
|
||
|
||
/* see BT Core Spec 4.0, Section 6.B.3.2 */
|
||
|
||
static inline void whiten(uint8_t len)
|
||
{
|
||
uint8_t i;
|
||
uint8_t * buf = (uint8_t *)&buffer;
|
||
|
||
/* initialize LFSR with current channel, set bit 6 */
|
||
|
||
uint8_t lfsr = channel[current] | 0x40;
|
||
|
||
while (len--)
|
||
{
|
||
uint8_t res = 0;
|
||
|
||
/* LFSR in "wire bit order" */
|
||
|
||
for (i = 1; i; i <<= 1)
|
||
{
|
||
if (lfsr & 0x01)
|
||
{
|
||
lfsr ^= 0x88;
|
||
res |= i;
|
||
}
|
||
|
||
lfsr >>= 1;
|
||
}
|
||
|
||
*(buf++) ^= res;
|
||
}
|
||
}
|
||
|
||
/* see BT Core Spec 4.0, Section 6.B.3.1.1 */
|
||
|
||
static inline void crc(uint8_t len, uint8_t * dst)
|
||
{
|
||
uint8_t i;
|
||
uint8_t * buf = (uint8_t *)&buffer;
|
||
|
||
/**
|
||
* initialize 24-bit shift register in "wire bit order"
|
||
* dst[0] = bits 23-16, dst[1] = bits 15-8, dst[2] = bits 7-0.
|
||
**/
|
||
|
||
dst[0] = 0xaa;
|
||
dst[1] = 0xaa;
|
||
dst[2] = 0xaa;
|
||
|
||
while (len--)
|
||
{
|
||
uint8_t d = *(buf++);
|
||
for (i = 1; i; i <<= 1, d >>= 1)
|
||
{
|
||
/**
|
||
* save bit 23 (highest-value),
|
||
* left-shift the entire register by one
|
||
**/
|
||
|
||
uint8_t t = dst[0] & 0x01; dst[0] >>= 1;
|
||
if (dst[1] & 0x01) dst[0] |= 0x80; dst[1] >>= 1;
|
||
if (dst[2] & 0x01) dst[1] |= 0x80; dst[2] >>= 1;
|
||
|
||
/**
|
||
* if the bit just shifted out (former bit 23) and the incoming
|
||
* data bit are not equal (i.e. bit_out ^ bit_in == 1) => toggle
|
||
* tap bits
|
||
*/
|
||
|
||
if (t != (d & 1))
|
||
{
|
||
/**
|
||
* toggle register tap bits (=XOR with 1)
|
||
* according to CRC polynom
|
||
**/
|
||
|
||
/* 0b11011010 inv. = 0b01011011 ^= x^6+x^4+x^3+x+1 */
|
||
|
||
dst[2] ^= 0xda;
|
||
|
||
/* 0b01100000 inv. = 0b00000110 ^= x^10+x^9 */
|
||
|
||
dst[1] ^= 0x60;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* change buffer contents to "wire bit order" */
|
||
|
||
static inline void swapbuf(uint8_t len)
|
||
{
|
||
uint8_t * buf = (uint8_t *)&buffer;
|
||
while (len--)
|
||
{
|
||
uint8_t a = *buf;
|
||
*(buf++) = swapbits(a);
|
||
}
|
||
}
|
||
|
||
int nrf24_cfg(int fd)
|
||
{
|
||
int error = 0;
|
||
|
||
uint32_t rf = NRF24L01_MIN_FREQ + frequency[current];
|
||
int32_t txpow = DEFAULT_TXPOWER;
|
||
|
||
nrf24l01_datarate_t datarate = RATE_1Mbps;
|
||
nrf24l01_retrcfg_t retrcfg =
|
||
{
|
||
.count = 0,
|
||
.delay = DELAY_1000us
|
||
};
|
||
|
||
uint32_t addrwidth = 4;
|
||
|
||
uint8_t pipes_en = (1 << 0); /* Only pipe #0 is enabled */
|
||
|
||
/**************************************************************************
|
||
* Define the pipe #0 parameters (AA enabled and dynamic payload length).
|
||
* 4 byte of access address, which is always 0x8E89BED6 for advertizing
|
||
* packets.
|
||
*
|
||
**************************************************************************/
|
||
|
||
nrf24l01_pipecfg_t pipe0cfg =
|
||
{
|
||
.en_aa = false,
|
||
.payload_length = 32,
|
||
.rx_addr =
|
||
{
|
||
swapbits(0x8e), swapbits(0x89), swapbits(0xbe), swapbits(0xd6)
|
||
}
|
||
};
|
||
|
||
nrf24l01_pipecfg_t *pipes_cfg[NRF24L01_PIPE_COUNT] =
|
||
{
|
||
&pipe0cfg, 0, 0, 0, 0, 0
|
||
};
|
||
|
||
nrf24l01_state_t primrxstate;
|
||
|
||
#ifdef CONFIG_WL_NRF24L01_RXSUPPORT
|
||
primrxstate = ST_RX;
|
||
#else
|
||
primrxstate = ST_POWER_DOWN;
|
||
#endif
|
||
|
||
/* Set radio parameters */
|
||
|
||
ioctl(fd, NRF24L01IOC_SETRETRCFG,
|
||
(unsigned long)((nrf24l01_retrcfg_t *)&retrcfg));
|
||
|
||
ioctl(fd, WLIOC_SETRADIOFREQ, (unsigned long)((uint32_t *)&rf));
|
||
ioctl(fd, WLIOC_SETTXPOWER, (unsigned long)((int32_t *)&txpow));
|
||
ioctl(fd, NRF24L01IOC_SETDATARATE,
|
||
(unsigned long)((nrf24l01_datarate_t *)&datarate));
|
||
|
||
ioctl(fd, NRF24L01IOC_SETADDRWIDTH,
|
||
(unsigned long)((uint32_t *)&addrwidth));
|
||
|
||
/* set advertisement address: 0x8E89BED6 (bit-reversed -> 0x6B7D9171) */
|
||
|
||
ioctl(fd, NRF24L01IOC_SETTXADDR,
|
||
(unsigned long)((uint8_t *)&pipe0cfg.rx_addr));
|
||
|
||
ioctl(fd, NRF24L01IOC_SETPIPESCFG,
|
||
(unsigned long)((nrf24l01_pipecfg_t **)&pipes_cfg));
|
||
ioctl(fd, NRF24L01IOC_SETPIPESENABLED,
|
||
(unsigned long)((uint8_t *)&pipes_en));
|
||
|
||
ioctl(fd, NRF24L01IOC_SETSTATE,
|
||
(unsigned long)((nrf24l01_state_t *)&primrxstate));
|
||
|
||
return error;
|
||
}
|
||
|
||
int nrf24_open(void)
|
||
{
|
||
int fd;
|
||
|
||
fd = open(DEV_NAME, O_RDWR);
|
||
|
||
if (fd < 0)
|
||
{
|
||
perror("Cannot open nRF24L01 device");
|
||
}
|
||
else
|
||
{
|
||
nrf24_cfg(fd);
|
||
}
|
||
|
||
return fd;
|
||
}
|
||
|
||
int nrf24_send(int wl_fd, uint8_t * buf, uint8_t len)
|
||
{
|
||
int ret;
|
||
|
||
wlinfo("send buffer len %d\n", len);
|
||
ret = write(wl_fd, buf, len);
|
||
if (ret < 0)
|
||
{
|
||
wlerr("Error sending packet\n");
|
||
return ret;
|
||
}
|
||
|
||
return OK;
|
||
}
|
||
|
||
static inline void generate_mac(void)
|
||
{
|
||
srand(time(NULL));
|
||
mac[0] = 0x42;
|
||
mac[1] = rand() % 256;
|
||
mac[2] = rand() % 256;
|
||
mac[3] = rand() % 256;
|
||
mac[4] = rand() % 256;
|
||
mac[5] = rand() % 256;
|
||
}
|
||
|
||
/****************************************************************************
|
||
* Broadcast an advertisement packet with a specific data type
|
||
* Standardized data types can be seen here:
|
||
* https://www.bluetooth.org/en-us/specification/assigned-
|
||
* numbers/generic-access-profile
|
||
*
|
||
****************************************************************************/
|
||
|
||
static void adv_packet(int wl_fd)
|
||
{
|
||
uint8_t namelen;
|
||
uint8_t pls = 0;
|
||
uint8_t i;
|
||
uint8_t ret;
|
||
#ifdef CONFIG_NRF24L01_BTLE_DHT11
|
||
int fd;
|
||
struct dhtxx_sensor_data_s dht_data;
|
||
struct nrf_service_data *temp;
|
||
struct nrf_service_data *hum;
|
||
fd = open("/dev/hum0", O_RDWR);
|
||
#endif
|
||
|
||
namelen = sizeof(adve_name);
|
||
|
||
/* hop channel */
|
||
|
||
ioctl(wl_fd, WLIOC_SETRADIOFREQ,
|
||
(unsigned long)((uint32_t *)&frequency[current]));
|
||
|
||
memcpy(&buffer.mac[0], &mac[0], 6);
|
||
|
||
/* add device descriptor chunk */
|
||
|
||
chunk(buffer, pls)->size = 0x02; /* chunk size: 2 */
|
||
chunk(buffer, pls)->type = 0x01; /* chunk type: device flags */
|
||
|
||
/* flags: LE-only, limited discovery mode */
|
||
|
||
chunk(buffer, pls)->data[0] = 0x06;
|
||
pls += 3;
|
||
|
||
/* add device name chunk */
|
||
|
||
chunk(buffer, pls)->size = namelen + 1;
|
||
chunk(buffer, pls)->type = 0x09;
|
||
for (i = 0; i < namelen; i++)
|
||
chunk(buffer, pls)->data[i] = adve_name[i];
|
||
pls += namelen + 2;
|
||
|
||
/* add custom data, if applicable */
|
||
|
||
#ifdef CONFIG_NRF24L01_BTLE_DHT11
|
||
ret = read(fd, &dht_data, sizeof(struct dhtxx_sensor_data_s));
|
||
if (ret < 0)
|
||
{
|
||
printf("Read error.\n");
|
||
printf("Sensor reported error %d\n", dht_data.status);
|
||
}
|
||
|
||
/* set temperature */
|
||
|
||
chunk(buffer, pls)->size = 3 + 1; /* chunk size */
|
||
|
||
/* chunk type */
|
||
|
||
chunk(buffer, pls)->type = 0x16;
|
||
temp = chunk(buffer, pls)->data;
|
||
temp->service_uuid = NRF_TEMPERATURE_SERVICE_UUID;
|
||
temp->value = (uint8_t)dht_data.temp;
|
||
pls += 3 + 2;
|
||
|
||
/* set humidity */
|
||
|
||
chunk(buffer, pls)->size = 3 + 1;
|
||
chunk(buffer, pls)->type = 0x16;
|
||
hum = chunk(buffer, pls)->data;
|
||
hum->service_uuid = NRF_ENVIRONMENTAL_SERVICE_UUID;
|
||
hum->value = (uint8_t)dht_data.hum;
|
||
pls += 3 + 2;
|
||
#else
|
||
chunk(buffer, pls)->size = 4 + 1;
|
||
chunk(buffer, pls)->type = 0xff; /* custom data */
|
||
chunk(buffer, pls)->data[0] = 't';
|
||
chunk(buffer, pls)->data[1] = 'e';
|
||
chunk(buffer, pls)->data[2] = 's';
|
||
chunk(buffer, pls)->data[3] = 't';
|
||
pls += 4 + 2;
|
||
sleep(1);
|
||
#endif
|
||
|
||
if (pls > 21)
|
||
{
|
||
wlerr("Total payload size must be 21 bytes or less.\n");
|
||
}
|
||
|
||
buffer.payload[pls] = 0x55;
|
||
buffer.payload[pls + 1] = 0x55;
|
||
buffer.payload[pls + 2] = 0x55;
|
||
|
||
/**************************************************************************
|
||
* The Payload field consists of AdvA and AdvData fields.
|
||
* The AdvA field shall contain the advertiser’s public or
|
||
* random device address as indicated by TxAdd.
|
||
* -----------------------------------------------------------
|
||
* | PDU | Type | RFU | TxAdd | RxAdd |Length RFU|
|
||
* |--------+---------+--------+--------+---------+----------|
|
||
* |(4 bits)| (2 bits)| (1 bit)| (1 bit)| (6 bits)| (2 bits) |
|
||
* -----------------------------------------------------------
|
||
* 0x42 = 0b1000010; include ADV_NONCONN_IND and TxAdd.
|
||
*
|
||
**************************************************************************/
|
||
|
||
buffer.pdu_type = 0x42;
|
||
|
||
/* set final payload size in header include MAC length */
|
||
|
||
buffer.pl_size = pls + 6;
|
||
|
||
/* calculate CRC over header+MAC+payload, append after payload */
|
||
|
||
uint8_t * outbuf = (uint8_t *)&buffer;
|
||
#ifdef CONFIG_DEBUG_WIRELESS
|
||
syslog(LOG_INFO, "payload len: %d\n ", pls);
|
||
nrf24_dumpbuffer("Hex Dump", outbuf, sizeof(buffer));
|
||
#endif
|
||
crc(pls + 8, outbuf + pls + 8);
|
||
whiten(pls + 11);
|
||
swapbuf(pls + 11);
|
||
#ifdef CONFIG_NRF24L01_BTLE_DHT11
|
||
close(fd);
|
||
#endif
|
||
nrf24_send(wl_fd, (uint8_t *)&buffer, pls + 11);
|
||
}
|
||
|
||
FAR void *advertise(FAR void *arg)
|
||
{
|
||
uint32_t wl_fd = *(uint32_t *)arg;
|
||
while (!quit)
|
||
{
|
||
if (current == 2)
|
||
{
|
||
current = 0;
|
||
}
|
||
|
||
adv_packet(wl_fd);
|
||
current++;
|
||
}
|
||
}
|
||
|
||
int nrf24_read(int wl_fd)
|
||
{
|
||
int ret;
|
||
uint32_t pipeno;
|
||
uint8_t rbuf[32];
|
||
|
||
ret = read(wl_fd, rbuf, sizeof(rbuf));
|
||
if (ret < 0)
|
||
{
|
||
perror("Error reading packet\n");
|
||
return ret;
|
||
}
|
||
|
||
if (ret == 0)
|
||
{
|
||
/* Should not happen ... */
|
||
|
||
printf("Packet payload empty !\n");
|
||
return ERROR;
|
||
}
|
||
|
||
/* Get the recipient pipe #
|
||
* (for demo purpose, as here the receiving pipe can only be pipe #0...)
|
||
*/
|
||
|
||
ioctl(wl_fd, NRF24L01IOC_GETLASTPIPENO,
|
||
(unsigned long)((uint32_t *)&pipeno));
|
||
|
||
rbuf[ret] = '\0'; /* end the string */
|
||
|
||
#ifdef CONFIG_DEBUG_WIRELESS
|
||
syslog(LOG_INFO, "Message received : (on pipe %d)\n", pipeno);
|
||
nrf24_dumpbuffer("Hex Dump", &rbuf[0], 32);
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
/****************************************************************************
|
||
* Public Functions
|
||
****************************************************************************/
|
||
|
||
int main(int argc, FAR char *argv[])
|
||
{
|
||
int ret;
|
||
struct sched_param param;
|
||
pthread_t thread;
|
||
pthread_attr_t attr;
|
||
char c;
|
||
int wl_fd;
|
||
quit = false;
|
||
current = 0;
|
||
wl_fd = nrf24_open();
|
||
if (wl_fd < 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
#ifdef EXAMPLES_NRF24L01_BTLE_RAND_MAC
|
||
generate_mac();
|
||
#endif
|
||
pthread_attr_init(&attr);
|
||
param.sched_priority = CONFIG_EXAMPLES_NRF24L01_BTLE_PRIORITY;
|
||
pthread_attr_setschedparam(&attr, ¶m);
|
||
pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_NRF24L01_BTLE_STACKSIZE);
|
||
|
||
ret = pthread_create(&thread, &attr, advertise, &wl_fd);
|
||
if (ret != 0)
|
||
{
|
||
printf("nrf24l01_btle: pthread_create failed: %d\n", ret);
|
||
return ERROR;
|
||
}
|
||
|
||
printf("nRF24L01+ wireless btle demo.\n");
|
||
printf("For basic Bluetooth Low Energy support using the nRF24L01+\n");
|
||
printf("sending on the advertising broadcast channel\n");
|
||
printf("Type 'q' to exit.\n\n");
|
||
|
||
pfds[0].fd = STDIN_FILENO;
|
||
pfds[0].events = POLLIN;
|
||
|
||
#ifdef CONFIG_WL_NRF24L01_RXSUPPORT
|
||
pfds[1].fd = wl_fd;
|
||
pfds[1].events = POLLIN;
|
||
#endif
|
||
while (!quit)
|
||
{
|
||
ret = poll(pfds, N_PFDS, -1);
|
||
if (ret < 0)
|
||
{
|
||
perror("Error polling console / wireless");
|
||
goto out;
|
||
}
|
||
|
||
if (pfds[0].revents & POLLIN)
|
||
{
|
||
read(STDIN_FILENO, &c, 1);
|
||
|
||
if (c == 'q')
|
||
{
|
||
/* Any non printable char -> exits */
|
||
|
||
quit = true;
|
||
printf ("Bye nRF24l01!\n");
|
||
sleep(2);
|
||
goto out;
|
||
}
|
||
}
|
||
|
||
if (!quit && (pfds[1].revents & POLLIN))
|
||
{
|
||
nrf24_read(wl_fd);
|
||
}
|
||
}
|
||
|
||
out:
|
||
close(wl_fd);
|
||
return 0;
|
||
}
|