Skip to main content

DIY Arduino Transmitter and receiver

By Vishu bhardwaj

 



Hey,

In today's blog we are going to make Transmitter and receiver using Arduino.


REQUIRED STUFF FOR TRANSMITTER:

Arduino pro mini

2 × joystick module

2 × toggle switch

Potentiometer

NRF24L01 Transceiver

HT7333 3.3v voltage regulator

AMS1117 3.3v Voltage regulator


SCHEMATIC FOR TRANSMITTER:


CODE FOR TRANSMITTER:

  1. #include <SPI.h>
  2. #include <nRF24L01.h>
  3. #include <RF24.h>
  4. #include <Wire.h>
  7. // Define the digital inputs
  8. #define jB1 1 // Joystick button 1
  9. #define jB2 0 // Joystick button 2
  10. #define t1 7 // Toggle switch 1
  11. #define t2 4 // Toggle switch 1
  12. #define b1 8 // Button 1
  13. #define b2 9 // Button 2
  14. #define b3 2 // Button 3
  15. #define b4 3 // Button 4
  17. const int MPU = 0x68; // MPU6050 I2C address
  18. float AccX, AccY, AccZ;
  19. float GyroX, GyroY, GyroZ;
  20. float accAngleX, accAngleY, gyroAngleX, gyroAngleY;
  21. float angleX, angleY;
  22. float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY;
  23. float elapsedTime, currentTime, previousTime;
  24. int c = 0;
  27. RF24 radio(5, 6); // nRF24L01 (CE, CSN)
  28. const byte address[6] = "00001"; // Address
  30. // Max size of this struct is 32 bytes - NRF24L01 buffer limit
  31. struct Data_Package {
  32. byte j1PotX;
  33. byte j1PotY;
  34. byte j1Button;
  35. byte j2PotX;
  36. byte j2PotY;
  37. byte j2Button;
  38. byte pot1;
  39. byte pot2;
  40. byte tSwitch1;
  41. byte tSwitch2;
  42. byte button1;
  43. byte button2;
  44. byte button3;
  45. byte button4;
  46. };
  48. Data_Package data; //Create a variable with the above structure
  50. void setup() {
  51. Serial.begin(9600);
  53. // Initialize interface to the MPU6050
  54. initialize_MPU6050();
  56. // Call this function if you need to get the IMU error values for your module
  57. //calculate_IMU_error();
  59. // Define the radio communication
  60. radio.begin();
  61. radio.openWritingPipe(address);
  62. radio.setAutoAck(false);
  63. radio.setDataRate(RF24_250KBPS);
  64. radio.setPALevel(RF24_PA_LOW);
  66. // Activate the Arduino internal pull-up resistors
  67. pinMode(jB1, INPUT_PULLUP);
  68. pinMode(jB2, INPUT_PULLUP);
  69. pinMode(t1, INPUT_PULLUP);
  70. pinMode(t2, INPUT_PULLUP);
  71. pinMode(b1, INPUT_PULLUP);
  72. pinMode(b2, INPUT_PULLUP);
  73. pinMode(b3, INPUT_PULLUP);
  74. pinMode(b4, INPUT_PULLUP);
  76. // Set initial default values
  77. data.j1PotX = 127; // Values from 0 to 255. When Joystick is in resting position, the value is in the middle, or 127. We actually map the pot value from 0 to 1023 to 0 to 255 because that's one BYTE value
  78. data.j1PotY = 127;
  79. data.j2PotX = 127;
  80. data.j2PotY = 127;
  81. data.j1Button = 1;
  82. data.j2Button = 1;
  83. data.pot1 = 1;
  84. data.pot2 = 1;
  85. data.tSwitch1 = 1;
  86. data.tSwitch2 = 1;
  87. data.button1 = 1;
  88. data.button2 = 1;
  89. data.button3 = 1;
  90. data.button4 = 1;
  91. }
  92. void loop() {
  93. // Read all analog inputs and map them to one Byte value
  94. data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255); // Convert the analog read value from 0 to 1023 into a BYTE value from 0 to 255
  95. data.j1PotY = map(analogRead(A0), 0, 1023, 0, 255);
  96. data.j2PotX = map(analogRead(A2), 0, 1023, 0, 255);
  97. data.j2PotY = map(analogRead(A3), 0, 1023, 0, 255);
  98. data.pot1 = map(analogRead(A7), 0, 1023, 0, 255);
  99. data.pot2 = map(analogRead(A6), 0, 1023, 0, 255);
  100. // Read all digital inputs
  101. data.j1Button = digitalRead(jB1);
  102. data.j2Button = digitalRead(jB2);
  103. data.tSwitch2 = digitalRead(t2);
  104. data.button1 = digitalRead(b1);
  105. data.button2 = digitalRead(b2);
  106. data.button3 = digitalRead(b3);
  107. data.button4 = digitalRead(b4);
  108. // If toggle switch 1 is switched on
  109. if (digitalRead(t1) == 0) {
  110. read_IMU(); // Use MPU6050 instead of Joystick 1 for controling left, right, forward and backward movements
  111. }
  112. // Send the whole data from the structure to the receiver
  113. radio.write(&data, sizeof(Data_Package));
  114. }
  116. void initialize_MPU6050() {
  117. Wire.begin(); // Initialize comunication
  118. Wire.beginTransmission(MPU); // Start communication with MPU6050 // MPU=0x68
  119. Wire.write(0x6B); // Talk to the register 6B
  120. Wire.write(0x00); // Make reset - place a 0 into the 6B register
  121. Wire.endTransmission(true); //end the transmission
  122. // Configure Accelerometer
  123. Wire.beginTransmission(MPU);
  124. Wire.write(0x1C); //Talk to the ACCEL_CONFIG register
  125. Wire.write(0x10); //Set the register bits as 00010000 (+/- 8g full scale range)
  126. Wire.endTransmission(true);
  127. // Configure Gyro
  128. Wire.beginTransmission(MPU);
  129. Wire.write(0x1B); // Talk to the GYRO_CONFIG register (1B hex)
  130. Wire.write(0x10); // Set the register bits as 00010000 (1000dps full scale)
  131. Wire.endTransmission(true);
  132. }
  134. void calculate_IMU_error() {
  135. // We can call this funtion in the setup section to calculate the accelerometer and gury data error. From here we will get the error values used in the above equations printed on the Serial Monitor.
  136. // Note that we should place the IMU flat in order to get the proper values, so that we then can the correct values
  137. // Read accelerometer values 200 times
  138. while (c < 200) {
  139. Wire.beginTransmission(MPU);
  140. Wire.write(0x3B);
  141. Wire.endTransmission(false);
  142. Wire.requestFrom(MPU, 6, true);
  143. AccX = (Wire.read() << 8 | Wire.read()) / 4096.0 ;
  144. AccY = (Wire.read() << 8 | Wire.read()) / 4096.0 ;
  145. AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0 ;
  146. // Sum all readings
  147. AccErrorX = AccErrorX + ((atan((AccY) / sqrt(pow((AccX), 2) + pow((AccZ), 2))) * 180 / PI));
  148. AccErrorY = AccErrorY + ((atan(-1 * (AccX) / sqrt(pow((AccY), 2) + pow((AccZ), 2))) * 180 / PI));
  149. c++;
  150. }
  151. //Divide the sum by 200 to get the error value
  152. AccErrorX = AccErrorX / 200;
  153. AccErrorY = AccErrorY / 200;
  154. c = 0;
  155. // Read gyro values 200 times
  156. while (c < 200) {
  157. Wire.beginTransmission(MPU);
  158. Wire.write(0x43);
  159. Wire.endTransmission(false);
  160. Wire.requestFrom(MPU, 4, true);
  161. GyroX = Wire.read() << 8 | Wire.read();
  162. GyroY = Wire.read() << 8 | Wire.read();
  163. // Sum all readings
  164. GyroErrorX = GyroErrorX + (GyroX / 32.8);
  165. GyroErrorY = GyroErrorY + (GyroY / 32.8);
  166. c++;
  167. }
  168. //Divide the sum by 200 to get the error value
  169. GyroErrorX = GyroErrorX / 200;
  170. GyroErrorY = GyroErrorY / 200;
  171. // Print the error values on the Serial Monitor
  172. Serial.print("AccErrorX: ");
  173. Serial.println(AccErrorX);
  174. Serial.print("AccErrorY: ");
  175. Serial.println(AccErrorY);
  176. Serial.print("GyroErrorX: ");
  177. Serial.println(GyroErrorX);
  178. Serial.print("GyroErrorY: ");
  179. Serial.println(GyroErrorY);
  180. }
  182. void read_IMU() {
  183. // === Read acceleromter data === //
  184. Wire.beginTransmission(MPU);
  185. Wire.write(0x3B); // Start with register 0x3B (ACCEL_XOUT_H)
  186. Wire.endTransmission(false);
  187. Wire.requestFrom(MPU, 6, true); // Read 6 registers total, each axis value is stored in 2 registers
  188. //For a range of +-8g, we need to divide the raw values by 4096, according to the datasheet
  189. AccX = (Wire.read() << 8 | Wire.read()) / 4096.0; // X-axis value
  190. AccY = (Wire.read() << 8 | Wire.read()) / 4096.0; // Y-axis value
  191. AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0; // Z-axis value
  193. // Calculating angle values using
  194. accAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * 180 / PI) + 1.15; // AccErrorX ~(-1.15) See the calculate_IMU_error()custom function for more details
  195. accAngleY = (atan(-1 * AccX / sqrt(pow(AccY, 2) + pow(AccZ, 2))) * 180 / PI) - 0.52; // AccErrorX ~(0.5)
  197. // === Read gyro data === //
  198. previousTime = currentTime; // Previous time is stored before the actual time read
  199. currentTime = millis(); // Current time actual time read
  200. elapsedTime = (currentTime - previousTime) / 1000; // Divide by 1000 to get seconds
  201. Wire.beginTransmission(MPU);
  202. Wire.write(0x43); // Gyro data first register address 0x43
  203. Wire.endTransmission(false);
  204. Wire.requestFrom(MPU, 4, true); // Read 4 registers total, each axis value is stored in 2 registers
  205. GyroX = (Wire.read() << 8 | Wire.read()) / 32.8; // For a 1000dps range we have to divide first the raw value by 32.8, according to the datasheet
  206. GyroY = (Wire.read() << 8 | Wire.read()) / 32.8;
  207. GyroX = GyroX + 1.85; //// GyroErrorX ~(-1.85)
  208. GyroY = GyroY - 0.15; // GyroErrorY ~(0.15)
  209. // Currently the raw values are in degrees per seconds, deg/s, so we need to multiply by sendonds (s) to get the angle in degrees
  210. gyroAngleX = GyroX * elapsedTime;
  211. gyroAngleY = GyroY * elapsedTime;
  213. // Complementary filter - combine acceleromter and gyro angle values
  214. angleX = 0.98 * (angleX + gyroAngleX) + 0.02 * accAngleX;
  215. angleY = 0.98 * (angleY + gyroAngleY) + 0.02 * accAngleY;
  216. // Map the angle values from -90deg to +90 deg into values from 0 to 255, like the values we are getting from the Joystick
  217. data.j1PotX = map(angleX, -90, +90, 255, 0);
  218. data.j1PotY = map(angleY, -90, +90, 0, 255);
  219. }
 SCHEMATIC FOR RECEIVER:

CODE FOR RECEIVER:

  1. #include <SPI.h>
  2. #include <nRF24L01.h>
  3. #include <RF24.h>
  4. RF24 radio(10, 9); // nRF24L01 (CE, CSN)
  5. const byte address[6] = "00001";
  7. unsigned long lastReceiveTime = 0;
  8. unsigned long currentTime = 0;
  10. // Max size of this struct is 32 bytes - NRF24L01 buffer limit
  11. struct Data_Package {
  12. byte j1PotX;
  13. byte j1PotY;
  14. byte j1Button;
  15. byte j2PotX;
  16. byte j2PotY;
  17. byte j2Button;
  18. byte pot1;
  19. byte pot2;
  20. byte tSwitch1;
  21. byte tSwitch2;
  22. byte button1;
  23. byte button2;
  24. byte button3;
  25. byte button4;
  26. };
  28. Data_Package data; //Create a variable with the above structure
  30. void setup() {
  31. Serial.begin(9600);
  32. radio.begin();
  33. radio.openReadingPipe(0, address);
  34. radio.setAutoAck(false);
  35. radio.setDataRate(RF24_250KBPS);
  36. radio.setPALevel(RF24_PA_LOW);
  37. radio.startListening(); // Set the module as receiver
  38. resetData();
  39. }
  40. void loop() {
  41. // Check whether there is data to be received
  42. if (radio.available()) {
  43. radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
  44. lastReceiveTime = millis(); // At this moment we have received the data
  45. }
  46. // Check whether we keep receving data, or we have a connection between the two modules
  47. currentTime = millis();
  48. if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
  49. resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone has a throttle up and we lose connection, it can keep flying unless we reset the values
  50. }
  51. // Print the data in the Serial Monitor
  52. Serial.print("j1PotX: ");
  53. Serial.print(data.j1PotX);
  54. Serial.print("; j1PotY: ");
  55. Serial.print(data.j1PotY);
  56. Serial.print("; button1: ");
  57. Serial.print(data.button1);
  58. Serial.print("; j2PotX: ");
  59. Serial.println(data.j2PotX);
  60. }
  62. void resetData() {
  63. // Reset the values when there is no radio connection - Set initial default values
  64. data.j1PotX = 127;
  65. data.j1PotY = 127;
  66. data.j2PotX = 127;
  67. data.j2PotY = 127;
  68. data.j1Button = 1;
  69. data.j2Button = 1;
  70. data.pot1 = 1;
  71. data.pot2 = 1;
  72. data.tSwitch1 = 1;
  73. data.tSwitch2 = 1;
  74. data.button1 = 1;
  75. data.button2 = 1;
  76. data.button3 = 1;
  77. data.button4 = 1;
  78. }
Making electronics project is too pretty simple with Us.

Join and Make with Us.

Labels:

Comments

Post a Comment

Popular posts from this blog

How To Make Pac- Man Game Using Arduino

By
Hello Guys , In This Post We Will Tell You How To Make A Arduino Based Pac- Man Game. For More Awesome Arduino Projects Subscribe Our Blog. #Microelectronics Components Required- 1-Arduino Uno / Nano  2-Display Module  3- Joystick Module  4- Jumper Wire   Circuit Diagram Is Given Below- Source Code- //Nokia 5110 LCD PacMan Game #include <LCD5110_Graph.h> #include <avr/pgmspace.h> #define RST 12    // RESET #define CE  13    // CS #define DC  11    // Data/Command #define DIN  10   // MOSI #define CLK  9    // SCK LCD5110 myGLCD(CLK, DIN, DC, RST, CE); // LCD5110(SCK, MOSI, DC, RST, CS); extern uint8_t SmallFont[]; const uint8_t pacman1[] PROGMEM={ 0x80, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3E, 0x1C,   // 0x0010 (16) pixels 0x0C, 0x00, 0x00, 0x00, 0x1F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF9,   // 0x0020 (32) pixels 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x
Post a Comment
Read more

Controlling A Servo Motor Using MPU 6050 Sensor .

By
Hello guys, In this post we are going to tell you that how you can control servo motor using MPU Sensor. Please subscribe to our blog, so that you can't miss any update from us.Join us @Microelectronics. Code and circuit diagram is given post. Material required- 1-MPU Sensor 2-An Arduino 3-Servo motor  4-Some jumper wires Circuit diagram- Source code- // I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files // for both classes must be in the include path of your project #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" //#include "MPU6050.h" // not necessary if using MotionApps include file // Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation // is used in I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE     #include "Wire.h" #endif #include <Servo.h> Servo myservo;  // create servo object to control a servo   // class default I2C address is 0x
Post a Comment
Read more

How To Make RFID Based Locking System Using Arduino ?

By
Hello Guys, In This Post You Will Learn How You Can Make A Locking System Using Arduino.  We Have Add Circuit Diagram And Source Code To This Post. Kindly Subscribe To Our Blog So That You Can't Miss Any Update From Us. Material Required-  1-RFID Tag  2-Arduino Uno / Nano  3- Display Module 4- Jumper Wires Click On The Link Below To Get -   Circuit Diagram And Source Code Note-  This Link May Be Redirect You To Simple Page, Where You Need To Choose Go To Site Option.
2 comments
Read more