Arduino NERF Ball Wireless FPV Sentry Turret

The joystick should now be complete!

Step 40: Code: Overview

This instructables is already very long, so we’ll keep this section brief.

The challenge of this project is constructing the turret and wiring it all up. If you’ve done it according to the instructions, then hopefully the code should be good to go. It has been commented in detail meaning it should be easy to adapt if required. I highly recommend you read through this as a lot of time was spent commenting the code.

There are 2 .ino as there are 2 Arduinos to program.

All the libraries required are listed at the top of the code. It uses the SPI.h, nRF24L01.h and Servo.h libraries.

Step 41: Code: Arduino Uno

A few brief points to note on the Uno code.

The ESC is controlled using PWM through the ‘Servo.h’ library.

The address for communicating to the Arduino Nano is set as ‘RxAAA’ and is established as a read-only variable. This can be changed, or in the future can be secured through encryption.

The data is transferred as a single array which contains 4 values – servo tilt angle, servo rotation direction, firing state and ESC speed. This is then delivered to the Arduino Nano which reads the array and uses each value for the respective function. This is a highly efficient and robust way to transfer data compared to sending 4 seperate values, making the turret respond rapidly without delay. A snippet is shown below.

//a single array that holds 4 values which will be read from the incoming Nano signal
//This is more efficient and robust than trying to send 4 seperate values, instead a single message is recieved
int message[4];

//each variable name is self-identifying to the turret
angle_val = message[0];
rotation_val = message[1];
escSpeed = message[2];
firing_state = message[3];

The Uno receives radio transmission. We use the lowest data transfer rate of 250kbps to get the highest range possible. The nRF24L01 has 6 pipes that it can use to transmit or receive data to at a time. In the setup part of the code, we open the pipe and set it as listening, since the Uno will be recieving all the commands from the Arduino Nano.

//this starts radio transmission and utilises the RF24 module<br>radio.begin();
//the lowest data transfer rate provides greater connection range
//since a single array is being received, this rate is suitable as the more important factor is the wireless range
radio.setDataRate( RF24_250KBPS );
//the nRF24L01 has 6 pipes that it can transmit or receive data to at a time
//this command opens the first data pipe for reading at the address we defined earlier
radio.openReadingPipe(0, address);
//Since the UNO is only receiving data, it must start listening for any values coming through the aforementioned ReadingPipe
radio.startListening();

The general way the code works is that it’s listening to messages from the Arduino Nano. Then it will write whatever the last value it receives and set the pin to that value. For the contionous rotation servo, we had to tune the point at which the direction changes as this will vary servo to servo. In the neutral position, to ensure the servo does not move, we use the detach command to disengage it.

For the firing servo, on the Uno side of the code, it’s simply checking if the firing state is on or off, and if the ESC speed exceeds a threshold (in this case if it’s rotating), then sends a signal to the servo so that it either blocks the balls or feeds the balls in.

The speed of the brushless motors is set by the ESC, which takes in commands written in microseconds from the Arduino. The data is continously sent to the ESC, even when stationary they are set to be idle, so that it always knows its throttle position. Interfacing an ESC with an Arduino can initially be challenging depending on the model, but straightfoward once you have the ESC manual.

In summary, download the .ino file and read the comments, there’s a lot more detail.

Attachments

• UNO_CODE.inoDownload

Step 42: Code: Arduino Nano

The Nano code works very similarly to the Uno code except instead of listening to commands, the Nano is only sending data out as a transmitter. Once again, my recommendation is to read the comments in the code as it’s been done with a high level of detail.

The main points here are to tune the potentiometers depending on how you’ve fixed them into the joystick so that they correspond with the values that are sent to the servos. The main function used here is map, where the analog reading of the potentiometer is taken (in this case it reads between 390 and 600), then it remaps these to servo values (105 to 160). A snippet is shown below:

////////////////TURRET TILT POT READING//////////////////<br>  //reading the potentiometer values from the analog pin, this is between 0 and 1023
  angle_val = analogRead(angle_pot);
  //since the potentiometer is mechanically fixed in the joystick, it only travels between 390 and 600
  //in order to write a suitable value to the servo, the potentiometer value is mapped accordingly
  //this keeps all the functionality of the potentiometer code within the Nano making reprogramming and adapting of the input controls later easier
  angle_val = map(angle_val, 390, 600, 105, 160);

The ESC continously has a 1500 microsecond signal passed to it. ESCs are typically used when you have a remote control with a throttle, and upon startup you set the min value and max value, then let the throttle spring back to neutral position. By setting the 1500 microsecond signal, we are essentially providing a neutral position. We are not however changing the throttle incrementally to min and max at startup, and need to reprogram the ESC settings so that it works with the Arduino – we will walk you through the basis of this in the next step.

The last part of the code defines the 4 values to send to the Arduino Uno into a single array message as mentioned earlier and then sent using:

//'sizeof' is a command for writing the message to the address, the second argument confirms the number of bytes occupied in the array and how many should be received  
//using '&' in this instance will pass the address of the variable where the data is stored
  radio.write(&message, sizeof(message));

Just like before, download the .ino file and read the comments, there’s a lot more detail.

Attachments

• NANO_CODE.inoDownload

Step 43: Code: Arduino ESC Settings

Attached are images from the manual demonstrating how to set throttle range. The run mode needs to be switched to ‘ONE’ to allow for simple control of the ESC through an Arduino.

Use the button on the side of the ESC to reprogram it to the correct mode, then it should be ready to use with the Arduino.

Upon startup you’ll hear a set of beeps (this is the Arduino setting the idle speed), then a startup jingle which indicates the ESC is calibrated and ready to use.

The full manual has been attached for the ESCs used in case it is of interest. If you are using a different ESC then please refer to its respective manual.

Step 44: Final Setup: Connecting the FPV Headset to Camera

What’s better than firing your wireless Nerf sentry gun? Being able to fire it in a different room and as if you’re sat at the end of the barrel.

It is an optional feature and will help reduce the cost of the project, but if you do include it, it makes the experience a lot more epic.

Once you’ve wired your camera in and charged the headset. It’s as simple as hitting search and waiting for the headset to find the same channel that the camera is on. You may have to manually set the channel if it does not work, referring to the user manual of the headset you chose. If it still doesn’t work then either you need to charge the headset more, or if it was a cheap one, then you need to get it replaced (we did).

Word of warning. Using the headset for too long can cause nausea, especially if you’re spinning the turret around a lot. So please be careful.

Step 45: Testing: Power It Up!

Finally, mount the battery in place and connect the negative and positive terminals.

The ESC should beep a couple times and make the calibration tune (this is the Arduino setting the throttle values as mentioned in the coding section). This should take a couple of seconds.

Your wireless Nerf shooting sentry gun is ready to use!

For a more immersive experience, use the headset for FPV.

Please remember to never aim at people and use with caution. Although this is fun to play with, it is not a toy and can be dangerous if misued, so please remember to be safe.

Happy Turreting!

Step 46: Future Developments

We are currently planning on making a v2 of this turret and are very open to any suggestions, improvements or new designs. Please leave any thoughts in the comments below!

 

Read more: Arduino NERF Ball Wireless FPV Sentry Turret