Arduino.ru

Если значение целочисленное, то его можно передавать импульсами, например так:

Ардуино 1 устанавливает на выходе PIN3 низкий уровень сигнала. А сам выход PIN3 подключен к PIN3 на второй Ардуино, только там он не выход, а вход.
Ардуино 2 видит, что на PIN3 низкий уровень сигнала, понимает, что сейчас начнётся передача данных и разрешает работу внешних прерываний
Ардуино 1 меняет состояние на PIN4 (каждое изменение состояния это +единица к счётчику)
Ардуино 2 отлавливает по прерыванию изменение состояния на своём PIN4 и прибавляет к счётчику единицу
...
Так повторяется до тех пор, пока Ардуино 1 не передаст всю информацию. По окончании передачи Ардуино 1 устанавливает на выхоlе PIN3 высокий уровень и этим сообщает Ардуино 2, что передача окончена.
Ардуино 2 запрещает прерывания, смотрит, сколько насчитал счётчик и потом использует эти данные так, как вам нужно.

Вот таким образом можно передавать самую разнобразную информацию с одной Ардуино на другую Ардуино.

Но если этот, вне всякого сомнения, гениальный способ вам почему то не подойдёт, то можно сделать так - http://rfanat.ru/s19/ardu-sv2pl.html

===

Удивительно, но оказалось, что информации на русском о соединении двух ардуино по проводам очень мало.

если по вашему варианту, то нужен ЦАП на 21 резисторе по схеме матрицы R2R.... такой ЦАП задействует 10 пинов на выход.... тогда ардуина_1 будет выдавать через ЦАП значения ( в виде напряжения ) 0...1023

ардуина_2 аналоговым пином сможет принимать эти значения, но с ошибкой :(

кроме ошибки ещё одна проблема - СИНХРОНИЗАЦИЯ приёма передачи

 

:) прикольный способ :) посмотрите патенты ! может этот способ ещё не запатентован :)-

Целесообразнее посмотреть в сторону дельта-сигма модуляции (гугл выдаст массу информации). Для передачи сигнала достаточно 1 линии. Плюс линия для синхронизации. И никаких R2R огородов с десятью выходными пинами.

Вообще-то, вопрос в топике задан как-то странно - в шапке речь идет о передаче аналогового сигнала, в тексте - о передаче некоей переменной. Если аналоговый (периодический, непрерывный, длительный...) сигнал - то дельта-сигма, если отдельно взятая переменная - то стандартные процедуры ардуино. Кроме того, если речь идет-таки об аналоговым сигнале, желательно указать его динамический и частотный диапазоны. Это тоже сильно повлияет на выбор оптимального способа передачи. 

щас ( чуть позжее ) ТС прочитает - и офуеет!!!!!

не нано его грузить дельтасигмами ! пусть здеся освоится ллы начала !

serginusoid, попробуйте эти способы:

1. по сериалу

Передатчик:

#include <EasyTransfer.h> 
 
struct DATA_STRUCTURE{
  //структура данных
  //должно быть одинаково у передатчика и у приёмника
  //в т. ч. переменные в одинаковом порядке
  int blinks;
  int pause;
};
 
EasyTransfer ET;
DATA_STRUCTURE myData;
 
void setup(){
  Serial.begin(9600);
  ET.begin(details(myData), &Serial);
  randomSeed(analogRead(0));  
}
 
void loop(){
  //заполняем структуру
  mydata.blinks = 5;
  mydata.pause = random(5);
  //посылаем
  ET.sendData();
  delay(5000);
}

Приёмник:

#include <EasyTransfer.h>
  
struct DATA_STRUCTURE{
  //структура данных
  int blinks;
  int pause;
};
 
EasyTransfer ET;
DATA_STRUCTURE myData;
 
void setup(){
  pinMode(13, OUTPUT); 
  Serial.begin(9600);
  ET.begin(details(myData), &Serial);
}
 
void loop(){
  //принято, мигаем
  if(ET.receiveData()){
    for(int i = 0; i < mydata.blinks; i++) {
      digitalWrite(13, HIGH);
      delay(mydata.pause * 100);
      digitalWrite(13, LOW);
      delay(mydata.pause * 100);
    }
  }
}

2. по iic

(резисторы по 4.7k)

Передатчик:

#include <Wire.h>
#include <EasyTransferI2C.h>

struct SEND_DATA_STRUCTURE{
  //структура данных для передачи
  int blinks;
  int pause;
};

SEND_DATA_STRUCTURE mydata;
EasyTransferI2C ET; 

//адрес i2c ведомого
#define I2C_SLAVE_ADDRESS 1

void setup(){
  Wire.begin();
  ET.begin(details(mydata), &Wire);  
  randomSeed(analogRead(0));  
}

void loop(){
  //заполняем структуру
  mydata.blinks = 5;
  mydata.pause = random(5);
  //посылаем
  ET.sendData(I2C_SLAVE_ADDRESS);  
  delay(5000);
}

Приёмник:

#include <Wire.h>
#include <EasyTransferI2C.h>

struct RECEIVE_DATA_STRUCTURE{
  //структура данных
  int blinks;
  int pause;
};

EasyTransferI2C ET; 
RECEIVE_DATA_STRUCTURE mydata;

#define I2C_SLAVE_ADDRESS 1
boolean receiveComplete = false; //флаг, true по факту приёма

void setup(){
  pinMode(13, OUTPUT); 
  Wire.begin(I2C_SLAVE_ADDRESS);
  ET.begin(details(mydata), &Wire);
  Wire.onReceive(receive);  
}

void loop(){
  if (receiveComplete == true){
    //пришла инфа, мигаем
    for(int i = 0; i < mydata.blinks; i++) {
      digitalWrite(13, HIGH);
      delay(mydata.pause * 100);
      digitalWrite(13, LOW);
      delay(mydata.pause * 100);
    }
    receiveComplete = false; //снимаем флаг
  }       
}

// приёмная функция
void receive(int numBytes){    
  //проверяем приход инфы, ставим флаг
  if(ET.receiveData()) {
    receiveComplete = true; 
  }
}

Архив с либой: https://github.com/madsci1016/Arduino-EasyTransfer

И снова здраствуйте, почти месяц прошел, а я все еще топчусь на том же месте.)) Попытался попробовать все вышеозвученные способы (кроме модуляции, т.к. вообще не в теме). Вообщем все не получалось кроме последнего примера по сериалу(который предложил(а) std) но и с ним не все хорошо. Собственно, с ним я и пытаюсь сейчас работать. Суть в чем: сам пример работает замечательно, но я его немного изменил(в коде Приемника):

#include <EasyTransfer.h>
#include <Servo.h> 

Servo myservo;

struct DATA_STRUCTURE{
  //структура данных
  int blinks;
  int pause;

};

EasyTransfer ET;

DATA_STRUCTURE myData;

void setup(){
  pinMode(13, OUTPUT);
  myservo.attach(8);
  myservo.write(0);
  
  Serial.begin(9600);
  ET.begin(details(myData), &Serial);
}

void loop(){
  //принято, мигаем
  if(ET.receiveData()){
    myservo.write(myData.pause*10);
    for(int i = 0; i < myData.blinks; i++) {
      digitalWrite(13, HIGH);
      delay(myData.pause * 100);
      digitalWrite(13, LOW);
      delay(myData.pause * 100);
    }
  }
}

 Итак, надеюсь, идея понятна. Hо при подсоединении к платке Приемника  сервопривода, он(серв), работать не будет потому нет питания, поэтому было логично, по крайней мере для меня питание подключить. И тут начались проблеммы - платка Приемника подключалась через USB порт в результате чего все просто переставало работать(как я думаю, это связано с внутренней логикой контроллера), а в Serial Monitor (Передатчика) вместо нормальных значений появляется абаркадабра какая-то(в коде Передатчика я вставил в loop метод Serial.println(myData.pause) чтобы отслеживать правильность значений). Собственно в чем может быть проблемма?

После вызова метода ET.begin() вывод информации в Serial monitor невозможен. Сериал не может одновременно пропускать через себя и отладочную информацию, и трафик EasyTransfer.

Как вариант, можно передавать по i2c. Приём по этой шине должен работать. Пробовался ли этот вариант?

Кстати, существует реализация через программный сериал, называется SoftEasyTransfer. И кстати, скорее всего всё вышеперечисленное вряд-ли нужно. Читайте пример EasyTransfer_2Way_wServo_Example.

Получается, я не могу подключить сериал к связке из двух ардуин? Если так, то как это можно обойти, если это вообще возможно?

Давайте представим сериал как 2 трубы в одну кричишь из другой слушаешь. Пока у вас 2 человека они могут орать и говорить одновременно. Полный дуплекс. А если 3 и все говорят одновременно, то получается фигня и никто не слышит никого.

Попробуйте 

A New Software Serial Library for Arduino

Делает ещё один Serial port на двух цифровых выходах

подскажите пожалуйста как сделать код под мои нужды: 

 

у меня есть плата в которой спаяны и ардуино и мотор шилд. 

на ней нехватает свободных пинов, для этих целей я хочу управлять ею с другой платы через UART 

вот то что я хочу получить в картинках: 

оно же в расширеной версии. 

 

 

у меня колесный робот. на котором 2 канала моторов. и нужно управлять кучей серво приводов и нагрузок. на камеру и эхолот внимания не обращайте... это так, может быть в будущем. 

все перерыл немогу найти приеру где бы через EasyTransfer или еще как то я мог управлять моторами и сервами одной ардуины через другую с геймпада по блютус, о как :)

 

на данный момент все управление идет через телефон по блютусу, на тирекс контролер

// Скетч для управления через блютус, Wild Thumper 6WD, на ардуино совместимом контролере TREX controller. реализовано движение и стрельба с водомета, захват клешней манипулятором. 
// по вопросам и предложениям писать на почту slom1@list.ru 
// новые фото и видео можно найти на www.шоуальянс.com

#include <BTCA2ALite.h>// Добавляем библиотеку блютус программы
#include <Servo.h> // Добавляем библиотеку серво

Servo myservoH; // Горизонтальная серва углы от 0 до 180 (центровка 89)
Servo myservoV; // Вертикальная серва углы от 1 до 45
Servo myservoZ; // серва Клешня
Servo myservoR; // серва рука клешни
const int Z_SERVO_PIN = 5; // добовляем пин захвата
const int R_SERVO_PIN = 6; // добовляем пин руки манипулятора
const int H_SERVO_PIN = 7; // Горизонтальная серва подключена к пину 7
const int V_SERVO_PIN = 8; //Пин вертикального сервопривода 8
const float Z_L_ANGLE = 116; // Максимальные угл поворота башни налево
const float Z_R_ANGLE = 45; // Максимальные угл поворота башни направо
const float Z_DEF_ANGLE = 50; // Дефолтный угол (центровка)
const float R_L_ANGLE = 178; // Максимальные угл поднятия руки
const float R_R_ANGLE = 3; // Максимальные угл наклона руки
const float R_DEF_ANGLE = 160; // Дефолтный угол руки
const float H_L_ANGLE = 180; // Максимальные угл поворота башни налево
const float H_R_ANGLE = 0; // Максимальные угл поворота башни направо
const float H_DEF_ANGLE = 84; // Дефолтный угол (центровка)
const float V_U_ANGLE = 140; // Максимальные угл поворота башни вверх
const float V_D_ANGLE = 45; // Максимальные угл поворота башни вниз
const float V_DEF_ANGLE = 60; // Дефолтный угол (центровка)
//Размер шага V_STEP и H_STEP побираем экспериментально для достижения нужной скорости поворота серв
const float V_STEP = 0.012; // Шаг - знаение отвечающее за скорость вращения по вертикали.
const float H_STEP = 0.012; // Шаг - знаение отвечающее за скорость вращения по горизонтали
const float Z_STEP = 0.012; // шаг захвата
const float R_STEP = 0.012; // шаг руки
float curVAngle = V_DEF_ANGLE; //Переменная текущего угла верт. сервы
float curHAngle = H_DEF_ANGLE; //Переменная текущего угла гор. сервы
float curZAngle = Z_DEF_ANGLE; //
float curRAngle = R_DEF_ANGLE; //
bool moveServoVUp = false; //Флаг движения верт. сервы вверх
bool moveServoVDown = false; //Флаг движения верт. сервы вниз
bool moveServoHLeft = false; //Флаг движения гор. сервы влево
bool moveServoHRight = false; //Флаг движения гор. сервы вправо
bool moveServoZLeft = false; //Флаг движения гор. сервы влево
bool moveServoZRight = false; //Флаг движения гор. сервы вправо
bool moveServoRLeft = false; //Флаг движения гор. сервы влево
bool moveServoRRight = false; //Флаг движения гор. сервы вправо

btca2aLite btca2aLite; // Конструктор btca2aLite


// задаем пины для левого мотора
#define Dir_L 2
#define Pwm_L 3
#define Brake_L 4
// задаем пины для правого мотора
#define Dir_R 10
#define Pwm_R 11
#define Brake_R 9

// Задаем скорости для движения
byte MaxSpeed = 230; // Максимальная скорость
byte MinSpeed = 90;  // Минимальная скорость

int forw_back = 0;
int righ_left = 0;

byte step_fb = 5;     // Шаг изменения скорости движения вперед - назад
byte step_stop = 10;  // Шаг изменения скорости остановки
byte step_rl =  10;    // Шаг изменения скорости движения вправо - влево
byte step_dir = 10;   // Шаг изменения скорости выравнивания



#define SHOT  12 // пин для водомета

enum States
{
    WAITING,
    READING,
    RUNNING,
    ERROR,
    TIMEOUT
};

States state;
States onWait();
States onRead();
States onRun();
States onError();

States onTimeout();

void performServo(); // добовляем сервы


void setup(){
    Serial.begin(9600); // Скорость BT и порта должна быть 9600
    //Моторы
    pinMode (Pwm_L, OUTPUT);
    pinMode (Dir_L, OUTPUT);
    pinMode (Brake_L, OUTPUT);
    
    pinMode (Pwm_R, OUTPUT);
    pinMode (Dir_R, OUTPUT);
    pinMode (Brake_R, OUTPUT);
    
    digitalWrite (Pwm_L, LOW);
    digitalWrite (Pwm_R, LOW);
    
    digitalWrite (Brake_L, LOW);
    digitalWrite (Brake_R, LOW);
  
 pinMode(SHOT, OUTPUT); // задаем выход для стрельбы водой
    
    // устанавливаем пин как вывод управления сервой
    myservoH.attach(H_SERVO_PIN);
    myservoV.attach(V_SERVO_PIN);
    myservoZ.attach(Z_SERVO_PIN);
    myservoR.attach(R_SERVO_PIN);
    myservoH.write(curHAngle);
    myservoV.write(curVAngle);
    myservoZ.write(curZAngle);
    myservoR.write(curRAngle);
    
    //Светодиод
    pinMode(13, OUTPUT); // Инициализируем пин светодиода
    digitalWrite(13, HIGH); // Светодиод выключен
}

void loop(){
    
    btca2aLite.ReadCommand(); // Считывание принятых команд (кодов кнопок)
    //Вызываем функцию управление сервами
    performServo();
    
 //этот код для меня темный лес, мне его дали для плавного старта и торможения моторов. если ехать вперед и резко нажать кнопку назад, машина продолжит ехать вперед, плавно остановиться и только потом поедет назад, это спасает редуктора от разрушения. 
 //если ктото знает что тут к чему, прокоментируйте пожалуйста, чтоб я тоже понимал :)
  static unsigned long pre_millis = 0;
  if(millis()-pre_millis > 50)
  {
    pre_millis = millis();
    
    if(btca2aLite.ButtonPressed(KEYCODE_DPAD_UP)) 
    {
      forw_back += step_fb;
      if(forw_back > 0 && forw_back < MinSpeed) forw_back = MinSpeed;
    }
    else if(btca2aLite.ButtonPressed(KEYCODE_DPAD_DOWN)) 
    {
      forw_back -= step_fb;
      if(forw_back < 0 && forw_back > MinSpeed*-1) forw_back = MinSpeed*-1;
    }
    else 
    {
      if(forw_back < 0) forw_back += step_stop;
      else if(forw_back > 0) forw_back -= step_stop;
      if(abs(forw_back) < MinSpeed) forw_back = 0;
    }
    forw_back = constrain(forw_back, MaxSpeed*-1, MaxSpeed);


    if(btca2aLite.ButtonPressed(KEYCODE_DPAD_RIGHT)) 
    {
      righ_left += step_rl;
      if(righ_left > 0 && righ_left < MinSpeed) righ_left = MinSpeed;
    }
    else if(btca2aLite.ButtonPressed(KEYCODE_DPAD_LEFT)) 
    {
      righ_left -= step_rl;
      if(righ_left < 0 && righ_left > MinSpeed*-1) righ_left = MinSpeed*-1;
    }
    else 
    {
      if(righ_left < 0) righ_left += step_dir;
      else if(righ_left > 0) righ_left -= step_dir;
      if(abs(righ_left) < MinSpeed) righ_left = 0;
    }
    righ_left = constrain(righ_left, MaxSpeed*-1, MaxSpeed);


    int pwm_l = forw_back + righ_left;
    int pwm_r = forw_back - righ_left;
    pwm_l = constrain(pwm_l, MaxSpeed*-1, MaxSpeed);
    pwm_r = constrain(pwm_r, MaxSpeed*-1, MaxSpeed);

    digitalWrite(Dir_L, (pwm_l<0)?0:1);
    digitalWrite(Dir_R, (pwm_r<0)?0:1);
    analogWrite(Pwm_L, abs(pwm_l));
    analogWrite(Pwm_R, abs(pwm_r));
  }
        
  //дальше идут кнопки управления
    
    //-------— включение насоса —-------------
   if (btca2aLite.ButtonPressed(KEYCODE_BUTTON_SELECT))
    { 
     digitalWrite (SHOT, HIGH);
     }
    //-------— выключение насоса происходит автоматически после отпускания кнопки—------------- 
   if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_SELECT))
    {
   digitalWrite (SHOT, LOW);
    } 
    
        if(btca2aLite.Button(KEYCODE_BUTTON_START)) // алгоритм автоматического хватания предметов
    {
       
 /* шаг вперед, отключил....
      digitalWrite (Dir_L, HIGH); 
      analogWrite (Pwm_L, 150); 
      digitalWrite (Dir_R, HIGH); 
      analogWrite (Pwm_R, 150); 
      delay (100);
      // потом стоп
      analogWrite (Pwm_L, 0); 
      analogWrite (Pwm_R, 0); 
      delay (500);
 */
      
       myservoZ.write(45);; // Клешня разжимается 
        myservoR.write(3);; // рука клешни опускаем 
        delay(2000); /* ждем 2 секунды, */
         myservoZ.write(116);; // Клешня сжимаем
         delay(1000); /* ждем 1 секунду, */
          myservoR.write(170);; // рука клешни поднимаем
           delay(1000); /* ждем  */
           myservoZ.write(45);; // Клешня разжимаем
    } 
    
    
    //--------— Повороты серв при нажатии кнопок —-------------
    
    if(btca2aLite.Button(KEYCODE_BUTTON_X)) // поворот водомета вниз
    {
        moveServoVDown = true;
              
    }
    if(btca2aLite.Button(KEYCODE_BUTTON_A)) // поворот водомета направо
    {
        moveServoHRight = true;
    }
    if(btca2aLite.Button(KEYCODE_BUTTON_B)) // поворот водомета вверх
    {
        moveServoVUp = true;
              
    }
    
    if(btca2aLite.Button(KEYCODE_BUTTON_Y)) // поворот водомета налево
    {
        moveServoHLeft = true;
    }
    
        if(btca2aLite.Button(KEYCODE_BUTTON_R1)) // зхахват сжать
    {
        moveServoZLeft = true;
    }
    if(btca2aLite.Button(KEYCODE_BUTTON_R2)) // захват разжать 
    {
        moveServoZRight = true;
    }
    
    
           if(btca2aLite.Button(KEYCODE_BUTTON_L1)) // рука клешни вниз
    {
        moveServoRLeft = true;
    }
    if(btca2aLite.Button(KEYCODE_BUTTON_L2)) // рука клешни вверх
    {
        moveServoRRight = true;
    } 
    
    
//--------— чтобы сервы не продолжали движения при отжатых кнопках —-------------    
if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_X))
{
moveServoVDown = false;
}
if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_B))
{
moveServoVUp = false;
}

if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_A))
{
moveServoHRight = false;
}
if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_Y))
{
moveServoHLeft = false;
}
 
 if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_R2))
{
moveServoZRight = false;
}
if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_R1))
{
moveServoZLeft = false;
}   
    
 if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_L2))
{
moveServoRRight = false;
}
if(btca2aLite.ButtonReleased(KEYCODE_BUTTON_L1))
{
moveServoRLeft = false;
}       
    
    
    //----------------— Стоп —---------------------
    
    // Если не нажата ни одна кнопка курсора происходит остановка, скорость 0 для каждого мотора
    if (btca2aLite.ButtonReleased(KEYCODE_DPAD_UP) && btca2aLite.ButtonReleased(KEYCODE_DPAD_DOWN) && btca2aLite.ButtonReleased(KEYCODE_DPAD_LEFT) && btca2aLite.ButtonReleased(KEYCODE_DPAD_RIGHT)){
        analogWrite (Pwm_L, 0);
        analogWrite (Pwm_R, 0);
    }
}



//Функция управления сервоприводами (вызывается в теле loop на каждой итерации)
//Выполняет изменения положения серв на подобранный шаг согласно установленным флагам движения
//Флаги устанавливаются согласно поступившим символам управления сервами
void performServo()
{
    //Установлен флаг движения вверх и текущий угол не максимальный
    if (moveServoVUp && curVAngle + V_STEP <= V_U_ANGLE)
    {
        //К текущему верт. углу прибавляем шаг
        curVAngle += V_STEP;
    }
    //Установлен флаг движения вниз и текущий угол не минимален
    else if (moveServoVDown && curVAngle - V_STEP >= V_D_ANGLE)
    {
        //От текущего верт. угла отнимаем шаг
        curVAngle -= V_STEP;
    }
    //Установлен флаг движения влево и текущий угол не максимален
    if (moveServoHLeft && curHAngle + H_STEP <= H_L_ANGLE)
    {
        //К текущему гор. углу прибавляем гор. шаг
        curHAngle += H_STEP;
    }
    //Установлен флаг движения вправо и текущий угол не минимален
    else if (moveServoHRight && curHAngle - H_STEP >= H_R_ANGLE)
    {
        //От текущего угла отнимаем гор. шаг
        curHAngle -= H_STEP;
    }
    
    //Установлен 
    if (moveServoZLeft && curZAngle + Z_STEP <= Z_L_ANGLE)
    {
        //К текущему гор. углу прибавляем гор. шаг
        curZAngle += Z_STEP;
    }
    //Установлен флаг движения вправо и текущий угол не минимален
    else if (moveServoZRight && curZAngle - Z_STEP >= Z_R_ANGLE)
    {
        //От текущего угла отнимаем гор. шаг
        curZAngle -= Z_STEP;
    }
    
    
        //Установлен 
    if (moveServoRLeft && curRAngle + R_STEP <= R_L_ANGLE)
    {
        //К текущему гор. углу прибавляем гор. шаг
        curRAngle += R_STEP;
    }
    //Установлен флаг движения вправо и текущий угол не минимален
    else if (moveServoRRight && curRAngle - R_STEP >= R_R_ANGLE)
    {
        //От текущего угла отнимаем гор. шаг
        curRAngle -= R_STEP;
    }
    
    //Если было движние по вертикали
    if (moveServoVUp || moveServoVDown)
    {
        myservoV.write(curVAngle);
    }
    //Если было движение по горизонтали
    if (moveServoHLeft || moveServoHRight)
    {
        myservoH.write(curHAngle);
    }
    
    if (moveServoZLeft || moveServoZRight)
    {
        myservoZ.write(curZAngle);
    }
    
        if (moveServoRLeft || moveServoRRight)
    {
        myservoR.write(curRAngle);
    }
}

 

в качестве теста, на другой плате использаван вот такой код, управляется с джойсткика 2 сервы: 

#include <PS2X_lib.h>  //for v1.6
#include <Servo.h>
PS2X ps2x;
int PS2 = 0; 
Servo LXservo;
Servo LYservo;
#define L_dir 2   //пины для драйвера мотора
#define L_pwm 3
#define R_dir 4
#define R_pwm 5

int mass[4];      //здесь будем хранить значения для скоростей и направлений
                  //mass[0]   лев.напр.
                  //mass[1]   лев.скор.
                  //mass[2]   прав.напр.
                  //mass[3]   прав.скор.
                 
void setup(){
  LXservo.attach(8);
  LYservo.attach(6);
  
  PS2 = ps2x.config_gamepad(13,11,10,12, true, true);   //Настройка выводов: (clock, command, attention, data, true, true)
  pinMode(L_dir, OUTPUT);
  pinMode(L_pwm, OUTPUT);
  pinMode(R_dir, OUTPUT);
  pinMode(R_pwm, OUTPUT);
}

void loop(){
  LXservo.write(map(ps2x.Analog(PSS_LX), 255, 0, 0, 180)); ; 
 delay(50); 
  ps2x.read_gamepad(false, 0);
  
  LYservo.write(map(ps2x.Analog(PSS_LY), 0, 255, 0, 90)); ; 
 delay(50); 
  ps2x.read_gamepad(false, 0);
  
  
    dir_pwm(ps2x.Analog(PSS_RY),2);   //обрабатываем правый джойстик
  digitalWrite(R_dir, mass[2]);
  analogWrite(R_pwm, mass[3]);
}    

void dir_pwm(int Y, int n){         //Подпрограмма для обработки значений джойстика
  if (Y == 128){
    mass[n+1] = 0;
  }
  if (Y >128){
    mass[n+1] = Y*2-255;
    mass[n] = 1;
  }
  if (Y <128){
    mass[n+1] = 255-Y*2;
    mass[n] = 0;
  }
}

код нашел в одной из здешних тем.  

Если железки подключены к интренету (можно по ЮСБ), то это можно сделать с помощью проекта Blynk. Пример скетча. Геттинг стартет.