Introduction: Draadloze Controller
Een draadloze controller word voor heel veel dingen gebruikt op dit moment.
En het kan ook op verschillende manieren gemaakt worden. Het meest voorkomende voorbeeld is dat van een bluetooth controller, maar dat gaan we hierin niet gebruiken.
In deze controller gaan we gebruik maken van arduino's en 2,4GHz transmitters en receivers.
Verder maken we ook gebruik van een analoge stick en een drukknop.
De programmeer code die gebruikt gaat worden voor de controller zal in Arduino zijn.
Het is handig om een beetje voorkennis te hebben maar het is geen must.
Benodigdheden:
2x Arduino (Mega, Uno of Nano). In dit geval gebruik ik 2x een nano.
2x Arduino kabel. Kijk goed wat voor kabel je nodig hebt.
2x NRF24L01 2.4GHz draadloze verzender en ontvanger.
1x Joystick Module.
1x Druk knop.
2x printplaat (maakt niet uit wat voor gebruik wat jij handig even fijn vind om te gebruiken.
1x Batterijhouder.
1x setje AA batterijen.
1x mini USB kabel.
1x DC DC converter (boost) want we moeten van 3 naar minstens 7 volt
1x Rolletje soldeertin.
Step 1: Welk Gereedschap Heb Je Nodig?
De meest praktische dingen die je kan gebruiken om dit te maken zijn.
- Schroevendraaier
Voor het instellen van de DC DC converter en het vast zetten van het een en ander.
- Striptang
Voor het strippen van je draden die je vervolgens moet solderen op een printplaat
- Soldeerbout (Must have)
De soldeerbout moet je zeker gebruiken anders zal je het op breadbordjes moeten doen en de kans dat dat los schiet is veel te groot.
Step 2: Hoe Werkt De Joystick in Arduino
De Joystick en de knoppen werken heel erg simpel in arduino.
Voor de joystick is geen arduino nodig omdat de joystick bestaat uit 2 potmeters en een drukknop.
Omdat het 2 potmeters zijn leest de arduino 2 weerstandswaarden uit en deze waarden kan je dan weer gebruiken om aan te geven of je links, rechts, omhoog of omlaag wil.
In ons geval maken we alleen gebruik van de X waardes voor het horizontaal bewegen, maar de waardes die je eruit haalt in de Y richting zijn hetzelfde en dus kan er eenzelfde code gebruikt worden om hier wat mee te doen.
De waardes die arduino binnekrijgt uit de joystick zijn tussen de 0 en de 1024.
hierin is 523 de centrale waarden die de rust positie aangeeft. Ik mijn geval heb ik gekozen om tussen de 535 en de 1023 naar rechts te gaan en tussen de 0 en de 515 naar links te gaan. Met deze indeling zal de snelheid waarop we naar rechts en links gaan altijd hetzelfde zijn. Mocht je willen dat dat sneller gaat naarmate de joystick verder naar links of naar rechts bewogen wordt, dan hoef je alleen maar meerdere grenzen aan te geven waarin bijvoorbeeld de motorsnelheid verhoogt wordt naarmate je meer grenzen opschuift.
Voor de knoppen is het heel simpel deze geven alleen een hoog of een laag signaal uit als de knop word ingedrukt en wanneer er weer word losgelaten.
Step 3: De Code
Het programmeren van de 2.4Ghz verzender en ontvanger is eigenlijk heel makkelijk want er zijn meerdere libraries te vinden om dat voor elkaar te krijgen.
Het verzenden:
/*----------------------------------------------------
Programma om de variabelen mee te zenden vanaf de controller en ontvangen naar de controller.
made by: Dave den Haan
Signal - Arduino pin
GND 1 GND
VCC 2 5V
CE 3 8
CSN 4 9
SCK 5 13
MOSI 6 11
MISO 7 12
IRQ 8 -
De eerste rij is de volgorde van de pinnen op de NRF24L01 en de rij ernaast is waaraan het moet verbinden in arduino
-------------------------------------------------------*/
#include
#include
#include
#include
#include
#include
//Define the CE and CSN Pins so they can be changed easy later if needed.
#define CE_PIN 8
#define CSN_PIN 9
//Create a new radio with the CE & CSN Pins
RF24 myRadio(CE_PIN, CSN_PIN);
//Create adress for transmitting and receiving
byte addresses[][6] = {"1Node", "2Node"};
//LCD Address LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
//Add joystick & potmeter
const int JS_Y = A2; const int JS_X = A1; const int potkal = A3;
//Add datastruct to save the transmitted/received values struct dataStruct { int Y; int Kal; int X; } tData;
struct dataStruct2 {
float Serv; float snelheid = 0.00; } rData;
unsigned long startLCD1 = 0; unsigned long startLCD2 = 0;
int last_tData_Y; int last_tData_Kal = 16; float last_rData_Serv; float last_rData_snelheid = 200;
void transceive();
void rereshLCD();
void setup() {
//Use the Serial monitor on baudrate of 115200 Serial.begin(115200); delay(250); Serial.println("Wireless transmitting");
//Start the radio
myRadio.begin();
//Set wifi channel above most normal wifi channels
myRadio.setChannel(108);
//PA level, choose which one to use. Low for testing, High for using
myRadio.setPALevel(RF24_PA_MIN);
//myRadio.setPALevel(RF24_PA_MAX);
//Open the reading and writing pipes.
myRadio.openWritingPipe(addresses[0]);
myRadio.openReadingPipe(1, addresses[1]);
delay(500);
//Set LCD
lcd.begin(20, 4); //lcd.print(column, line)
lcd.setCursor(2, 0);
lcd.print("Wireless Racecar");
lcd.setCursor(6, 1);
lcd.print("made by");
lcd.setCursor(3, 2);
lcd.print("Groep 4 -- SCS")
//Initialize pinmodes
pinMode(JS_Y, INPUT);
pinMode(JS_X, INPUT);
pinMode(potkal, INPUT);
delay(3000);
lcd.clear();
//Set LCD Screen
lcd.setCursor(2, 0);
lcd.print("Wireless Racecar:");
lcd.setCursor(0, 1);
lcd.print("Kalibratie: ");
lcd.setCursor(5, 2);
lcd.print("Accu%: ");
lcd.setCursor(2, 3);
lcd.print("Snelheid: ");
}
void loop() {
/*
Read potvalue
send value
*/
tData.X = map(analogRead(JS_X), 12, 1023, -255, 255);
tData.Y = map(analogRead(JS_Y), 13, 1023, 45, 130);
//tData.Y = (analogRead(JS_Y));
tData.Kal = map(analogRead(potkal), 0, 1023, -6, 6);
//Transmit data
transceive();
//Reresh the LCD
startLCD1 = millis();
if (startLCD1 - startLCD2 > 75)
{
refreshLCD();
startLCD2 = startLCD1;
}
}
void transceive() {
//Serial.println("Start transceiving");
unsigned long started_tranceiving_at = micros();
bool Succes = false;
myRadio.stopListening();
if (!myRadio.write(&tData, sizeof(tData)))
{
//Serial.println("Failed! GG");
}
else
{
//Serial.println("Succes! :D");
myRadio.startListening();
Succes = true;
}
unsigned long started_waiting_at = micros();
while (Succes)
{
//Serial.println("Waiting for Daniel");
if (myRadio.available()) {
//Serial.println("Data ontvangen...");
myRadio.read(&rData, sizeof(rData));
Succes = false;
}
if (micros() - started_waiting_at > 200000)
{
//Serial.println("Timeout detected!!!!!!!!!!!!!!!!");
Succes = false;
break;
}
}
//Serial.print("Total time tranceiving: ");
//Serial.println(micros() - started_tranceiving_at);
}
void refreshLCD() {
/*
Variabelen:
Accu%
Snelheid
potkal
accumelding
*/
if (tData.Kal != last_tData_Kal)
{
lcd.setCursor(12, 1);
lcd.print(" ");
lcd.setCursor(12, 1);
lcd.print(tData.Kal);
last_tData_Kal = tData.Kal;
}
if (rData.Serv != last_rData_Serv)
{
lcd.setCursor(12, 2);
lcd.print(" ");
lcd.setCursor(12, 2);
lcd.print(rData.Serv, 0);
lcd.print("%");
last_rData_Serv = rData.Serv;
}
if (rData.snelheid != last_rData_snelheid)
{
lcd.setCursor(12, 3);
lcd.print(" ");
lcd.setCursor(12, 3);
lcd.print(rData.snelheid, 0);
lcd.print("km/h ");
last_rData_snelheid = rData.snelheid;
}
}------------------------------------------------------------------------------------------------------------
Zoals ze te zien is hierboven is het een vrij lange code maar hierin zijn 3 dingen al in verwerkt
namelijk de joystick voor het bewegen, en 1 knop. 1 voor het schieten en 1 voor het resetten.
Maar dit is alleen het verzenden nog maar.
Hieronder het ontvangen
------------------------------------------------------------------------------------------------------------
/*
Simple transmit program, transmitting numbers starting
*
*
* Signal - Arduino pin
* GND 1 GND
* VCC 2 5V
* CE 3 8
* CSN 4 9
* SCK 5 13
* MOSI 6 11
* MISO 7 12
* IRQ 8 -
*/
#include
#include
#include
#include
#include
//Define the CE and CSN Pins
#define CE_PIN 8
#define CSN_PIN 9
//Create new radio with
RF24 myRadio(CE_PIN, CSN_PIN);
//Create address for 1 way transmitting
byte addresses[][6] = {"1Node", "2Node"};
//Receive datastruct:
struct dataStruct {
int X = 0;//joystick
int Res = 0;//Reset
int Schiet = 0;//Schiet
} RData;
//Flags
int Flag1 = 0;
int Flag2 = 0;
int Flag3 = 0;
//Outputs
int Res = A0;
int Schiet = A1;
int Rechts = A2;
int Links = A3;
void setup() {
//Use serial monitor on baudrate of 115200
Serial.begin(115200);
delay(1000);
Serial.println("RF24 Sending test");
pinMode(Res, OUTPUT);
pinMode(Schiet, OUTPUT);
pinMode(Rechts, OUTPUT);
pinMode(Links, OUTPUT);
//Communication:
//Start the radio
myRadio.begin();
//Set channel above wifi Channels
myRadio.setChannel(108);
//Setup Radio connection:
myRadio.setPALevel(RF24_PA_MIN);
myRadio.openWritingPipe(addresses[1]);
myRadio.openReadingPipe(1,addresses[0]);
delay(1000);
myRadio.startListening();
}
void loop() {
myRadio.read(&RData, sizeof(RData));
if(Flag1 = 0){
myRadio.read(&RData, sizeof(RData));
if(RData.X == 1)
{
Serial.print("Rechts");
analogWrite(Rechts, HIGH);
Flag1 = 1;
}
else if(RData.X == 2)
{
Serial.print("Links");
analogWrite(Links, HIGH);
Flag1 = 1;
}
}
if(RData.X == 0)
{
Serial.print("Stilstaan");
Flag1 = 0;
}
if(Flag2 = 0){
if(RData.Res = 1)
{
Serial.print("Reset");
analogWrite(Res, HIGH);
Flag2 = 1;
}
}
if(RData.Res = 0){
Flag2 = 0;
}
if(Flag3 = 0){
if(RData.Schiet == 1)
{
Serial.print("Schiet");
analogWrite(Schiet, HIGH);
Flag3 = 1;
}
}
if(RData.Schiet = 0){
Flag3 = 0;
}
}
De code hierboven spreekt best wel voor zich eigenlijk. Als de ontvanger dingen binnenkrijgt dan geeft hij simpelweg een pin hoog aan en hiermee kan een vervolg aangegeven worden. In ons geval word er op een andere arduino een ledmatrix aangestuurd om te schieten heen en weer te bewegen of de game te resetten.
Step 4: Het in Elkaar Zetten
Het in elkaar zetten is het makkelijkst van allemaal.
Voor de casing heb ik een lasersnijder gebruikt die alles precies op de juiste maat maakte en het zo te gebruikten was.
Ik snap dat niet iedereen een lasersnijder tot zijn beschikking heeft en dus zal het netjes met de hand gemaakt moeten worden of een andere slimme manier om een case te maken.
De case die ik gebruikt heb is bovenin te zien en is ontworpen met MakerCase.
Link:
Dit is een programma waarbij je maten kunt invoeren en vervolgens jouw ontworpen bestand kan downloaden
Als je deze file hebt zal je nog een programma nodig hebben om het te bewerken.
Ik raad adobe illustrator aan omdat het een makkelijk te gebruiken programma is als je het eenmaal snapt.
Je zal in dit programma nog kleine aanpassingen moeten doen om het printbaar te maken maar dat is allemaal op google te vinden.
Als je alle componenten hebt raad ik je aan om 1 van de arduino nano's te soldeer aan een printplaat en vervolgens alle aansluitingen van je joystick en beide knoppen aan de juiste poorten van je arduino te solderen. Hierdoor is een printplaatje of experimenteelplaatje erg handig want je hoeft niet alles aan 1 pin te solderen je kan makkelijk een baan doortrekken naar een volgende en zo heel erg makkelijk een net printplaatje solderen zonder te kortsluiting.
TIP: Één van de belangrijkste dingen die je niet moet vergeten bij het solderen is dat je de uitgang van je DC DC converter ook naar je arduino moet sturen. Anders zal deze geen powerhebben aangezien we de kabel alleen gebruiken voor het uploaden van de code en niet voor het poweren. De OUTPUT+ van de DC DC converter zal aan de Vin van de arduino moeten en de OUTPUT- van de DC DC converter zal aan de GND pin moeten. In mijn geval heb ik nog een aan/uit switch achter het rode draad van de batterij gehangen om zo de controller aan en uit te kunnen zetten en je niet elke paar uur je batterijen hoeft te vervangen.
Als alles is gesoldeerd en de code werkend is hoef je alleen nog maar de knoppen en joystick op de juiste plek vast te maken en je casing sluiten. Hierna zal hij draadloos naar de ontvanger moeten kunnen versturen. Dit is voor heel veel verschillende te gebruiken mits je de code voor verzenden en ontvangen juist maakt. Deze controller is gemaakt naar waar ik hem voor nodig had, namelijk het aansturen van een zelfgemaakt SPACE INVADERS spel.
Mochten er nog vragen zijn of dingen die ik ben vergeten die belangrjik zijn om te weten mail gerust.
Verder wens ik iedereen veel succes met het maken van de controller
