├── .gitignore
├── Arduino
    └── bb_ble
    │   └── bb_ble.ino
├── LICENSE
├── README.md
└── node.js
    ├── nrf.js
    └── package.json


/.gitignore:
--------------------------------------------------------------------------------
1 | node.js/node_modules/
2 | 
3 | 


--------------------------------------------------------------------------------
/Arduino/bb_ble/bb_ble.ino:
--------------------------------------------------------------------------------
  1 | #include <DHT.h>
  2 | 
  3 | // based off of: http://dmitry.gr/index.php?r=05.Projects&proj=11.%20Bluetooth%20LE%20fakery
  4 | 
  5 | //#include <stdio.h>
  6 | //#include <avr/io.h>
  7 | //#include <avr/interrupt.h>
  8 | //#include <avr/sleep.h>
  9 | //#define F_CPU	8000000
 10 | //#include <avr/delay.h>
 11 | //
 12 | //#include <stdint.h>
 13 | 
 14 | #define PIN_CE	8 //Output
 15 | #define PIN_nCS	7 //Output
 16 | 
 17 | 
 18 | #define MY_MAC_0	0xEF
 19 | #define MY_MAC_1	0xFF
 20 | #define MY_MAC_2	0xC0
 21 | #define MY_MAC_3	0xAA
 22 | #define MY_MAC_4	0x18
 23 | #define MY_MAC_5	0x00
 24 | 
 25 | #define DHTPIN 2
 26 | #define DHTTYPE DHT22
 27 | 
 28 | //ISR(PCINT0_vect)
 29 | //{
 30 | //	//useless
 31 | //}
 32 | 
 33 | void btLeCrc(const uint8_t* data, uint8_t len, uint8_t* dst){
 34 | 
 35 | 	uint8_t v, t, d;
 36 | 
 37 | 	while(len--){
 38 | 	
 39 | 		d = *data++;
 40 | 		for(v = 0; v < 8; v++, d >>= 1){
 41 | 		
 42 | 			t = dst[0] >> 7;
 43 | 			
 44 | 			dst[0] <<= 1;
 45 | 			if(dst[1] & 0x80) dst[0] |= 1;
 46 | 			dst[1] <<= 1;
 47 | 			if(dst[2] & 0x80) dst[1] |= 1;
 48 | 			dst[2] <<= 1;
 49 | 			
 50 | 		
 51 | 			if(t != (d & 1)){
 52 | 			
 53 | 				dst[2] ^= 0x5B;
 54 | 				dst[1] ^= 0x06;
 55 | 			}
 56 | 		}	
 57 | 	}
 58 | }
 59 | 
 60 | uint8_t  swapbits(uint8_t a){
 61 | 
 62 | 	uint8_t v = 0;
 63 | 	
 64 | 	if(a & 0x80) v |= 0x01;
 65 | 	if(a & 0x40) v |= 0x02;
 66 | 	if(a & 0x20) v |= 0x04;
 67 | 	if(a & 0x10) v |= 0x08;
 68 | 	if(a & 0x08) v |= 0x10;
 69 | 	if(a & 0x04) v |= 0x20;
 70 | 	if(a & 0x02) v |= 0x40;
 71 | 	if(a & 0x01) v |= 0x80;
 72 | 
 73 | 	return v;
 74 | }
 75 | 
 76 | void btLeWhiten(uint8_t* data, uint8_t len, uint8_t whitenCoeff){
 77 | 
 78 | 	uint8_t  m;
 79 | 	
 80 | 	while(len--){
 81 | 	
 82 | 		for(m = 1; m; m <<= 1){
 83 | 		
 84 | 			if(whitenCoeff & 0x80){
 85 | 				
 86 | 				whitenCoeff ^= 0x11;
 87 | 				(*data) ^= m;
 88 | 			}
 89 | 			whitenCoeff <<= 1;
 90 | 		}
 91 | 		data++;
 92 | 	}
 93 | }
 94 | 
 95 | static inline uint8_t btLeWhitenStart(uint8_t chan){
 96 | 	//the value we actually use is what BT'd use left shifted one...makes our life easier
 97 | 
 98 | 	return swapbits(chan) | 2;	
 99 | }
100 | 
101 | void btLePacketEncode(uint8_t* packet, uint8_t len, uint8_t chan){
102 | 	//length is of packet, including crc. pre-populate crc in packet with initial crc value!
103 | 
104 | 	uint8_t i, dataLen = len - 3;
105 | 	
106 | 	btLeCrc(packet, dataLen, packet + dataLen);
107 | 	for(i = 0; i < 3; i++, dataLen++) packet[dataLen] = swapbits(packet[dataLen]);
108 | 	btLeWhiten(packet, len, btLeWhitenStart(chan));
109 | 	for(i = 0; i < len; i++) packet[i] = swapbits(packet[i]);
110 | 	
111 | }
112 | 
113 | uint8_t spi_byte(uint8_t byte){
114 | 
115 | //	uint8_t i = 0;
116 | //	
117 | //	do{
118 | //		digitalWrite(11, LOW); //PORTB &=~ (uint8_t)(1 << 6);
119 | //		if(byte & 0x80) digitalWrite(11, HIGH); //PORTB |= (uint8_t)(1 << 6);
120 | //		digitalWrite(13, HIGH); //CLK |= (uint8_t)(1 << 4);
121 | //		byte <<= 1;
122 | ////		if(PINA & (uint8_t)32) byte++;
123 | ////                delay(10);
124 | //		digitalWrite(13, LOW);//CLK &=~ (uint8_t)(1 << 4);
125 | //	
126 | //	}while(--i);
127 | 
128 | 
129 | //      Serial.println("SPI BYTE");
130 |         shiftOut(11, 13, MSBFIRST, byte);
131 | 
132 | 	return byte;
133 | }
134 | 
135 | void nrf_cmd(uint8_t cmd, uint8_t data)
136 | {
137 | 	digitalWrite(PIN_nCS, LOW); //cbi(PORTB, PIN_nCS);
138 | 	spi_byte(cmd);
139 | 	spi_byte(data);
140 | 	digitalWrite(PIN_nCS, HIGH); // sbi(PORTB, PIN_nCS); //Deselect chip
141 | }
142 | 
143 | void nrf_simplebyte(uint8_t cmd)
144 | {
145 | 	digitalWrite(PIN_nCS, LOW); //cbi(PORTB, PIN_nCS);
146 | 	spi_byte(cmd);
147 | 	digitalWrite(PIN_nCS, HIGH); //sbi(PORTB, PIN_nCS);
148 | }
149 | 
150 | void nrf_manybytes(uint8_t* data, uint8_t len){
151 | 
152 |         digitalWrite(PIN_nCS, LOW); // cbi(PORTB, PIN_nCS);
153 |         do{
154 | 	
155 | 		spi_byte(*data++);
156 | 	
157 | 	}while(--len);
158 | 	digitalWrite(PIN_nCS, HIGH); // sbi(PORTB, PIN_nCS);
159 | }
160 | 
161 | //void fob_init (void)
162 | //{
163 | //	DDRA = (uint8_t)~(1<<5);
164 | //	DDRB = 0b00000110;
165 | //	PORTA = 0b10001111;
166 | //	cbi(PORTB, PIN_CE);
167 | //	TCCR0B = (1<<CS00);
168 | //	MCUCR = (1<<SM1)|(1<<SE);
169 | //	sei();
170 | //}
171 | 
172 | DHT dht(DHTPIN, DHTTYPE);
173 | 
174 | void setup() {
175 |   // set the digital pin as output:
176 |   pinMode(PIN_nCS, OUTPUT);
177 |   pinMode(PIN_CE, OUTPUT);
178 |   pinMode(11, OUTPUT);
179 |   pinMode(13, OUTPUT);
180 |   
181 |   Serial.begin(9600);
182 |   Serial.println("HELLO");
183 |   
184 |   dht.begin();
185 | }
186 | 
187 | void loop() { //int main (void)
188 | //{
189 | 	static const uint8_t chRf[] = {2, 26,80};
190 | 	static const uint8_t chLe[] = {37,38,39};
191 | 	uint8_t i, L, ch = 0;
192 | 	uint8_t buf[32];
193 | 	
194 | //	fob_init();
195 | 	
196 | //	DDRA |= 4;
197 | //	PORTA |= 4;
198 | 	
199 | 	nrf_cmd(0x20, 0x12);	//on, no crc, int on RX/TX done
200 | 	nrf_cmd(0x21, 0x00);	//no auto-acknowledge
201 | 	nrf_cmd(0x22, 0x00);	//no RX
202 | 	nrf_cmd(0x23, 0x02);	//5-byte address
203 | 	nrf_cmd(0x24, 0x00);	//no auto-retransmit
204 | 	nrf_cmd(0x26, 0x06);	//1MBps at 0dBm
205 | 	nrf_cmd(0x27, 0x3E);	//clear various flags
206 | 	nrf_cmd(0x3C, 0x00);	//no dynamic payloads
207 | 	nrf_cmd(0x3D, 0x00);	//no features
208 | 	nrf_cmd(0x31, 32);	//always RX 32 bytes
209 | 	nrf_cmd(0x22, 0x01);	//RX on pipe 0
210 | 	
211 | 	buf[0] = 0x30;			//set addresses
212 | 	buf[1] = swapbits(0x8E);
213 | 	buf[2] = swapbits(0x89);
214 | 	buf[3] = swapbits(0xBE);
215 | 	buf[4] = swapbits(0xD6);
216 | 	nrf_manybytes(buf, 5);
217 | 	buf[0] = 0x2A;
218 | 	nrf_manybytes(buf, 5);
219 | 
220 | 	
221 | 	
222 | 	while(1){
223 |   
224 |                 float h = dht.readHumidity() ;
225 |                 float t = dht.readTemperature();
226 | 		
227 | 		L = 0;
228 | 		
229 | 		buf[L++] = 0x42;	//PDU type, given address is random
230 |                 buf[L++] = 0x11 /*+ 8*/ + 10; //17 bytes of payload
231 | 		
232 | 		buf[L++] = MY_MAC_0;
233 | 		buf[L++] = MY_MAC_1;
234 | 		buf[L++] = MY_MAC_2;
235 | 		buf[L++] = MY_MAC_3;
236 | 		buf[L++] = MY_MAC_4;
237 | 		buf[L++] = MY_MAC_5;
238 | 		
239 | 		buf[L++] = 2;		//flags (LE-only, limited discovery mode)
240 | 		buf[L++] = 0x01;
241 | 		buf[L++] = 0x05;
242 | 		
243 | 		buf[L++] = 7;// + 8;
244 | 		buf[L++] = 0x08;
245 | 
246 | 		buf[L++] = 'n';
247 | 		buf[L++] = 'R';
248 | 		buf[L++] = 'F';
249 | 		buf[L++] = ' ';
250 | 		buf[L++] = 'L';
251 | 		buf[L++] = 'E';
252 | 
253 |                 buf[L++] = 9;
254 |                 buf[L++] = 0xff;
255 |                 memcpy(&buf[L], &h, 4);
256 |                 L += 4;
257 |                 memcpy(&buf[L], &t, 4);
258 |                 L += 4;
259 |                 
260 | 		
261 | 		buf[L++] = 0x55;	//CRC start value: 0x555555
262 | 		buf[L++] = 0x55;
263 | 		buf[L++] = 0x55;
264 | 		
265 | 		
266 | 		if(++ch == sizeof(chRf)) ch = 0;
267 | 		
268 | 		nrf_cmd(0x25, chRf[ch]);
269 | 		nrf_cmd(0x27, 0x6E);	//clear flags
270 | 
271 | 		btLePacketEncode(buf, L, chLe[ch]);
272 | 		
273 | 		nrf_simplebyte(0xE2); //Clear RX Fifo
274 | 		nrf_simplebyte(0xE1); //Clear TX Fifo
275 | 	
276 |                 digitalWrite(PIN_nCS, LOW); // cbi(PORTB, PIN_nCS);
277 | 		spi_byte(0xA0);
278 | 		for(i = 0 ; i < L ; i++) spi_byte(buf[i]);
279 |                 digitalWrite(PIN_nCS, HIGH); // sbi(PORTB, PIN_nCS);
280 | 	
281 | 		nrf_cmd(0x20, 0x12);	//tx on
282 |                 digitalWrite(PIN_CE, HIGH); // sbi(PORTB, PIN_CE);	 //do tx
283 | 		delay(10); //delay_ms(10);
284 |                 digitalWrite(PIN_CE, LOW); // cbi(PORTB, PIN_CE);	(in preparation of switching to RX quickly)
285 | 	}
286 | 	
287 | 	
288 | //	return 0;
289 | }
290 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013 Sandeep Mistry
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | arduino-nRF24L01-BLE
2 | ====================
3 | 
4 | [![Analytics](https://ga-beacon.appspot.com/UA-56089547-1/sandeepmistry/arduino-nRF24L01-BLE?pixel)](https://github.com/igrigorik/ga-beacon)
5 | 
6 | Example of using an Arduino and a nRF24L01+ to fake BLE advertisement
7 | 


--------------------------------------------------------------------------------
/node.js/nrf.js:
--------------------------------------------------------------------------------
 1 | var noble = require('noble');
 2 | 
 3 | noble.on('stateChange', function(state) {
 4 |   if (state === 'poweredOn') {
 5 |     noble.startScanning([], true);
 6 |   } else {
 7 |     noble.stopScanning();
 8 |   }
 9 | });
10 | 
11 | noble.on('discover', function(peripheral) {
12 |   if (peripheral.advertisement.localName !== 'nRF LE') {
13 |     return;
14 |   }
15 | 
16 |   console.log('peripheral discovered:');
17 |   console.log('\thello my local name is:');
18 |   console.log('\t\t' + peripheral.advertisement.localName);
19 |   console.log('\there is my manufacturer data:');
20 |   var manufacturerData = peripheral.advertisement.manufacturerData; 
21 |   var humidity = manufacturerData.readFloatLE(0);
22 |   var temperature = manufacturerData.readFloatLE(4);
23 |   console.log('\t\t' + manufacturerData.toString('hex'));
24 |   console.log('\t\thumidity = ' + humidity.toFixed(1) + '%');
25 |   console.log('\t\ttemperature = ' + temperature.toFixed(1) + ' C');
26 |   console.log();
27 | });
28 | 
29 | 


--------------------------------------------------------------------------------
/node.js/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "nrf",
3 |   "version": "0.0.0",
4 |   "main": "nrf.js",
5 |   "dependencies": {
6 |     "noble": "~0.2.2"
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------