nRF24L01RF Module Tutorial

Posted by: Admin Gelobalsys | 20/04/2020 | Kategori: Tutorial | 104 kali dibaca | Rating: 125

Sebelumnya, kami membahas tutorial tentang ESP8266-01 (ESP8266 Setup Tutorial), modul WiFi footprint kecil yang dirancang untuk memungkinkan pengguna dengan mudah menambahkan fungsionalitas WiFi ke proyek mereka. Hari ini, kita akan membahas modul RF nRF24L01 +, semacam modul saudara ke ESP8266 ESP-01 yang memungkinkan pengguna untuk menambahkan komunikasi frekuensi radio nirkabel ke proyek mereka. The nRF24L01 + dan ESP8266 ESP-01 berbagi faktor bentuk yang sama dan tata letak pin (dan bahkan terlihat sama dari jauh!) Tetapi dikontrol dan berfungsi sangat berbeda. Dalam tutorial ini, kami berharap dapat memperkenalkan dasar-dasar penggunaan modul RF ini, sambil juga menjelaskan bagaimana berkomunikasi dengan modul RF lainnya dan mikrokontroler. Untuk keperluan tutorial ini, kami akan mendemonstrasikan interfacing modul dengan mikrokontroler Arduino Uno.

The nRF24L01 + didasarkan pada Nordic Semiconductor nRF24L01 + "RF transceiver IC untuk band 2.4GHz ISM (Industrial, Scientific, and Medical)."

Spesifikasi:
2.4GHz Operasi Band ISM

3.3V Nominal Vcc (input toleran 5V)

Pengaturan Tegangan pada chip

250 kbps, 1 Mbps, 2Mbps pada kecepatan data transmisi udara

Pengoperasian daya sangat rendah

Undian arus rendah (900nA - 26μA)

6 pipa data

Pertama, kami akan membahas bagian perangkat keras menggunakan modul. Mirip dengan ESP-01, modul RF memiliki antarmuka header pria 4 x 2. Pinout yang sebenarnya, bagaimanapun, berbeda dari modul ESP-01 karena modul RF menggunakan protokol komunikasi yang berbeda - SPI - untuk berkomunikasi dengan perangkat lain. Jika Anda ingin mempelajari lebih lanjut tentang protokol SPI, lihat Tutorial Protokol Komunikasi Arduino kami!

Pinout untuk modul RF dirangkum dalam diagram berikut dari Addicore.

Tutorial Arduino

Modul RF diatur untuk bertindak sebagai budak SPI, yang artinya hanya dapat digunakan dengan perangkat yang memiliki jalur komunikasi SPI khusus. Ini berarti bahwa pin SPI MOSI, MISO, dan SCK (clock) yang ditunjukkan pada diagram harus dihubungkan ke pin yang sesuai pada mikrokontroler. Di Arduino, pin ini adalah sebagai berikut:

MOSI: Arduino D11
MISO: Arduino D12
SCK: Arduino D13
CE dan pin CSN dapat dihubungkan ke pin GPIO keluaran apa pun di Arduino. Dalam perangkat lunak, mereka ditentukan secara tepat ketika komunikasi SPI diinisialisasi.

Berikut ini contohnya seperti apa hubungan antara modul RF dan Arduino:

Untuk antarmuka Arduino dengan modul, kami akan menggunakan perpustakaan RF24 TMRh20, yang dengan mudah mengemas komunikasi tingkat rendah antara modul RF dan MCU ke dalam kelas C ++ yang mudah digunakan.

Sebelum kita menyelami penggunaan modul, pertama-tama kita akan membahas beberapa dasar di balik operasinya. Di Amerika Serikat, perangkat yang menggunakan gelombang frekuensi radio terbatas pada rentang frekuensi yang dialokasikan oleh FCC. Pita ISM adalah salah satu rentang yang disediakan untuk instrumen ilmiah dan medis, dan modul RF kami berkomunikasi melalui frekuensi dalam rentang ISM ini. Untuk keperluan bekerja dengan modul RF, tidak perlu mengetahui rincian frekuensi ini atau bagaimana tepatnya komunikasi melalui frekuensi ini terjadi. Kami sebaliknya akan fokus pada berbagai aspek komunikasi RF nirkabel yang dapat dikontrol.

Jika Anda menggulir melalui dokumentasi perpustakaan RF24, Anda akan melihat bahwa ada banyak parameter yang dapat diatur. Beberapa parameter utama adalah

Saluran: saluran frekuensi spesifik tempat komunikasi akan terjadi (frekuensi dipetakan ke bilangan bulat antara 0 dan 125
Pipa Baca: pipa baca adalah alamat 24, 32, atau 40-bit yang unik darimana modul membaca data
Pipa Penulisan: pipa penulisan adalah alamat unik di mana modul menulis data
Level Power Amplifier (PA): level PA mengatur daya tarik chip dan dengan demikian daya transmisi. Untuk keperluan tutorial ini (gunakan dengan Arduino) kami akan menggunakan pengaturan daya minimum.
Halaman dokumentasi perpustakaan RF24 menyediakan beberapa contoh kode untuk memulai dengan perpustakaan. Contoh proyek dapat ditemukan di sini: http://tmrh20.github.io/RF24/examples.html

Kami akan melihat bagaimana parameter yang tercantum di atas diinisialisasi dalam kode Arduino "Persiapan" yang dapat ditemukan di sini:

http://tmrh20.github.io/RF24/GettingStarted_8ino-example.html

GettingStarted.ino

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

/*

 

* Getting Started example sketch for nRF24L01+ radios

 

* This is a very basic example of how to send data from one node to another

 

* Updated: Dec 2014 by TMRh20

 

*/

 

#include

 

#include "RF24.h"

 

/****************** User Config ***************************/

 

/***      Set this radio as radio number 0 or 1         ***/

 

bool radioNumber = 0;

 

/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */

 

RF24 radio(7,8);

 

/**********************************************************/

 

byte addresses[][6] = {"1Node","2Node"};

 

// Used to control whether this node is sending or receiving

 

bool role = 0;

 

void setup() {

 

Serial.begin(115200);

 

Serial.println(F("RF24/examples/GettingStarted"));

 

Serial.println(F("*** PRESS 'T' to begin transmitting to the other node"));

 

 radio.begin();

 

// Set the PA Level low to prevent power supply related issues since this is a

 

// getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default.

 

radio.setPALevel(RF24_PA_LOW);

 

 // Open a writing and reading pipe on each radio, with opposite addresses

 

if(radioNumber){

 

  radio.openWritingPipe(addresses[1]);

 

  radio.openReadingPipe(1,addresses[0]);

 

}else{

 

  radio.openWritingPipe(addresses[0]);

 

  radio.openReadingPipe(1,addresses[1]);

 

}

 

 // Start the radio listening for data

 

radio.startListening();

 

}

 

void loop() {

 

/****************** Ping Out Role ***************************/

 

if (role == 1)  {

 

 

 

  radio.stopListening();                                    // First, stop listening so we can talk.

 

 

 

 

 

  Serial.println(F("Now sending"));

 

  unsigned long start_time = micros();                             // Take the time, and send it.  This will block until complete

 

   if (!radio.write( &start_time, sizeof(unsigned long) )){

 

     Serial.println(F("failed"));

 

   }

 

     

 

  radio.startListening();                                    // Now, continue listening

 

 

 

  unsigned long started_waiting_at = micros();               // Set up a timeout period, get the current microseconds

 

  boolean timeout = false;                                   // Set up a variable to indicate if a response was received or not

 

 

 

  while ( ! radio.available() ){                             // While nothing is received

 

    if (micros() - started_waiting_at > 200000 ){            // If waited longer than 200ms, indicate timeout and exit while loop

 

        timeout = true;

 

        break;

 

    }     

 

  }

 

     

 

  if ( timeout ){                                             // Describe the results

 

      Serial.println(F("Failed, response timed out."));

 

  }else{

 

      unsigned long got_time;                                 // Grab the response, compare, and send to debugging spew

 

      radio.read( &got_time, sizeof(unsigned long) );

 

      unsigned long end_time = micros();

 

     

 

      // Spew it

 

      Serial.print(F("Sent "));

 

      Serial.print(start_time);

 

      Serial.print(F(", Got response "));

 

      Serial.print(got_time);

 

      Serial.print(F(", Round-trip delay "));

 

      Serial.print(end_time-start_time);

 

      Serial.println(F(" microseconds"));

 

  }

 

  // Try again 1s later

 

  delay(1000);

 

}

 

/****************** Pong Back Role ***************************/

 

if ( role == 0 )

 

{

 

  unsigned long got_time;

 

 

 

  if( radio.available()){

 

                                                                  // Variable for the received timestamp

 

    while (radio.available()) {                                   // While there is data ready

 

      radio.read( &got_time, sizeof(unsigned long) );             // Get the payload

 

    }

 

  

 

    radio.stopListening();                                        // First, stop listening so we can talk  

 

    radio.write( &got_time, sizeof(unsigned long) );              // Send the final one back.     

 

    radio.startListening();                                       // Now, resume listening so we catch the next packets.    

 

    Serial.print(F("Sent response "));

 

    Serial.println(got_time);

 

 }

 

}

 

/****************** Change Roles via Serial Commands ***************************/

 

if ( Serial.available() )

 

{

 

  char c = toupper(Serial.read());

 

  if ( c == 'T' && role == 0 ){     

 

    Serial.println(F("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK"));

 

    role = 1;                  // Become the primary transmitter (ping out)

 

 

 

 }else

 

  if ( c == 'R' && role == 1 ){

 

    Serial.println(F("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK"));     

 

     role = 0;                // Become the primary receiver (pong back)

 

     radio.startListening();

 

    

 

  }

 

}

 

} // Loop

Dua baris pertama yang menarik adalah dua arahan C ++ # include di bagian atas file: satu untuk menyertakan pustaka Arduino SPI (ingat dari sebelumnya bahwa modul RF menggunakan SPI untuk berkomunikasi dengan Arduino), dan satu untuk menyertakan RF24 Perpustakaan.

#termasuk
#termasuk “RF24.h”

Baris berikutnya yang menarik adalah garis yang membangun objek RF24: radio RF24 (7,8); Dua parameter yang diteruskan ke konstruktor adalah pin digital CE dan CSN yang terhubung ke modul. Meskipun pin MOSI, MISO, dan SCK harus masing-masing pin digital 11, 12, dan 13, pin CE dan CSN dapat berupa dua pin digital!

Selanjutnya kita akan melihat alamat pipa untuk membaca dan menulis. Seperti yang mungkin bisa Anda tebak, alamat pipa tulis dan baca ditukar antara dua radio yang berkomunikasi satu sama lain, karena pipa penulisan untuk masing-masing radio adalah pipa baca untuk yang lain. Alamat radio berukuran 24, 32, atau 40 bit. Dalam kode contoh, alamat-alamat ini dikonversi dari string string C ++, tetapi Anda juga dapat menentukannya dalam format biner atau heksadesimal. Misalnya, alamat 40-bit yang ditentukan sebagai nilai hex mungkin 0xF0F0F0F0F0. Praktik pemrograman yang baik untuk menyimpan penulisan dan membaca alamat pipa adalah dengan meletakkan dua nilai di dalam array. Dalam kode contoh, alamat pipa penulisan dan bacaan disimpan dalam array byte bernama "alamat."

Pada metode void setup (), kita perlu memberikan instruksi untuk menginisialisasi radio dengan parameter pipa alamat dan parameter lainnya juga.

Pertama, metode RF24 :: begin () dipanggil. Begin () harus dipanggil sebelum salah satu metode perpustakaan RF24 lainnya dipanggil pada objek radio karena ia menginisialisasi pengoperasian chip RF.

Selanjutnya, level power amplifier (PA) diatur dengan memanggil metode RF24 :: setPALevel (). Pustaka RF24 memberikan nilai konstan yang berbeda untuk menentukan level power amplifier. Level PA yang lebih tinggi berarti bahwa modul dapat berkomunikasi dengan jarak yang lebih jauh, tetapi pada gilirannya menarik lebih banyak arus selama operasi. Untuk digunakan dalam sketsa persiapan, kami meneruskan konstanta RF_24_LOW sebagai parameter ke metode setPALevel () karena jarak antara dua modul yang berkomunikasi tidak akan terlalu besar. Secara umum, ketika menggunakan modul RF dengan papan Arduino, mungkin ide yang bagus untuk menjaga level PA serendah mungkin untuk mengurangi penarikan arus pada catu daya yang diatur Arduino.

Selanjutnya, kita akan melihat bagaimana menginisialisasi tulisan dan membaca pipa. Kami telah mendefinisikan pipa penulisan dan bacaan sebagai beberapa nilai byte. Kita sekarang harus meneruskan definisi ini ke objek radio sehingga ia juga memiliki pengetahuan tentang penulisan dan membaca alamat pipa. Pipa penulisan diatur dengan metode openWritingPipe (), dan pipa baca diatur dengan metode openReadingPipe (). Contoh membuka pipa menulis dan membaca adalah:

radio.openWritingPipe (alamat [1]);

radio.openReadingPipe (1, alamat [0]);

Perhatikan bahwa metode openReadingPipe () harus melewati parameter integer tambahan yang menjelaskan pipa bacaan mana yang sedang diinisialisasi. Ini karena modul RF dapat memiliki hingga 6 pipa baca terbuka pada waktu tertentu!

Kode contoh dengan tepat menetapkan nilai pipa baca dan tulis melalui nilai peran boolean. Berdasarkan nilai peran, program menentukan apakah modul RF adalah perangkat ping atau pong. Kode serupa dapat digunakan di proyek Anda juga. Pastikan saja bahwa alamat membaca dan menulis ditukar pada dua perangkat, atau tidak ada data yang akan dikirim atau dibaca!

Modul radio diinstruksikan untuk mulai mendengarkan dengan memanggil metode RF24 :: startListening (). Penting untuk dicatat bahwa pipa baca harus diinisialisasi sebelum modul RF diinstruksikan untuk mulai mendengarkan data (yaitu metode openReadingPipe () harus dipanggil sebelum metode startListening ()!)

Demikian pula, kelas RF24 juga menyediakan metode stopListening (), yang harus dipanggil sebelum modul radio dapat mulai menulis.

Dalam kode contoh, Anda mungkin memperhatikan bahwa modul radio diinstruksikan untuk memeriksa data yang masuk melalui penggunaan metode RF24 :: available (). Ini mirip dengan metode Serial :: available () dan SoftwareSerial :: available () yang telah kita lihat sebelumnya — jika data tersedia melalui koneksi RF, metode yang tersedia () mengembalikan true, dan data dapat dibaca.

Akhirnya, kelas RF24 menyediakan metode untuk benar-benar menulis dan membaca data. Parameter untuk metode RF24 :: write () dan RF24 :: read () adalah (1) pointer ke variabel dengan tipe yang sama dengan data yang sedang dikirim, dan (2) ukuran data yang dikirim. Dalam metode baca (), variabel yang menjadi titik penunjuk menerima data yang sedang dibaca. Dalam metode write (), variabel yang menjadi titik penunjuk menyimpan data yang sedang ditulis. Dalam kedua metode, sangat penting untuk memastikan bahwa pointer menunjuk ke variabel dari jenis yang sama dengan data yang dikirim, dan bahwa ukuran yang diteruskan ke metode sebenarnya mencerminkan ukuran data. Melewati jenis atau nilai ukuran yang salah ke metode baca () dan tulis () dapat menghasilkan pemotongan nilai yang tidak diinginkan, yang dapat membuat data yang dikirimkan tidak berguna. Dalam kode "Getting Started", data yang sedang dikirim adalah lama yang tidak ditandatangani. Oleh karena itu penunjuk yang diteruskan sebagai argumen ke metode read () dan write () menunjuk ke variabel juga dari tipe unsigned long. Juga jelas bahwa ukuran data yang dikirim selalu seukuran panjang yang tidak ditandatangani. Dalam situasi ini, ukuran tidak perlu diteruskan secara eksplisit sebagai bilangan bulat, dan argumen ukuran dapat hanya berupa sizeof (unsigned long).

Satu-satunya parameter yang tidak mencakup kode "Persiapan" adalah saluran komunikasi. Jika saluran tertentu diinginkan (misalnya, jika Anda memiliki beberapa jaringan RF yang tidak ingin saling mengganggu), maka saluran tersebut dapat diatur dengan mengirimkan parameter integer 8-bit ke RF24 :: setChannel () metode. Contoh dari kode ini mungkin radio.setChannel (10);

Coba sambungkan dua modul RF ke dua papan Arduino yang terpisah dan unggah kode "Memulai" di masing-masing (untuk salah satu papan, Anda harus mengubah peran boolean menjadi 1). Anda seharusnya sekarang dapat mengirim dan menerima kembali pesan dengan waktu ping yang sesuai! Berikut adalah gambar dua monitor serial "ping" dan "pong":

loading...

Apakah pendapat Anda tentang artikel ini?

Share:


KATEGORI


POST POPULER

Loop sensor

by: Admin Gelobalsys | 15 January 2020

LPR PARKING SYSTEM

by: Admin Gelobalsys | 13 February 2020

Pemasangan Dispenser

by: Admin Gelobalsys | 15 January 2020

parking equipment sistem

by: Admin Gelobalsys | 08 April 2020

EQUIPMENT PARKING SYSTEM By PT. GEMADUNIAKITA

by: Admin Gelobalsys | 16 February 2020

MANLESS PARKING SYSTEM

by: Admin Gelobalsys | 13 February 2020

Sistem Aplikasi Parkir

by: Admin Gelobalsys | 08 April 2020

INTERFACE SISTEM PARKIR MAINLESS

by: Admin Gelobalsys | 07 March 2020

Data maintenance IT Support

by: Admin Gelobalsys | 07 March 2020

LOOP DETECTOR KENDARAAN

by: Admin Gelobalsys | 10 April 2020

POST TERBARU

Unlimited SSD Hosting

by: Admin Gelobalsys | 19 August 2020

Subscreber Chanel Youtube

by: Admin Gelobalsys | 07 August 2020

Forwarding DNS Server Mikrotik

by: Admin Gelobalsys | 17 May 2020

nRF24L01RF Module Tutorial

by: Admin Gelobalsys | 20 April 2020

Harga Hardisk Seagate 1TB

by: Admin Gelobalsys | 18 April 2020

IT Support Services and Software Development Solutions

by: Admin Gelobalsys | 18 April 2020

CCTV HIKVISION

by: Admin Gelobalsys | 18 April 2020

IT Support Software hardware Jaringan server

by: Admin Gelobalsys | 18 April 2020

Tiket Dispenser Mainless Parkir

by: Admin Gelobalsys | 18 April 2020

Sistem Gate Cluster

by: Admin Gelobalsys | 10 April 2020