HobbyKing.com New Products Flash Sale
Reply
Thread Tools
Old Feb 16, 2013, 12:04 PM
Registered User
Dutchraptor's Avatar
The Netherlands, ZH, Hoogvliet
Joined Jul 2008
286 Posts
Discussion
Full RC Arduino Control

Hi guys,
Sooner or later everyone wants to control more then 4 functions in a boat. But when one dreams of a boat with more then 100 functions , including feedback, GPS and such, then your not happy with the standard Futaba and Graupner systems. They cost a lot and are a bit outdated . Especialy when one wants 2,4gHz. Here's a small introduction to my approach.

A friend of mine ones learned me to program C++/Arduino. Unfortunately he passed away last year. We were developing a fully controlled system based on arduio for ships. He was working on the sounds and teaching me the basic. I was busy with interfaces and communications. Now I have been testing more then a year and the system works.

The receiver side has a etches board already, the transmitter is still waiting for new material. I have now a spiderweb of wires in an old Graupner transmitter with an Arduino Mega. Analog 0->9 are inputs for pots (sticks), Analog 10->13, are for trimpots. Almost all other i/o pins are for functionswitches. The program just sends the commands that change, not like commerial TX's which send sequences of 8 channels. 1 command send 1 servo or 8 digital functions a time. The first basic version (I'm also working on an extended version) sends out 10 servo's and 32 functions. In the setup you can choose for a channel or you can add a potmeter on analog 14 for a channel selector. A reset button/led is also added (reset and channel can be done with defines, hardware reset is not needed). An arduino for controlling lednumbers or LCD can be connected on one of the RX/TX ports to display the channelnumber.

The receiverside shield is allready finished and tested. The transmitterside is still waiting or parts. But it's not one of the most complicated shield I build. On both shields there are 5 7805's. Each power eiter 2 servo's or 3/4 pots. The i/o's have 10K resistors for pulling down the switch or the function. The receiverside program is fully working and tested and cleaned-up. All experimental stuff for newer versions are out. The transmitterside is cleaned up and changed for the new shield. With the spiderweb version it worked and was very stable. But it is still Beta since I have not yet got the opportunity to test the shield version. As I said, it is a cleaned-up version, more functionality is to come (I hope soon, but work is keeping me from my hobbies). I have made a test led shield that can be mounted on the shield to test the i/o's.

In the boat, all wires will be connected to either servo, esc's, relais, FET's or transistors. Later versions (working but still cleaning/tidying up) will include feedback modules (seperate from this unit but communicating with it) and even more functions with port-expanders (i2c with 16x8 functions). A sound-board based on arduino is also working, but still needs a good PCB. The communications work on 2,4 gHz. with NRF24L01 units. Previous versions of the software needed a seperate arduino for comms, now everything works with a single mega. A member here (Tweety777) has allready seen/heard my stuff. He pointed me to this part of the forum. Perhaps you guys have use for this too. If so, and you can make it better, please share so we can all benefit from it. Perhaps we can make it a new standard like the wii-copter software (dream).
The (theoratical) maximum for the protocol (so far) is 144 servo's or 1296 functions, or any combination within these limits. I've also made a small Nano/NRF combination for computercontrol, but that is for later. Works with the same protocol and I don't need to change anything in the boat.

I hope the code comes throught allright, I copy pasted it from arduino. If anyone is having trouble, let me know.

grtz.

Danny van Dijk
Hoogvliet, Netherlands, Europe

Here are the images so far:
the shield test board, Computeradapter Nano wih NRF24L01, duo soundsystem and converted transmitter


the Final Receiver


the Receiver without testshield


The PCB's


the transmittercode
Code:
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>

//#define Channel1     //uncomment for standard Pot control A0
#define Channel1Trim   //uncomment for standard Pot control A0 + trim pot on A10
//#define Channel2     //uncomment for standard Pot control A1
#define Channel2Trim   //uncomment for standard Pot control A1 + trim pot on A11
//#define Channel3     //uncomment for standard Pot control A2
#define Channel3Trim   //uncomment for standard Pot control A2 + trim pot on A12
//#define Channel4     //uncomment for standard Pot control A3
#define Channel4Trim   //uncomment for standard Pot control A3 + trim pot on A13
#define Channel5       //uncomment for standard Pot control A4
#define Channel6       //uncomment for standard Pot control A5
#define Channel7       //uncomment for standard Pot control A6
#define Channel8       //uncomment for standard Pot control A7
#define Channel9       //uncomment for standard Pot control A8
#define Channel10      //uncomment for standard Pot control A9

const int trimspaceH = 20; const int trimspaceL = -20; // keep the same for liniar trimming

#define DynChannel     // uncomment for setting dynamic channel select on A14. Serial3
                       // reset to use channel. Feedback naar SerialChannel (follow soon)
#define RESET          // do you have a resetbutton? Pin13 for button + Pin12 fo LED

const int STARTUP = 1000;
// when dynamic channel is ON
const int chpotlow = 0;
const int chpothigh = 1023;
const int channelselectlow = 80; // Lowest channel number
const int channelselecthigh = 99; // Highest channel number
int channelsend = 0;

// what channel are we on when NOT dynamic set.
int channel = 80; int channelchk = 0; 
int timer =0;

// transmit buffering
const int zendbuffer1 = 1;       // how sensitive are the navigationpots in relation to communication
const int zendbuffer2 = 3;       // how sensitive are the other pots in relation to communication
const int transmitbuffer = 10;   // how many millisec. hold for next transmit

// which pin is where                // send code
const int buttonPin53 = 53;          // unused

const int buttonPin2 = 2;            //
const int buttonPin5 = 3;            //
const int buttonPin6 = 4;            //
const int buttonPin7 = 5;            //
const int buttonPin10 = 6;           //
const int buttonPin11 = 7;           //
// pin 8 and pin 9 are for the NRF24L01
const int buttonPin12 = 10;           //
const int buttonPin13 = 11;           //

const int buttonPin22 = 22;           //
const int buttonPin23 = 23;           //
const int buttonPin24 = 24;           //
const int buttonPin25 = 25;           // 
const int buttonPin26 = 26;           //
const int buttonPin27 = 27;           //
const int buttonPin28 = 28;           //
const int buttonPin29 = 29;           //
const int buttonPin30 = 30;           //
const int buttonPin31 = 31;           // 
const int buttonPin32 = 32;           //
const int buttonPin33 = 33;           // 
const int buttonPin34 = 34;           //
const int buttonPin35 = 35;           //
const int buttonPin36 = 36;           //
const int buttonPin37 = 37;           //  
const int buttonPin38 = 38;           //
const int buttonPin39 = 39;           // 
const int buttonPin40 = 40;           //
const int buttonPin41 = 41;           //  
const int buttonPin42 = 42;           //
const int buttonPin43 = 43;           //
const int buttonPin44 = 44;           //
const int buttonPin45 = 45;           //
const int buttonPin46 = 46;           //
const int buttonPin47 = 47;           //
const int buttonPin48 = 48;           //
const int buttonPin49 = 49;           //
/*
pinMode(buttonPin2, INPUT); //pinMode(buttonPin3, INPUT);
pinMode(buttonPin4, INPUT); pinMode(buttonPin5, INPUT);
pinMode(buttonPin6, INPUT); pinMode(buttonPin7, INPUT);
pinMode(buttonPin8, INPUT); pinMode(buttonPin9, INPUT);
pinMode(buttonPin10, INPUT); pinMode(buttonPin11, INPUT);
pinMode(buttonPin13, INPUT); pinMode(buttonPin12, INPUT);
*/
// constants for analog readout
const int pot1L = 0; const int pot1H = 1023;
const int pot2L = 0; const int pot2H = 1023;
const int pot3L = 0; const int pot3R = 1023; const int pot3H = 1023;
const int pot4L = 0; const int pot4R = 1023; const int pot4H = 1023;
const int pot5L = 0; const int pot5H = 1023;
const int pot6L = 0; const int pot6R = 1023;
const int pot7L = 0; const int pot7R = 1023;
const int pot8L = 0; const int pot8R = 1023;
const int pot9L = 0; const int pot9R = 1023;
const int pot10L = 0; const int pot10R = 1023;
const int pot11L = 0; const int pot11H = 1023;
const int pot12L = 0; const int pot12R = 1023;
const int pot15L = 430; const int pot15H = 750;
const int pot16L = 400; const int pot16R = 720;
const int pot17L = 350; const int pot17R = 680;
const int pot18L = 360; const int pot18R = 680;

// constants for PWM-send (converted from analog in)

// end values for trimmed channels
const int pot1LST = 0+trimspaceH; const int pot1RS = 255-trimspaceH;
const int pot2LST = 0+trimspaceH; const int pot2RS = 255-trimspaceH;
const int pot3LST = 0+trimspaceH; const int pot3RS = 255-trimspaceH;
const int pot4LST = 0+trimspaceH; const int pot4RS = 255-trimspaceH; 
const int pot15LT = trimspaceH; const int pot15HT = trimspaceL; // how much trimspace do you want left and right
const int pot16LT = trimspaceH; const int pot16RT = trimspaceL; // how much trimspace do you want left and right
const int pot17LT = trimspaceH; const int pot17RT = trimspaceL; // how much trimspace do you want left and right
const int pot18LT = trimspaceH; const int pot18RT = trimspaceL; // how much trimspace do you want left and right

// end values for not-trimmed channels
const int pot1LS = 0; const int pot1HS = 255;
const int pot2LS = 0; const int pot2HS = 255;
const int pot3LS = 0; const int pot3HS = 255;
const int pot4LS = 0; const int pot4HS = 255;
const int pot5LS = 0; const int pot5HS = 255;
const int pot6LS = 0; const int pot6RS = 255;
const int pot7LS = 0; const int pot7RS = 255;
const int pot8LS = 0; const int pot8RS = 255;
const int pot9LS = 0; const int pot9RS = 255;
const int pot10LS = 0; const int pot10RS = 255;
const int pot11LS = 0; const int pot11HS = 255;
const int pot12LS = 0; const int pot12RS = 255;

#ifdef RESET
const int resetPin = 13;              // the number of the pushbutton pin
const int ResetState = 0;            // variable for reading the pushbutton status
const int resetled = 12;              // light up led when reset
const int timetoreset = 500;         // how long delay after reset
#endif

#ifdef DynChannel
const int ChannelPin = A14;          // select the input pin for the channel select
int ChannelValue = 0;                // temp. channel until read
int channelold;                      // just needed as a default when setting channel dynamic
int channeloldchk;
#endif

char buffer[5]; 
// nRF24L01(+) radio attached to SPI and pins 8 & 9
RF24 radio(8,9);
RF24Network network(radio);
// Address of our node
const uint16_t this_node = 1;
// Address of the other node
const uint16_t other_node = 0;

// How often to send to the other unit
const unsigned long interval = 200; //ms
unsigned long last_sent;
long strlnum;

// temporary numbers:
int servolow1 =0; int servohigh1 = 0; // temporary hi/low until read
int servolow2 =0; int servohigh2 = 0; // temporary hi/low until read
int servolow3 =0; int servohigh3 = 0; // temporary hi/low until read
int servolow4 =0; int servohigh4 = 0; // temporary hi/low until read
int servolow5 =0; int servohigh5 = 0; // temporary hi/low until read
int servolow6 =0; int servohigh6 = 0; // temporary hi/low until read
int servolow7 =0; int servohigh7 = 0; // temporary hi/low until read
int servolow8 =0; int servohigh8 = 0; // temporary hi/low until read
int servolow9 =0; int servohigh9 = 0; // temporary hi/low until read
int servolow10 =0; int servohigh10 = 0; // temporary hi/low until read
int servolow11 =0; int servohigh11 = 0; // temporary hi/low until read
int servolow12 =0; int servohigh12 = 0; // temporary hi/low until read
int servolow13 =0; int servohigh13 = 0; // temporary hi/low until read
 
int buttonState22 = 0; int buttonState23 = 0; int buttonState24 = 0;
int buttonState25 = 0; int buttonState26 = 0; int buttonState27 = 0;
int buttonState28 = 0; int buttonState29 = 0; int buttonState30 = 0;
int buttonState31 = 0; int buttonState32 = 0; int buttonState33 = 0;
int buttonState34 = 0; int buttonState35 = 0; int buttonState36 = 0;
int buttonState37 = 0; int buttonState38 = 0; int buttonState39 = 0;
int buttonState40 = 0; int buttonState41 = 0; int buttonState42 = 0;
int buttonState43 = 0; int buttonState44 = 0; int buttonState45 = 0;
int buttonState46 = 0; int buttonState47 = 0; int buttonState48 = 0;
int buttonState49 = 0; int buttonState53 = 0; int buttonState2  = 0;
int buttonState5  = 0;  int buttonState6 = 0; int buttonState7  = 0;
int buttonState10 = 0; int buttonState11 = 0; int buttonState12 = 0;
int buttonState13 = 0;

int ButtonSend1 = 0; int ButtonSend1old = 1000;
int ButtonSend2 = 0; int ButtonSend2old = 1000;
int ButtonSend3 = 0; int ButtonSend3old = 1000;
int ButtonSend4 = 0; int ButtonSend4old = 1000;
int ButtonSend5 = 0; int ButtonSend5old = 1000;
int ButtonSend6 = 0; int ButtonSend6old = 1000;


void setup(void)
{
  
  delay(STARTUP);
#ifdef RESET
  pinMode(resetPin, INPUT); 
#endif  
#ifdef DynChannel
  Serial3.begin(115200);
#endif

pinMode(buttonPin22, INPUT); pinMode(buttonPin23, INPUT); 
pinMode(buttonPin24, INPUT); pinMode(buttonPin25, INPUT); 
pinMode(buttonPin26, INPUT); pinMode(buttonPin27, INPUT); 
pinMode(buttonPin28, INPUT); pinMode(buttonPin29, INPUT); 
pinMode(buttonPin30, INPUT); pinMode(buttonPin31, INPUT); 
pinMode(buttonPin33, INPUT); pinMode(buttonPin34, INPUT); 
pinMode(buttonPin35, INPUT); pinMode(buttonPin36, INPUT); 
pinMode(buttonPin37, INPUT); pinMode(buttonPin38, INPUT); 
pinMode(buttonPin39, INPUT); pinMode(buttonPin40, INPUT); 
pinMode(buttonPin41, INPUT); pinMode(buttonPin42, INPUT); 
pinMode(buttonPin43, INPUT); pinMode(buttonPin44, INPUT); 
pinMode(buttonPin45, INPUT); pinMode(buttonPin46, INPUT); 
pinMode(buttonPin47, INPUT); pinMode(buttonPin48, INPUT); 
pinMode(buttonPin49, INPUT); // pinMode(buttonPin53, INPUT); 
pinMode(buttonPin2, INPUT);  
pinMode(buttonPin5, INPUT); pinMode(buttonPin6, INPUT); 
pinMode(buttonPin7, INPUT); pinMode(buttonPin10, INPUT); 
pinMode(buttonPin11, INPUT); pinMode(buttonPin12, INPUT); 
pinMode(buttonPin13, INPUT);
  
#ifdef DynChannel
  ChannelValue = analogRead (ChannelPin);
  int channel = map(ChannelValue,chpotlow,chpothigh,channelselectlow,channelselecthigh);
  channelsend = channel;
  channelsend = channelsend + 40000;
  Serial3.write(channelsend);
 // delay(1000);
 // Serial3.print(channelsend);
#endif

  SPI.begin();
  radio.begin();
  network.begin(/*channel*/ channel, /*node address*/ this_node); 

}
#ifdef RESET
void(* resetFunc) (void) = 0; //declare reset function @ address 0
#endif

void loop(void){
  
#ifdef RESET
// reset button
 int ResetState = digitalRead(resetPin);
   if (ResetState == HIGH) {     
 analogWrite(resetled,100); // just ot test button
delay(timetoreset);
resetFunc();  //call reset
 }
 else {analogWrite(resetled,20);}  
#endif

#ifdef DynChannel
  ChannelValue = analogRead (ChannelPin);
  int channelchk = map(ChannelValue,chpotlow,chpothigh,channelselectlow,channelselecthigh);
  if (channelchk != channeloldchk){
  int channelsendchk = channelchk;
  channelsendchk = channelsendchk + 40000;
if (channeloldchk != channelchk){
//    Serial.print("Channel: ");
    Serial3.print(channelchk+40000);
//    Serial.println("    ");
    channeloldchk = channelchk;}
}
#endif 

  
  network.update(); 
  
  char buf[12];
  RF24NetworkHeader header(/*to node*/ other_node);

#ifdef Channel1Trim
//SERVO 1 Left stick: UP/DOWN + trim -------------------------------------------//
  int servoraw1 = analogRead (A0); 
  int servo1= map(servoraw1,pot1L,pot1H,pot1LST,pot1RS);
  int servoraw15 = analogRead (A10);  //trims
  int servo15= map(servoraw15,pot15L,pot15H,pot15LT,pot15HT); //trims
  servo1 = servo1+servo15;
    servo1=servo1+11000; 
    char* xs1 = (itoa(servo1,buf,10));
    const char* sendready1 = (xs1);
    network.write(header,sendready1,strlen(sendready1)); 
    delay (transmitbuffer);
//End of Left stick: UP/DOWN + trim --------------------------------------------//  
#endif

#ifdef Channel2Trim
//SERVO 2 Left stick: LEFT/RIGHT + trims ---------------------------------------//
  int servoraw2 = analogRead (A1); 
  int servo2= map(servoraw2,pot2L,pot2H,pot2LST,pot2RS); 
  int servoraw16 = analogRead (A11); // trims
  int servo16= map(servoraw16,pot16L,pot16R,pot16LT,pot16RT); // trims
  servo2 = servo2+servo16;  
    servo2=servo2+11500; 
    char* xs2 = (itoa(servo2,buf,10));
    const char* sendready2 = (xs2);
    network.write(header,sendready2,strlen(sendready2)); 
    delay (transmitbuffer);
//End of Left stick: LEFT/RIGHT + trims ----------------------------------------//  
#endif

#ifdef Channel3Trim
//SERVO 3 Right stick:LEFT/RIGHT +trims  ---------------------------------------//
  int servoraw3 = analogRead (A2); 
  int servo3= map(servoraw3,pot3L,pot3R,pot3LST,pot3RS); 
  int servoraw18 = analogRead (A12); // trims
  int servo18= map(servoraw18,pot18L,pot18R,pot18LT,pot18RT); // trims
  servo3 = servo3+servo18;  
    servo3=servo3+12000; 
    char* xs3 = (itoa(servo3,buf,10));
    const char* sendready3 = (xs3);
    network.write(header,sendready3,strlen(sendready3)); 
    delay (transmitbuffer);    
// End of Right stick:LEFT/RIGHT +trims  ---------------------------------------// 
#endif

#ifdef Channel4Trim
//SERVO 4 Right stick: UP/DOWN + trims -----------------------------------------//
  int servoraw4 = analogRead (A3); 
  int servo4= map(servoraw4,pot4L,pot4R,pot4LST,pot4RS); 
  int servoraw17 = analogRead (A13); // trims
  int servo17= map(servoraw17,pot17L,pot17R,pot17LT,pot17RT); // trims
  servo4 = servo4+servo17;  
    servo4=servo4+12500; 
    char* xs4 = (itoa(servo4,buf,10));
    const char* sendready4 = (xs4);
    network.write(header,sendready4,strlen(sendready4)); 
    delay (transmitbuffer);   
//End of Right stick: UP/DOWN + trims ------------------------------------------// 
#endif

#ifdef Channel1
//ANALOG 1 input/checker/send: POT A0 ------------------------------------------//
  int servoraw1 = analogRead (A0); 
  int servo1= map(servoraw1,pot1L,pot1H,pot1LS,pot1HS); 
  if (servo1 <= servolow1 || servo1 >= servohigh1){
    servolow1 = servo1 - zendbuffer2;
    servohigh1 = servo1 + zendbuffer2;
    servo1=servo1+11000; 
    char* xs1 = (itoa(servo1,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready1 = (xs1);
    network.write(header,sendready1,strlen(sendready1)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: POT A0 ---------------------------------------------//
#endif

#ifdef Channel2
//ANALOG 2 input/checker/send: POT A1 ------------------------------------------//
  int servoraw2 = analogRead (A1); 
  int servo2= map(servoraw2,pot2L,pot2H,pot2LS,pot2HS); 
  if (servo2 <= servolow2 || servo2 >= servohigh2){
    servolow2 = servo2 - zendbuffer2;
    servohigh2 = servo2 + zendbuffer2;
    servo2=servo2+11500; 
    char* xs2 = (itoa(servo2,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready2 = (xs2);
    network.write(header,sendready2,strlen(sendready2)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: POT A1 ---------------------------------------------//
#endif

#ifdef Channel3
//ANALOG 3 input/checker/send: POT A2 ------------------------------------------//
  int servoraw3 = analogRead (A2); 
  int servo3= map(servoraw3,pot3L,pot3H,pot3LS,pot3HS); 
  if (servo3 <= servolow3 || servo3 >= servohigh3){
    servolow3 = servo3 - zendbuffer2;
    servohigh3 = servo3 + zendbuffer2;
    servo3=servo3+12000; 
    char* xs3 = (itoa(servo3,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready3 = (xs3);
    network.write(header,sendready3,strlen(sendready3)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: POT A2 ---------------------------------------------//
#endif

#ifdef Channel4
//ANALOG 1 input/checker/send: POT A3 ------------------------------------------//
  int servoraw4 = analogRead (A3); 
  int servo4= map(servoraw4,pot4L,pot4H,pot4LS,pot4HS); 
  if (servo4 <= servolow4 || servo4 >= servohigh4){
    servolow4 = servo4 - zendbuffer2;
    servohigh4 = servo4 + zendbuffer2;
    servo4=servo4+12500; 
    char* xs4 = (itoa(servo4,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready4 = (xs4);
    network.write(header,sendready4,strlen(sendready4)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: POT A3 ---------------------------------------------//
#endif

#ifdef Channel5
//ANALOG 5 input/checker/send: POT 5 ------------------------------------------//
  int servoraw5 = analogRead (A4); 
  int servo5= map(servoraw5,pot5L,pot5H,pot5LS,pot5HS); 
  if (servo5 <= servolow5 || servo5 >= servohigh5){
    servolow5 = servo5 - zendbuffer2;
    servohigh5 = servo5 + zendbuffer2;
    servo5=servo5+13000; 
    char* xs5 = (itoa(servo5,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready5 = (xs5);
    network.write(header,sendready5,strlen(sendready5)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: POT 5 ---------------------------------------------//
#endif

#ifdef Channel6
//ANALOG 6 input/checker/send: POT 6 ------------------------------------------//
  int servoraw6 = analogRead (A5); 
  int servo6= map(servoraw6,pot6L,pot6R,pot6LS,pot6RS); 
  if (servo6 <= servolow6 || servo6 >= servohigh6){
    servolow6 = servo6 - zendbuffer2;
    servohigh6 = servo6 + zendbuffer2;
    servo6=servo6+13500; 
    char* xs6 = (itoa(servo6,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready6 = (xs6);
    network.write(header,sendready6,strlen(sendready6)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: POT 6 ---------------------------------------------//
#endif

#ifdef Channel7
//ANALOG 9 input/checker/send: SLIDER LEFT midsection --------------------------//
  int servoraw9 = analogRead (A6); 
  int servo9= map(servoraw9,pot9L,pot9R,pot9LS,pot9RS); 
  if (servo9 <= servolow9 || servo9 >= servohigh9){
    servolow9 = servo9 - zendbuffer2;
    servohigh9 = servo9 + zendbuffer2;
    servo9=servo9+15000; 
    char* xs9 = (itoa(servo9,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready9 = (xs9);
    network.write(header,sendready9,strlen(sendready9)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: SLIDER LEFT midsection ----------------------------//
#endif

#ifdef Channel8
//ANALOG 10 input/checker/send: SLIDER RIGHT midsection ------------------------//
  int servoraw10 = analogRead (A7); 
  int servo10= map(servoraw10,pot10L,pot10R,pot10LS,pot10RS); 
  if (servo10 <= servolow10 || servo10 >= servohigh10){
    servolow10 = servo10 - zendbuffer2;
    servohigh10 = servo10 + zendbuffer2;
    servo10=servo10+15500; 
    char* xs10 = (itoa(servo10,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready10 = (xs10);
    network.write(header,sendready10,strlen(sendready10)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: SLIDER LEFT midsection ----------------------------//
#endif

#ifdef Channel9
//ANALOG 11 input/checker/send: TOP Pot midsection -----------------------------//
  int servoraw11 = analogRead (A8); 
  int servo11= map(servoraw11,pot11L,pot11H,pot11LS,pot11HS); 
  if (servo11 <= servolow11 || servo11 >= servohigh11){
    servolow11 = servo11 - zendbuffer2;
    servohigh11 = servo11 + zendbuffer2;
    servo11=servo11+16000; 
    char* xs11 = (itoa(servo11,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready11 = (xs11);
    network.write(header,sendready11,strlen(sendready11)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: TOP Pot midsection --------------------------------//
#endif

#ifdef Channel10
//ANALOG 12 input/checker/send: BOTTOM Pot midsection --------------------------//
  int servoraw12 = analogRead (A9); 
  int servo12= map(servoraw12,pot12L,pot12R,pot12LS,pot12RS); 
  if (servo12 <= servolow12 || servo12 >= servohigh12){
    servolow12 = servo12 - zendbuffer2;
    servohigh12 = servo12 + zendbuffer2;
    servo12=servo12+16500; 
    char* xs12 = (itoa(servo12,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* sendready12 = (xs12);
    network.write(header,sendready12,strlen(sendready12)); 
    delay (transmitbuffer);
  }
//End of input/checker/send: BOTTOMT Pot midsection ----------------------------//
#endif

//--------  Start Buttonsend groep 1 - D22->D28   -----------// 
  ButtonSend1 = 0;
  buttonState22 = digitalRead(buttonPin22);
  if (digitalRead(buttonPin22) == HIGH) {     
    ButtonSend1 = ButtonSend1+128;             
  } 
  buttonState23 = digitalRead(buttonPin23);
  if (digitalRead(buttonPin23) == HIGH) {     
    ButtonSend1 = ButtonSend1+64;             
  }   
  buttonState24 = digitalRead(buttonPin24);
  if (digitalRead(buttonPin24) == HIGH) {     
    ButtonSend1 = ButtonSend1+32;             
  }   
  buttonState25 = digitalRead(buttonPin25);
  if (digitalRead(buttonPin25) == HIGH) {     
    ButtonSend1 = ButtonSend1+16;             
  }   
  buttonState26 = digitalRead(buttonPin26);
  if (digitalRead(buttonPin26) == HIGH) {     
    ButtonSend1 = ButtonSend1+8;             
  }  
  buttonState27 = digitalRead(buttonPin27);
  if (digitalRead(buttonPin27) == HIGH) {     
    ButtonSend1 = ButtonSend1+4;             
  }  
 buttonState28 = digitalRead(buttonPin28);
  if (digitalRead(buttonPin28) == HIGH) {     
    ButtonSend1 = ButtonSend1+2;             
  }  
if (ButtonSend1 != ButtonSend1old){ // gaan we versturen of niet?
  ButtonSend1old = ButtonSend1;
    ButtonSend1=ButtonSend1+21000; 
    char* xssend1 = (itoa(ButtonSend1,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* ButtonSend1Code = (xssend1);
    network.write(header,ButtonSend1Code,strlen(ButtonSend1Code)); 
    delay (transmitbuffer);
#ifdef DEBUG
    Serial.print(" ButtonSend1: ");
    Serial.print(ButtonSend1);
    Serial.print("   send: ");
    Serial.println(ButtonSend1Code);
#endif
#ifdef LCDfeedback
  Serial3.print(ButtonSend1Code);
#endif
} // end ButtonSend1
//--------  Eind Buttonsend groep 1 - D22->D28   -----------// 

//--------  Start Buttonsend groep 2 - D29->D35  -----------// 
  ButtonSend2 = 0;
  buttonState29 = digitalRead(buttonPin29);
  if (digitalRead(buttonPin29) == HIGH) {     
    ButtonSend2 = ButtonSend2+128;             
  } 
  buttonState30 = digitalRead(buttonPin30);
  if (digitalRead(buttonPin30) == HIGH) {     
    ButtonSend2 = ButtonSend2+64;             
  }   
  buttonState31 = digitalRead(buttonPin31);
  if (digitalRead(buttonPin31) == HIGH) {     
    ButtonSend2 = ButtonSend2+32;             
  }   
  buttonState32 = digitalRead(buttonPin32);
  if (digitalRead(buttonPin32) == HIGH) {     
    ButtonSend2 = ButtonSend2+16;             
  }   
  buttonState33 = digitalRead(buttonPin33);
  if (digitalRead(buttonPin33) == HIGH) {     
    ButtonSend2 = ButtonSend2+8;             
  }  
  buttonState34 = digitalRead(buttonPin34);
  if (digitalRead(buttonPin34) == HIGH) {     
    ButtonSend2 = ButtonSend2+4;             
  }  
 buttonState35 = digitalRead(buttonPin35);
  if (digitalRead(buttonPin35) == HIGH) {     
    ButtonSend2 = ButtonSend2+2;             
  }  
if (ButtonSend2 != ButtonSend2old){ // gaan we versturen of niet?
  ButtonSend2old = ButtonSend2;
    ButtonSend2=ButtonSend2+21500; 
    char* xssend2 = (itoa(ButtonSend2,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* ButtonSend2Code = (xssend2);
    network.write(header,ButtonSend2Code,strlen(ButtonSend2Code)); 
    delay (transmitbuffer);
} // end ButtonSend2
//--------  Eind Buttonsend groep 2 - D29->D35   -----------// 

//--------  Start Buttonsend groep 3 - D36->D42  -----------// 
  ButtonSend3 = 0;
  buttonState36 = digitalRead(buttonPin36);
  if (digitalRead(buttonPin36) == HIGH) {     
    ButtonSend3 = ButtonSend3+128;             
  } 
  buttonState37 = digitalRead(buttonPin37);
  if (digitalRead(buttonPin37) == HIGH) {     
    ButtonSend3 = ButtonSend3+64;             
  }   
  buttonState38 = digitalRead(buttonPin38);
  if (digitalRead(buttonPin38) == HIGH) {     
    ButtonSend3 = ButtonSend3+32;             
  }   
  buttonState39 = digitalRead(buttonPin39);
  if (digitalRead(buttonPin39) == HIGH) {     
    ButtonSend3 = ButtonSend3+16;             
  }   
  buttonState40 = digitalRead(buttonPin40);
  if (digitalRead(buttonPin40) == HIGH) {     
    ButtonSend3 = ButtonSend3+8;             
  }  
  buttonState41 = digitalRead(buttonPin41);
  if (digitalRead(buttonPin41) == HIGH) {     
    ButtonSend3 = ButtonSend3+4;             
  }  
 buttonState42 = digitalRead(buttonPin42);
  if (digitalRead(buttonPin42) == HIGH) {     
    ButtonSend3 = ButtonSend3+2;             
  }  
if (ButtonSend3 != ButtonSend3old){ // gaan we versturen of niet?
  ButtonSend3old = ButtonSend3;
    ButtonSend3=ButtonSend3+22000; 
    char* xssend3 = (itoa(ButtonSend3,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* ButtonSend3Code = (xssend3);
    network.write(header,ButtonSend3Code,strlen(ButtonSend3Code)); 
    delay (transmitbuffer);
} // end ButtonSend3
//--------  Eind Buttonsend groep 3 - D36->D42   -----------// 

//--------  Start Buttonsend groep 4 - D43->D49  -----------// 
  ButtonSend4 = 0;
  buttonState43 = digitalRead(buttonPin43);
  if (digitalRead(buttonPin43) == HIGH) {     
    ButtonSend4 = ButtonSend4+128;             
  } 
  buttonState44 = digitalRead(buttonPin44);
  if (digitalRead(buttonPin44) == HIGH) {     
    ButtonSend4 = ButtonSend4+64;             
  }   
  buttonState45 = digitalRead(buttonPin45);
  if (digitalRead(buttonPin45) == HIGH) {     
    ButtonSend4 = ButtonSend4+32;             
  }   
  buttonState46 = digitalRead(buttonPin46);
  if (digitalRead(buttonPin46) == HIGH) {     
    ButtonSend4 = ButtonSend4+16;             
  }   
  buttonState47 = digitalRead(buttonPin47);
  if (digitalRead(buttonPin47) == HIGH) {     
    ButtonSend4 = ButtonSend4+8;             
  }  
  buttonState48 = digitalRead(buttonPin48);
  if (digitalRead(buttonPin48) == HIGH) {     
    ButtonSend4 = ButtonSend4+4;             
  }  
 buttonState49 = digitalRead(buttonPin49);
  if (digitalRead(buttonPin49) == HIGH) {     
    ButtonSend4 = ButtonSend4+2;             
  }  
if (ButtonSend4 != ButtonSend4old){ // gaan we versturen of niet?
  ButtonSend4old = ButtonSend4;
    ButtonSend4=ButtonSend4+22500; 
    char* xssend4 = (itoa(ButtonSend4,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* ButtonSend4Code = (xssend4);
    network.write(header,ButtonSend4Code,strlen(ButtonSend4Code)); 
    delay (transmitbuffer);
} // end ButtonSend4
//--------  Eind Buttonsend groep 4 - D43->D49   -----------// 


//--------  Start Buttonsend groep 5 - D53->D2-11  -----------// 
  ButtonSend5 = 0;
  buttonState12 = digitalRead(buttonPin12);
  if (digitalRead(buttonPin12) == HIGH) {     
    ButtonSend5 = ButtonSend5+128;             
  } 
  buttonState2 = digitalRead(buttonPin2);
  if (digitalRead(buttonPin2) == HIGH) {     
    ButtonSend5 = ButtonSend5+64;             
  }   
  buttonState5 = digitalRead(buttonPin5);
  if (digitalRead(buttonPin5) == HIGH) {     
    ButtonSend5 = ButtonSend5+32;             
  }   
  buttonState6 = digitalRead(buttonPin6);
  if (digitalRead(buttonPin6) == HIGH) {     
    ButtonSend5 = ButtonSend5+16;             
  }   
  buttonState7 = digitalRead(buttonPin7);
  if (digitalRead(buttonPin7) == HIGH) {     
    ButtonSend5 = ButtonSend5+8;             
  }  
  buttonState10 = digitalRead(buttonPin10);
  if (digitalRead(buttonPin10) == HIGH) {     
    ButtonSend5 = ButtonSend5+4;             
  }  
 buttonState11 = digitalRead(buttonPin11);
  if (digitalRead(buttonPin11) == HIGH) {     
    ButtonSend5 = ButtonSend5+2;             
  }  
if (ButtonSend5 != ButtonSend5old){ // gaan we versturen of niet?
  ButtonSend5old = ButtonSend5;
    ButtonSend5=ButtonSend5+23000; 
    char* xssend5 = (itoa(ButtonSend5,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* ButtonSend5Code = (xssend5);
    network.write(header,ButtonSend5Code,strlen(ButtonSend5Code)); 
    delay (transmitbuffer);
} // end ButtonSend5
//--------  Eind Buttonsend groep 5 - D53->D2-11   -----------// 


//--------  Start Buttonsend groep 6 - D13  -----------// 
  ButtonSend6 = 0;
  buttonState13 = digitalRead(buttonPin13);
  if (digitalRead(buttonPin13) == HIGH) {     
    ButtonSend6 = ButtonSend6+128;             
  }  
  int servoraw20 = analogRead (A12);
  if(servoraw20 >= 500){ 
        ButtonSend6 = ButtonSend6+64;
  } 
    int servoraw21 = analogRead (A14);
  if(servoraw21 >= 500){ 
        ButtonSend6 = ButtonSend6+32;
  }    
if (ButtonSend6 != ButtonSend6old){ // gaan we versturen of niet?
  ButtonSend6old = ButtonSend6;
    ButtonSend6=ButtonSend6+23500; 
    char* xssend6 = (itoa(ButtonSend6,buf,10));
    RF24NetworkHeader header(/*to node*/ other_node);
    const char* ButtonSend6Code = (xssend6);
    network.write(header,ButtonSend6Code,strlen(ButtonSend6Code)); 
    delay (transmitbuffer);
} // end ButtonSend6
//--------  Eind Buttonsend groep 6 - D13   -----------// 

}

the receivercode
Code:
#include <Servo.h>
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>

//#define DEBUG // uncomment for feedback through the serialmonitor
//#define DynChannel // uncomment for setting dynamic channel select. 
                     // Ananolg pin 13 for potmeter. Reset to use channel
                     // an extra Arduino will be needed (will follow)
                     // RX/TX to serial 1 
//#define RESET // do you have want resetbutton? 
                // Stick it on pin A15, and add a 10K pulldown. Led on pin A14

int channel = 80; // what channel are we on? // comment for dynamic channel control
int channelold;
char buffer[64]; 
char msg[140] = "";

// let's define some servo's
Servo servo1; Servo servo2; Servo servo3; Servo servo4; 
/*Servo servo5; Servo servo6; Servo servo7; Servo servo8; */
Servo servo9; Servo servo10; Servo servo11; Servo servo12;
// minimum and maximum range for the servo
int servmin1 = 16; int servmax1 = 177; 
int servmin2 = 16; int servmax2 = 177;
int servmin3 = 16; int servmax3 = 177; 
int servmin4 = 16; int servmax4 = 177;
/*int servmin5 = 0; int servmax5 = 255; 
int servmin6 = 0; int servmax6 = 255;
int servmin7 = 0; int servmax7 = 255; 
int servmin8 = 0; int servmax8 = 255;*/
int servmin9 = 16; int servmax9 = 177; 
int servmin10 = 16; int servmax10 = 177;
int servmin11 = 16; int servmax11 = 177;
int servmin12 = 16; int servmax12 = 177;

int pinNumber; int pinValue;
int Pin22 = 22; int Pin23 = 23; int Pin24 = 24; int Pin25 = 25;
int Pin26 = 26; int Pin27 = 27; int Pin28 = 28; int Pin29 = 29;
int Pin30 = 30; int Pin31 = 31; int Pin32 = 32; int Pin33 = 33;
int Pin34 = 34; int Pin35 = 35; int Pin36 = 36; int Pin37 = 37;
int Pin38 = 38; int Pin39 = 39; int Pin40 = 40; int Pin41 = 41;
int Pin42 = 42; int Pin43 = 43; int Pin44 = 44; int Pin45 = 45;
int Pin46 = 46; int Pin47 = 47; int Pin48 = 48; int Pin49 = 49;
int Pin53 = 53; int Pin8 = A0; int Pin9 = A1; int Pin10 = A2;
int Pin11 = A3; int Pin12 = A4; int Pin13 = A5; 
int Pin14 = A6; int Pin15 = A7; 

#ifdef RESET
const int resetPin = A15;          // the number of the pushbutton pin
const int ResetState = 0;        // variable for reading the pushbutton status
const int resetled = A14;         // light up led when reset
const int timetoreset = 500;     // how long delay after reset
#endif

#ifdef DynChannel
const int ChannelPin = A13;      // select the input pin for the channel select
int ChannelValue = 0;            // temp. channel until read
int channelold;                  // just needed as a default when setting channel dynamic
#endif

// nRF24L01(+) radio attached to SPI and pins 8 & 9
RF24 radio(8,9);

// Network uses that radio
RF24Network network(radio);

// Address of our node
const uint16_t this_node = 0; // the receiver code

// Address of the other node
const uint16_t other_node = 1; // the transmittercode

void defaultvalues(){ 
}

void setup(void)
{
  pinMode(Pin22, OUTPUT); pinMode(Pin23, OUTPUT);
  pinMode(Pin24, OUTPUT); pinMode(Pin25, OUTPUT);
  pinMode(Pin26, OUTPUT); pinMode(Pin27, OUTPUT);
  pinMode(Pin28, OUTPUT); pinMode(Pin29, OUTPUT);
  pinMode(Pin30, OUTPUT); pinMode(Pin31, OUTPUT);
  pinMode(Pin32, OUTPUT); pinMode(Pin33, OUTPUT);
  pinMode(Pin34, OUTPUT); pinMode(Pin35, OUTPUT);
  pinMode(Pin36, OUTPUT); pinMode(Pin37, OUTPUT);
  pinMode(Pin38, OUTPUT); pinMode(Pin39, OUTPUT);
  pinMode(Pin40, OUTPUT); pinMode(Pin41, OUTPUT);
  pinMode(Pin42, OUTPUT); pinMode(Pin43, OUTPUT);
  pinMode(Pin44, OUTPUT); pinMode(Pin45, OUTPUT);
  pinMode(Pin46, OUTPUT); pinMode(Pin47, OUTPUT);
  pinMode(Pin48, OUTPUT); pinMode(Pin49, OUTPUT);
  pinMode(Pin53, OUTPUT); 
  pinMode(Pin8, OUTPUT); pinMode(Pin9, OUTPUT);
  pinMode(Pin10, OUTPUT); pinMode(Pin11, OUTPUT);
  pinMode(Pin12, OUTPUT); pinMode(Pin13, OUTPUT);
  pinMode(Pin14, OUTPUT); pinMode(Pin15, OUTPUT);
  
  digitalWrite(Pin22, LOW); digitalWrite(Pin23, LOW);
  digitalWrite(Pin24, LOW); digitalWrite(Pin25, LOW);
  digitalWrite(Pin26, LOW); digitalWrite(Pin27, LOW);
  digitalWrite(Pin28, LOW); digitalWrite(Pin29, LOW);
  digitalWrite(Pin30, LOW); digitalWrite(Pin31, LOW);
  digitalWrite(Pin32, LOW); digitalWrite(Pin33, LOW);
  digitalWrite(Pin34, LOW); digitalWrite(Pin35, LOW);
  digitalWrite(Pin36, LOW); digitalWrite(Pin37, LOW);
  digitalWrite(Pin38, LOW); digitalWrite(Pin39, LOW);
  digitalWrite(Pin40, LOW); digitalWrite(Pin41, LOW);
  digitalWrite(Pin42, LOW); digitalWrite(Pin43, LOW);
  digitalWrite(Pin44, LOW); digitalWrite(Pin45, LOW);
  digitalWrite(Pin46, LOW); digitalWrite(Pin47, LOW);
  digitalWrite(Pin48, LOW); digitalWrite(Pin49, LOW);
  digitalWrite(Pin53, LOW); 
  digitalWrite(Pin8, LOW); digitalWrite(Pin9, LOW);
  digitalWrite(Pin10, LOW); digitalWrite(Pin11, LOW);
  digitalWrite(Pin12, LOW); digitalWrite(Pin13, LOW);
  digitalWrite(Pin14, LOW); digitalWrite(Pin15, LOW);
  
#ifdef RESET  
  pinMode(resetPin, INPUT);
  pinMode(resetled, OUTPUT); 
#endif  
  Serial.begin(9600);
#ifdef DEBUG
  Serial.println("RF24Network/nummeriek protocol ontvangerzijde");
  Serial.print("Encoder channel: ");
  Serial.println(channel);
#endif

// sound serial 1
  Serial1.begin(9600);

//  what servo goes in what port
  servo1.attach(2); servo2.attach(3); servo3.attach(4); servo4.attach(5); 
  /*servo5.attach(6); servo6.attach(7); servo7.attach(10); servo8.attach(11); */
  servo9.attach(6); servo10.attach(7); servo11.attach(10); servo12.attach(11);   

#ifdef DynChannel
  ChannelValue = analogRead (ChannelPin);
  int channel = map(ChannelValue,0,1023,80,90);
  int channelsend = channel;
  channelsend = channelsend + 1000;
  Serial1.write(channelsend);
#endif

  SPI.begin();
  radio.begin();
  network.begin(/*channel*/ channel, /*node address*/ this_node);
#ifdef commpin53
  digitalWrite(commpin,HIGH);         
#endif
}
#ifdef RESET
void(* resetFunc) (void) = 0; //declare reset function @ address 0
#endif

void loop(void) 
{
#ifdef RESET
  // reset button
  int ResetState = analogRead(resetPin);
  if (ResetState >= 10) {     
 //   analogWrite(resetled,100); // just ot test button
    delay(timetoreset);
    resetFunc();  //call reset
  }
  else {
 //   analogWrite(resetled,20);
  }  
#endif

#ifdef DynChannel
  ChannelValue = analogRead (ChannelPin);
  int channel = map(ChannelValue,0,1023,1,99);
  if (channel != channelold){
    int channelsend = channel;
    channelsend = channelsend + 1000;
    Serial1.write(channelsend);
  }
#endif 
#ifdef DEBUG
  if (channelold != channel){
    Serial.print("Channel: ");
    Serial.print(channel);
    Serial.print("    ");
    channelold = channel;
  }
#endif 

  // Pump the network regularly
  network.update();

  // Is there anything ready for us?
  while ( network.available() )
  {
    // If so, grab it and print it out
    RF24NetworkHeader header;
    static char message[64];
    network.read(header,message,sizeof(message));
    splitString(message);
  }
}

void splitString(char* data) {  
  char* parameter; 
  parameter = strtok (data, " ,"); 
  while (parameter != NULL) { 
    setFunctionelegroep(parameter); 
    parameter = strtok (NULL, " ,"); 
  } 
  // Clear the text and serial buffers 
  for (int x=0; x<64; x++) { 
    buffer[x]='\0'; 
  } 
  //  Serial.flush(); 
}

// initialiseer functie. Gewoon i typen en alles gaat naar 0 en middenpositie
void setFunctionelegroep(char* data) { 

//------------------- Start functionele groep 1 ---------------------//
  if (data[0] == '1') { // funtionele groep 
    int servoin1 = strtol(data+1, NULL, 10); 

//-------------- Groep1 / Servo 1 input/checker/send ----------------//
    if (servoin1 >= 1000 && servoin1 <1500){
      int serv1 = servoin1 - 1000;
      if (serv1 >=0){
        serv1 = map(serv1, 0, 255, servmin1, servmax1);
#ifdef DEBUG
        Serial.print("Servo 1 is set to: ");
        Serial.println(serv1); 
#endif
        servo1.write(serv1); 
      }
    }
//-------------   End of groep 1 / Servo 1 control   ----------------//   

//-------------- Groep1 / Servo 2 input/checker/send ----------------//
    if (servoin1 >= 1500 && servoin1 <2000){
      int serv2 = servoin1 - 1500;
      if (serv2 >=0){
        serv2 = map(serv2, 0, 255, servmin2, servmax2);
#ifdef DEBUG
        Serial.print("Servo 2 is set to: ");
        Serial.println(serv2); 
#endif
        servo2.write(serv2); 
      }
    }
//-------------   End of groep 1 / Servo 2 control   ----------------// 

//-------------- Groep1 / Servo 3 input/checker/send ----------------//
    if (servoin1 >= 2000 && servoin1 <2500){
      int serv3 = servoin1 - 2000;
      if (serv3 >=0){
        serv3 = map(serv3, 0, 255, servmin3, servmax3);
#ifdef DEBUG
        Serial.print("Servo 3 is set to: ");
        Serial.println(serv3); 
#endif
        servo3.write(serv3); 
      }
    }
//-------------   End of groep 1 / Servo 3 control   ----------------// 

//-------------- Groep1 / Servo 4 input/checker/send ----------------//
    if (servoin1 >= 2500 && servoin1 <3000){
      int serv4 = servoin1 - 2500;
      if (serv4 >=0){
        serv4 = map(serv4, 0, 255, servmin4, servmax4);
#ifdef DEBUG
        Serial.print("Servo 4 is set to: ");
        Serial.println(serv4); 
#endif
/*        
int motorgeluid = map(serv4,55,190,0,25);
    if (motorgeluid == 0){Serial1.write('9');}
    if (motorgeluid == 1){Serial1.write('8');}
    if (motorgeluid == 2){Serial1.write('7');}    
    if (motorgeluid == 3){Serial1.write('6');}    
    if (motorgeluid == 4){Serial1.write('5');}    
    if (motorgeluid == 5){Serial1.write('4');}    
    if (motorgeluid == 6){Serial1.write('3');}    
    if (motorgeluid == 7){Serial1.write('2');}    
    if (motorgeluid == 8){Serial1.write('1');}
    if (motorgeluid == 9){Serial1.write('0');}
    if (motorgeluid == 10){Serial1.write('1');}
    if (motorgeluid == 11){Serial1.write('2');}
    if (motorgeluid == 12){Serial1.write('3');}
    if (motorgeluid == 13){Serial1.write('4');}
    if (motorgeluid == 14){Serial1.write('5');}
    if (motorgeluid == 15){Serial1.write('6');}
    if (motorgeluid == 16){Serial1.write('7');}
    if (motorgeluid == 17){Serial1.write('8');}
    if (motorgeluid == 18){Serial1.write('9');}
    */
    servo4.write(serv4); 
        
      }
    }
//-------------   End of groep 1 / Servo 2 control   ----------------// 

//-------------- Groep1 / Servo 9 input/checker/send ----------------//
    if (servoin1 >= 5000 && servoin1 <5500){
      int serv9 = servoin1 - 5000;
      if (serv9 >=0){
        serv9 = map(serv9, 0, 255, servmin9, servmax9);
#ifdef DEBUG
        Serial.print("Servo 9 is set to: ");
        Serial.println(serv9); 
#endif
        servo9.write(serv9); 
      }
    }
//-------------   End of groep 1 / Servo 9 control   ----------------// 

//-------------- Groep1 / Servo 10 input/checker/send ----------------//
    if (servoin1 >= 5500 && servoin1 <6000){
      int serv10 = servoin1 - 5500;
      if (serv10 >=0){
        serv10 = map(serv10, 0, 255, servmin10, servmax10);
#ifdef DEBUG
        Serial.print("Servo 10 is set to: ");
        Serial.println(serv10); 
#endif
        servo10.write(serv10); 
      }
    }
//-------------   End of groep 1 / Servo 10 control   ----------------// 

//-------------- Groep1 / Servo 11  Volume 1 ----------------//
    if (servoin1 >= 6000 && servoin1 <6500){
      int serv11 = servoin1 - 6000;
      if (serv11 >=0){
        serv11 = map(serv11, 0, 255, servmin11, servmax11);
#ifdef DEBUG
        Serial.print("Servo 11 is set to: ");
        Serial.println(serv11); 
#endif
        servo11.write(serv11); 
      }
    }
//-------------   End of groep 1 / Volume 1   ----------------// 

//-------------- Groep1 / Servo 12 Volume 2  ----------------//
    if (servoin1 >= 6500 && servoin1 <7000){
      int serv12 = servoin1 - 6500;
      if (serv12 >=0){
        serv12 = map(serv12, 0, 255, servmin12, servmax12);
#ifdef DEBUG
        Serial.print("Servo 12 is set to: ");
        Serial.println(serv12); 
#endif
        servo12.write(serv12); 
      }
    }
//-------------   End of groep 1 / Volume 2   ----------------// 

} // einde functionele groep 1


//------------------- Start functionele groep 2 ---------------------//
  if (data[0] == '2') { // funtionele groep 
    int buttonin1 = strtol(data+1, NULL, 10); 

//-------------- Groep2 / buttongroep 1 D22->D28 -----------//
  if ( buttonin1 >= 1000 && buttonin1 <1500){
    int butto1 = buttonin1 - 1000;
    if (butto1 >=0){
#ifdef DEBUG
  Serial.print("buttongroep1 code is: ");
  Serial.println(butto1); 
#endif
////////////////////////////////// D22 ///////////////////////////////
  if (butto1 >= 128) {
    digitalWrite(Pin22, HIGH);
#ifdef DEBUG
  Serial.println("Pin22 = on");
#endif
    butto1 = (butto1 - 128); 
  }
  else {
    digitalWrite(Pin22, LOW);
  }
////////////////////////////////// D23 ///////////////////////////////
  if (butto1 >= 64) {
    digitalWrite(Pin23, HIGH);
#ifdef DEBUG
  Serial.println("Pin23 = on"); 
#endif
    butto1 = (butto1 - 64);
  }  
  else {
    digitalWrite(Pin23, LOW);
  }
////////////////////////////////// D24 ///////////////////////////////
  if (butto1 >= 32) {
    digitalWrite(Pin24, HIGH);
#ifdef DEBUG
  Serial.println("Pin24 = on");
#endif
    butto1 = (butto1 - 32); 
  }   
  else {
    digitalWrite(Pin24, LOW);
  }   
////////////////////////////////// D25 ///////////////////////////////
  if (butto1 >= 16) {
    digitalWrite(Pin25, HIGH);
#ifdef DEBUG
  Serial.println("Pin25 = on");
#endif
    butto1 = (butto1 - 16); 
  }    
  else {
    digitalWrite(Pin25, LOW);
  }   
////////////////////////////////// D26 ///////////////////////////////
  if (butto1 >= 8) {
    digitalWrite(Pin26, HIGH);
#ifdef DEBUG
  Serial.println("Pin26 = on");
#endif 
    butto1 = (butto1 - 8);
  }    
  else {
    digitalWrite(Pin26, LOW);
  }   
////////////////////////////////// D27 ///////////////////////////////
  if (butto1 >= 4) {
    digitalWrite(Pin27, HIGH);
#ifdef DEBUG
  Serial.println("Pin27 = on");
#endif
    butto1 = (butto1 - 4); 
  }
  else {
    digitalWrite(Pin27, LOW);
  }  
////////////////////////////////// D28 ///////////////////////////////
  if (butto1 >= 2) {
    digitalWrite(Pin28, HIGH);
#ifdef DEBUG
  Serial.println("Pin28 = on");
#endif
    butto1 = (butto1 - 2); 
  } 
  else {
    digitalWrite(Pin28, LOW);
  }    
 }
}
//-------------   End of groep 2 / buttongroep 1 D22-D28   ------------//   

//-------------- Groep2 / buttongroep 2 D29->D35 -----------//
  if ( buttonin1 >= 1500 && buttonin1 <2000){
    int butto2 = buttonin1 - 1500;
    if (butto2 >=0){
#ifdef DEBUG
  Serial.print("buttongroep2 code is: ");
  Serial.println(butto2); 
#endif
////////////////////////////////// D29 ///////////////////////////////
  if (butto2 >= 128) {
    digitalWrite(Pin29, HIGH);
#ifdef DEBUG
  Serial.println("Pin29 = on");
#endif
    butto2 = (butto2 - 128); 
  }
  else {
    digitalWrite(Pin29, LOW);
  }
////////////////////////////////// D30 ///////////////////////////////
  if (butto2 >= 64) {
    digitalWrite(Pin30, HIGH);
#ifdef DEBUG
  Serial.println("Pin30 = on"); 
#endif
    butto2 = (butto2 - 64);
  }  
  else {
    digitalWrite(Pin30, LOW);
  }
///////////////////////////////// D31 ///////////////////////////////
  if (butto2 >= 32) {
    digitalWrite(Pin31, HIGH);
#ifdef DEBUG
  Serial.println("Pin31 = on");
#endif
    butto2 = (butto2 - 32); 
  }   
  else {
    digitalWrite(Pin31, LOW);
  }   
////////////////////////////////// D32 ///////////////////////////////
  if (butto2 >= 16) {
    digitalWrite(Pin32, HIGH);
#ifdef DEBUG
  Serial.println("Pin32 = on");
#endif
    butto2 = (butto2 - 16); 
  }    
  else {
    digitalWrite(Pin32, LOW);
  }   
////////////////////////////////// D33 ///////////////////////////////
  if (butto2 >= 8) {
    digitalWrite(Pin33, HIGH);
#ifdef DEBUG
  Serial.println("Pin33 = on");
#endif 
    butto2 = (butto2 - 8);
  }    
  else {
    digitalWrite(Pin33, LOW);
  }   
////////////////////////////////// D34 ///////////////////////////////
  if (butto2 >= 4) {
    digitalWrite(Pin34, HIGH);
#ifdef DEBUG
  Serial.println("Pin34 = on");
#endif
    butto2 = (butto2 - 4); 
  }
  else {
    digitalWrite(Pin34, LOW);
  }  
////////////////////////////////// D35 ///////////////////////////////
  if (butto2 >= 2) {
    digitalWrite(Pin35, HIGH);
#ifdef DEBUG
  Serial.println("Pin35 = on");
#endif
    butto2 = (butto2 - 2); 
  } 
  else {
    digitalWrite(Pin35, LOW);
  }    
 }
}
//-------------   End of groep 2 / buttongroep 2 D29-D35   ------------//   

//-------------- Groep2 / buttongroep 3 D36->D42 -----------//
  if ( buttonin1 >= 2000 && buttonin1 <2500){
    int butto3 = buttonin1 - 2000;
    if (butto3 >=0){
#ifdef DEBUG
  Serial.print("buttongroep3 code is: ");
  Serial.println(butto3); 
#endif
////////////////////////////////// D36 ///////////////////////////////
  if (butto3 >= 128) {
    digitalWrite(Pin36, HIGH);
#ifdef DEBUG
  Serial.println("Pin36 = on");
#endif
    butto3 = (butto3 - 128); 
  }
  else {
    digitalWrite(Pin36, LOW);
  }
////////////////////////////////// D37 ///////////////////////////////
  if (butto3 >= 64) {
    digitalWrite(Pin37, HIGH);
#ifdef DEBUG
  Serial.println("Pin37 = on"); 
#endif
    butto3 = (butto3 - 64);
  }  
  else {
    digitalWrite(Pin37, LOW);
  }
////////////////////////////////// D38 ///////////////////////////////
  if (butto3 >= 32) {
    digitalWrite(Pin38, HIGH);
#ifdef DEBUG
  Serial.println("Pin38 = on");
#endif
    butto3 = (butto3 - 32); 
  }   
  else {
    digitalWrite(Pin38, LOW);
  }   
////////////////////////////////// D39 ///////////////////////////////
  if (butto3 >= 16) {
    digitalWrite(Pin39, HIGH);
#ifdef DEBUG
  Serial.println("Pin39 = on");
#endif
    butto3 = (butto3 - 16); 
  }    
  else {
    digitalWrite(Pin39, LOW);
  }   
////////////////////////////////// D40 ///////////////////////////////
  if (butto3 >= 8) {
    digitalWrite(Pin40, HIGH);
#ifdef DEBUG
  Serial.println("Pin40 = on");
#endif 
    butto3 = (butto3 - 8);
  }    
  else {
    digitalWrite(Pin40, LOW);
  }   
////////////////////////////////// D41 ///////////////////////////////
  if (butto3 >= 4) {
    digitalWrite(Pin41, HIGH);
#ifdef DEBUG
  Serial.println("Pin41 = on");
#endif
    butto3 = (butto3 - 4); 
  }
  else {
    digitalWrite(Pin41, LOW);
  }  
////////////////////////////////// D42 ///////////////////////////////
  if (butto3 >= 2) {
    digitalWrite(Pin42, HIGH);
#ifdef DEBUG
  Serial.println("Pin42 = on");
#endif
    butto3 = (butto3 - 2); 
  } 
  else {
    digitalWrite(Pin42, LOW);
  }    
 }
}
//-------------   End of groep 2 / buttongroep 3 D35-D42   ------------//   

//-------------- Groep2 / buttongroep 4 D43->D49 -----------//
  if ( buttonin1 >= 2500 && buttonin1 <3000){
    int butto4 = buttonin1 - 2500;
    if (butto4 >=0){
#ifdef DEBUG
  Serial.print("buttongroep4 code is: ");
  Serial.println(butto4); 
#endif
////////////////////////////////// D43 ///////////////////////////////
  if (butto4 >= 128) {
    digitalWrite(Pin43, HIGH);
#ifdef DEBUG
  Serial.println("Pin43 = on");
#endif
    butto4 = (butto4 - 128); 
  }
  else {
    digitalWrite(Pin43, LOW);
  }
////////////////////////////////// D44 ///////////////////////////////
  if (butto4 >= 64) {
    digitalWrite(Pin44, HIGH);
#ifdef DEBUG
  Serial.println("Pin44 = on"); 
#endif
    butto4 = (butto4 - 64);
  }  
  else {
    digitalWrite(Pin44, LOW);
  }
////////////////////////////////// D45 ///////////////////////////////
  if (butto4 >= 32) {
    digitalWrite(Pin45, HIGH);
#ifdef DEBUG
  Serial.println("Pin45 = on");
#endif
    butto4 = (butto4 - 32); 
  }   
  else {
    digitalWrite(Pin45, LOW);
  }   
////////////////////////////////// D46 ///////////////////////////////
  if (butto4 >= 16) {
    digitalWrite(Pin46, HIGH);
#ifdef DEBUG
  Serial.println("Pin46 = on");
#endif
    butto4 = (butto4 - 16); 
  }    
  else {
    digitalWrite(Pin46, LOW);
  }   
////////////////////////////////// D47 ///////////////////////////////
  if (butto4 >= 8) {
    digitalWrite(Pin47, HIGH);
#ifdef DEBUG
  Serial.println("Pin47 = on");
#endif 
    butto4 = (butto4 - 8);
  }    
  else {
    digitalWrite(Pin47, LOW);
  }   
////////////////////////////////// D48 ///////////////////////////////
  if (butto4 >= 4) {
    digitalWrite(Pin48, HIGH);
#ifdef DEBUG
  Serial.println("Pin48 = on");
#endif
    butto4 = (butto4 - 4); 
  }
  else {
    digitalWrite(Pin48, LOW);
  }  
////////////////////////////////// D49 ///////////////////////////////
  if (butto4 >= 2) {
    digitalWrite(Pin49, HIGH);
#ifdef DEBUG
  Serial.println("Pin49 = on");
#endif
    butto4 = (butto4 - 2); 
  } 
  else {
    digitalWrite(Pin49, LOW);
  }    
 }
}
//-------------   End of groep 2 / buttongroep 5 A8-A14   ------------//   

//-------------- Groep2 / buttongroep 5 D43->D49 -----------//
  if ( buttonin1 >= 3000 && buttonin1 <3500){
    int butto5 = buttonin1 - 3000;
    if (butto5 >=0){
#ifdef DEBUG
  Serial.print("buttongroep5 code is: ");
  Serial.println(butto5); 
#endif
////////////////////////////////// A14 ///////////////////////////////
  if (butto5 >= 128) {
    digitalWrite(Pin14, HIGH);
#ifdef DEBUG
  Serial.println("Pin14 = on");
#endif
    butto5 = (butto5 - 128); 
  }
  else {
    digitalWrite(Pin14, LOW);
  }
////////////////////////////////// A13 ///////////////////////////////
  if (butto5 >= 64) {
    digitalWrite(Pin13, HIGH);
#ifdef DEBUG
  Serial.println("Pin13 = on"); 
#endif
    butto5 = (butto5 - 64);
  }  
  else {
    digitalWrite(Pin13, LOW);
  }
////////////////////////////////// A12 ///////////////////////////////
  if (butto5 >= 32) {
    digitalWrite(Pin12, HIGH);
#ifdef DEBUG
  Serial.println("Pin12 = on");
#endif
    butto5 = (butto5 - 32); 
  }   
  else {
    digitalWrite(Pin12, LOW);
  }   
////////////////////////////////// A11 ///////////////////////////////
  if (butto5 >= 16) {
    digitalWrite(Pin11, HIGH);
#ifdef DEBUG
  Serial.println("Pin11 = on");
#endif
    butto5 = (butto5 - 16); 
  }    
  else {
    digitalWrite(Pin11, LOW);
  }   
////////////////////////////////// A10 ///////////////////////////////
  if (butto5 >= 8) {
    digitalWrite(Pin10, HIGH);
#ifdef DEBUG
  Serial.println("Pin10 = on");
#endif 
    butto5 = (butto5 - 8);
  }    
  else {
    digitalWrite(Pin10, LOW);
  }   
////////////////////////////////// A9 ///////////////////////////////
  if (butto5 >= 4) {
    digitalWrite(Pin9, HIGH);
#ifdef DEBUG
  Serial.println("Pin9 = on");
#endif
    butto5 = (butto5 - 4); 
  }
  else {
    digitalWrite(Pin9, LOW);
  }  
////////////////////////////////// A8 ///////////////////////////////
  if (butto5 >= 2) {
    digitalWrite(Pin8, HIGH);
#ifdef DEBUG
  Serial.println("Pin8 = on");
#endif
    butto5 = (butto5 - 2); 
  } 
  else {
    digitalWrite(Pin8, LOW);
  }    
 }
}
//-------------   End of groep 2 / buttongroep 5 A8-A14   ------------//   




//-------------- Groep2 / buttongroep 6 A15 -----------//
  if ( buttonin1 >= 3500 && buttonin1 <4000){
    int butto6 = buttonin1 - 3500;
    if (butto6 >=0){
#ifdef DEBUG
  Serial.print("buttongroep6 code is: ");
  Serial.println(butto6); 
#endif
////////////////////////////////// D53 ///////////////////////////////
  if (butto6 >= 128) {
    digitalWrite(Pin15, HIGH);
#ifdef DEBUG
  Serial.println("Pin15 = on");
#endif
    butto6 = (butto6 - 128); 
  }
  else {
    digitalWrite(Pin15, LOW);
  }
 }
}
//-------------   End of groep 2 / buttongroep 5 D53   ------------//   


  } // einde functionele groep 2   

} // void loop
Dutchraptor is online now Find More Posts by Dutchraptor
Last edited by Dutchraptor; May 07, 2014 at 05:21 AM.
Reply With Quote
Sign up now
to remove ads between posts
Old Feb 16, 2013, 12:18 PM
Registered User
tweety777's Avatar
Vlaardingen, The Netherlands
Joined Nov 2008
1,336 Posts
Looks great, thanks for sharing.
I'll be following this one closely.

Greetings Josse
tweety777 is offline Find More Posts by tweety777
Reply With Quote
Old Feb 16, 2013, 12:28 PM
---o-O-o---
blutoh's Avatar
United States, NJ, Livingston
Joined Mar 2012
1,575 Posts
Subscribed. Thanks and welcome Danny

I was just soliciting this kind of information in another post.

Pete
blutoh is online now Find More Posts by blutoh
Reply With Quote
Old Feb 16, 2013, 05:41 PM
made of fire and pop rocks
bgnome's Avatar
Richmond Virginia
Joined Oct 2009
1,710 Posts
lloks great and sounds very interesing, posting to subscribe!

this is just the stuff we were looking for with the formation of this new forum
bgnome is offline Find More Posts by bgnome
Reply With Quote
Old Feb 16, 2013, 06:57 PM
Spreckels Lake, GGP, SF, CA
craig_c's Avatar
USA, CA, San Francisco
Joined Apr 2007
3,631 Posts
oh YEAH!!
craig_c is offline Find More Posts by craig_c
RCG Plus Member
Old Feb 16, 2013, 07:52 PM
made of fire and pop rocks
bgnome's Avatar
Richmond Virginia
Joined Oct 2009
1,710 Posts
I think the stencils for the custom photo etched PCB's is a very nice touch personally.

print those out, treat your blank PCB with the proper etching chemicals, lay the print out over it subject it too intense white light, then "develop it" use a tight dremel to cut out the pin holes.
bgnome is offline Find More Posts by bgnome
Reply With Quote
Old Feb 16, 2013, 10:48 PM
Registered User
Dutchraptor's Avatar
The Netherlands, ZH, Hoogvliet
Joined Jul 2008
286 Posts
The PCB are made using Press'n Peel. I bought it at ebay. It's more common in America then in Europe. Just print the PCB to the blue side with a cheap laser printer, cut it out and use your wifes iron to transfer it to the blank. After that, you just need to etch it. I used to use the light methode, but it's getting harder to find proper material.

Danny
Dutchraptor is online now Find More Posts by Dutchraptor
Reply With Quote
Old Feb 16, 2013, 11:35 PM
made of fire and pop rocks
bgnome's Avatar
Richmond Virginia
Joined Oct 2009
1,710 Posts
My wifes iron?
can't I just use one of my own? Like the one for setting monokote? or the one I use for making Sailboat sails?

what about the regular steam Iron I have for pleating stuff?


I mean.. I think my wife has a tiny travel one.. I'm not sure... Lord knows if I have ever seen her use one...




bgnome is offline Find More Posts by bgnome
Reply With Quote
Old Feb 16, 2013, 11:52 PM
Spreckels Lake, GGP, SF, CA
craig_c's Avatar
USA, CA, San Francisco
Joined Apr 2007
3,631 Posts
What about the one I use for my breacan an fheilidh?
craig_c is offline Find More Posts by craig_c
RCG Plus Member
Old Feb 17, 2013, 02:02 AM
Registered User
Deckie's Avatar
Australia, WA, Garden Island
Joined Nov 2010
456 Posts
Thanks for that Dutchraptor, your code is excellent

Some of the // commentary in it being in Dutch is a bit unfortunate, but i'm working it out with the help of Google Translate
Deckie is offline Find More Posts by Deckie
Reply With Quote
Old Feb 17, 2013, 08:38 AM
Registered User
Dutchraptor's Avatar
The Netherlands, ZH, Hoogvliet
Joined Jul 2008
286 Posts
Sorry about the dutch comment. It is a cut-down version of a newer code that is in beta testing. If I have some more time, I will final test this beta release with the extra channel selector and LCD. But then, this is only the basic version. The transmitter version is for a newer shield then used in the graupner transmitter. Still a test version, but it should be stable (just a lot of pin swapped around, better commenting and #defines).

Tell me if you run into strange things so I can update the software. That way we can all benefit from it. Don't you just love OpenSource.

Danny
Dutchraptor is online now Find More Posts by Dutchraptor
Reply With Quote
Old Feb 17, 2013, 04:06 PM
---o-O-o---
blutoh's Avatar
United States, NJ, Livingston
Joined Mar 2012
1,575 Posts
Danny,

Is this transceiver the same as the NRF24L01 that you are using?

It's not obvious to me which Arduino boards you are using, Uno, Due, or Mega?

Also, which side of the pcb is the "blue" side. The one showing in your post?
EDIT: I found a How-To page on using the Press-n-Peel.

Thnx,
Pete
blutoh is online now Find More Posts by blutoh
Last edited by blutoh; Feb 17, 2013 at 08:34 PM.
Reply With Quote
Old Feb 17, 2013, 04:56 PM
Spreckels Lake, GGP, SF, CA
craig_c's Avatar
USA, CA, San Francisco
Joined Apr 2007
3,631 Posts
Jargon Watch: nRF24L01

Time out! Guys, remember not everybody speak'a da geek!

nRF24L01: Component Chip - "The nRF24L01 is a highly integrated, ultra low power (ULP) 2Mbps RF transceiver IC for the 2.4GHz ISM (Industrial, Scientific and Medical) band," made by Nordic Semiconductor. In other words a chip you can base a bidirectional RC system around. PDF Spec. Sheet
craig_c is offline Find More Posts by craig_c
RCG Plus Member
Last edited by craig_c; Feb 17, 2013 at 05:13 PM.
Reply With Quote
Old Feb 17, 2013, 10:54 PM
Registered User
Dutchraptor's Avatar
The Netherlands, ZH, Hoogvliet
Joined Jul 2008
286 Posts
Hi guys,
I use these kind of transceivers:
http://www.ebay.com/itm/NRF24L01-RF-...item3a79972429

Cheap and simple. All the info on how to use them + library came from:
http://arduino-info.wikispaces.com/N...1-2.4GHz-HowTo

I use 2 Arduino Mega's for this project and 2 NRF units. The NRF's use 7 wires. They say it uses 3.3 volt, but have them on the 5volt. I think there is a regulator on these things, but please test on 3.3 volt before using 5volt.

MEGA/328
NRFpin 1 => gnd/GND
NRFpin 2 = > 3.3V!!!/3.3V!!!
NRFpin 3 = > 8/8
NRFpin 4 = > 9/9
NRFpin 5 = > 52/13
NRFpin 6 = > 51/11
NRFpin 7 = > 50/12
NRFpin 8 = > NC/NC

Danny
Dutchraptor is online now Find More Posts by Dutchraptor
Last edited by Dutchraptor; Feb 17, 2013 at 11:00 PM.
Reply With Quote
Old Feb 18, 2013, 09:44 AM
---o-O-o---
blutoh's Avatar
United States, NJ, Livingston
Joined Mar 2012
1,575 Posts
Hi Danny,

I have been reading thru the code to get an idea of your design. Do you have any diagram or flow chart of the system I can look at? I don't see from the pictures how you interface the arduino, the PCBs and the rradio module all together. I will be ordering some mega's this week, probably the mega with 256Kb, like these. This model does not use the FTDI USB-to-serial driver chip. Instead, it uses the ATmega16U2 programmed as a USB-to-serial converter. Let me know if thats presents a problem, and if you think a different model would be better.

Thnx,
Pete
blutoh is online now Find More Posts by blutoh
Last edited by blutoh; Feb 18, 2013 at 09:55 AM.
Reply With Quote
Reply


Thread Tools

Similar Threads
Category Thread Thread Starter Forum Replies Last Post
New Product Open Source Lights - Arduino based RC Light Controller LukeZ DIY Electronics 42 Jun 30, 2014 09:10 PM
Discussion Arduino Uno Based Flight Controller? alexgator Multirotor Electronics 4 Feb 15, 2013 12:49 AM
Discussion I want to auto controlled RC helicopter with arduino+wmp+nunchuk parkjungho Electric Heli Talk 3 Jun 21, 2011 02:58 PM
Discussion Arduino project to build autopilot controlled RC plane! Ecibob Electric Plane Talk 2 Apr 25, 2011 10:17 AM