Adaptador para el mando del volante Renault Megane 1 fase 2

Adaptador de mandos de radio al volante para Renault.

En este proyecto, voy a intentar explicar de una forma didáctica, cómo adaptar el mando del volante del Renault Megane del 99 o similar (otros como el Clio de la época o Scenic tenían el mismo).

El fin es aprovechar el mando que trae de serie el vehículo, para que funcione con cualquier radio pioneer actual con conector W/R.

Veremos el desarrollo del proyecto de principio a fin, diseñando una placa a medida para controlar la radio, diseñada en KICAD.

Los archivos, en un principio, los proporcionaré a las personas que estén interesadas en montar este proyecto, a través de email. Tanto el código fuente de Arduino, como los archivos de KiCAD para montar la placa.

Se pueden encontrar por internet varios tutoriales para realizar esta tarea de diversas formas. Una de las que me gustó fue usando un microcontrolador "PIC", el titular del artículo colgó un archivo para subir al pic, y publicó el esquema del circuito, pero no fue más allá en la forma de programarlo. Aquí el link.

Para mí el PIC es totalmente desconocido. En su día se me enseñó Arduino, en el Ciclo Superior de Mantenimiento Electrónico (un gran abrazo a Paco y Severino y demás profesores y ex compañeros del Vicente Blasco Ibáñez de Valencia).

Arduino tiene muchas ventajas: es una plataforma libre, es muy flexible, es didáctico, económico, hay una gran comunidad dándole apoyo, y es fácil de programar.

PIC tendrá sus ventajas, pero lo poco que he mirado me ha provocado un poco de rechazo, ya que para programarlo, parece ser que es necesario hacerlo en un lenguaje de muy bajo nivel: Ensamblador.

MANDO Y RADIO...

La radio usada en este proyecto es una Pioneer.
Dispone de un conector trasero minijack con un conector W/R (wired remote).

Se podría usar una SONY o una KENWOOD, o similar con el mismo sistema de WR, pero no es la que tengo yo y no he podido realizar las pruebas pertinentes.

¿Cómo sabe la radio que estoy pulsando un botón y cual?

Valores estimados de resistencias para PIONEER. Fuente: http://jvde.net/node/7

La radio (según el modelo) aplica una tensión de 3,3V ó de 5V al conector minijack. Internamente, debe detectar la caída de voltaje al pasar por una u otra resistencia del interfaz que tenemos por crear, interpretando en ese caso una u otra función que debe ejecutar en el sistema de sonido.
En el caso que nos ocupa, no podemos usar las funciones de carpeta arriba/abajo, ya que el mando que se va a usar no tiene tantos botones para cubrir esas funciones. El resto sí que se va a usar.
Para cambiar de carpeta se usaría la parte del minijack "RING", junto con "SLEEVE" (masa). La punta del minijack (TIP), contendrá el resto de funciones.

Así visto, parece fácil. El problema del mando RENAULT, es el control giratorio, que es un pequeño codificador rotatorio, que es lo que va a complicar todo.

En otros vehículos (por si alguien intenta hacerlo para otra marca y está leyendo aquí), podría ser que los controles de pasar pista funcionen con botones, en lugar de la rueda, lo cual simplificaría todo.

Además tener en cuenta que el mando de Renault que estamos utilizando para el proyecto no tiene resistencias, otros mandos tienen resistencias SMD montadas en su mismo circuito. En tal caso, simplemente consiguiendo los valores adecuados, sustituyéndolas y poniendo un minijack correctamente soldado y conectado en la salida, se podría tener directamente el adaptador para la radio, sin necesidad de un interfaz como el que se va a montar. Pero esta información es muy general y habría que ver cada modelo en cuestión de forma más detallada.

Realizando primeras pruebas con el Arduino Mega. En particular la salida para el multiplexor.
Los 4 leds correspondían a los 3 bits de selección y la puerta "inh"

Para poder comenzar necesitaremos desconectar el mando del volante. En el megane classic del 99, se encuentra conectado al display del reloj y la temperatura, en la parte superior.
Yo me las vi negras para sacarlo sin desmontar medio salpicadero. Sobre todo porque al tirar del cable se sale el display de las pestañas que lo soportan, y luego para meterlo otra vez es complicado.
Finalmente con ello conseguido, se pueden empezar las primeras pruebas para entender el funcionamiento del mismo.

¿Cómo funciona el mando?

Mando con la carcasa abierta

En esta foto se ven claramente los 6 cables de colores que tiene el mando.

Ahora que tenemos una idea de cómo interpreta la radio las señales que se le dan por el mando, necesitamos saber cómo funciona éste.

Para complicarlo todo aún más, resulta que este mando tiene 6 cables, cuando uno piensa que se podría haber fabricado con 2 ó 3: un conector común, y luego según el que se pulse.
El funcionamiento aún así no es muy complicado.
Por ejemplo, pulsar el botón VOL+, es equivalente a hacer un cortocircuito entre el cable rojo y el cable azul.
Pulsar el botón MUTE, equivale a hacer un corto entre el cable negro y el azul.
ES DECIR, si cortáramos con una tijera el cable a la altura del mando y tuvieramos la radio original de Renault, y cruzáramos el cable negro con el azul, la radio pasaría a MUTE, como si pulsáramos tal botón. (Creo que con eso ya queda claro). El resto de funciones están en la foto adjunta en el borrador que anoté.

Estos son los cables "comunes", son 3:

• NEGRO: junto con Azul, Amarillo y Verde: Controla los dos botones SRC de la parte superior del mando y el botón MUTE/ATT.
• ROJO: junto con Azul, Amarillo y Verde: VOL+, VOL- y el botón inferior del mando que originalmente se usa para cambiar el CD del cargador del maletero.
• MARRÓN junto con Azul, Amarillo y Verde: Controla pasar pista, y este es el que nos va a dar dolores de cabeza.tiene dos funciones con 3 combinaciones distintas, que en realidad son 6, ya que el Marrón está asignado a la rueda de cambio de pista, que puede girar en dos direcciones (2x3 = 6 combinaciones). Aquí es donde tendremos que pensar cómo el ARDUINO nos va a ayudar.

Mucho hay escrito por ahí del funcionamiento de los botones, pero no de la rueda.

Para tener las ideas más claras, abrí el mando y seguí las pistas con el tester, para averiguar cómo se iba comportando según iba girando la rueda hacia arriba y abajo.

Notas antes de abrir el mando, probando con el tester:

Faltaba sólo terminar de entender cómo actuaba la ruleta. Cada vez que se movía una posición cambiaba de conexión de color, rotando entre los colores amarillo, verde y azul.

Ya estaba claro que había digamos 3 cables "maestros": el negro, el rojo y el marrón.

Con el mando abierto, pude observar que la ruleta tiene dos contactos, que al girar va cambiando, siempre tocando uno de los dos contactos el correspondiente al cable marrón, y al ir girando iba tocando de forma alterna el verde, el amarillo y el azul. Entonces viendo cómo iba, ya podía establecer un patrón lógico para más tarde programar el arduino para que supiera según que cable había antes y cual toca al girar, si subir o bajar pistas.

Esquema de las conexiones de la ruleta del mando y posibles combinaciones que podría dar.

Con el funcionamiento del mando ya averiguado, se puede avanzar al siguiente paso.

Esquema del interfaz entre el mando y el microcontrolador Arduino.

El esquema está basado en su mayor parte en el realizado por Chón para el microcontrolador PIC, y publicado en http://www.clioclub.com.ar/forum/index.php?topic=92931.0 Modificado por mí para adaptar a un Arduino.

Esquema original de Chón, http://www.clioclub.com.ar/forum/index.php?topic=92931.0

De igual forma que en el enlace antes mencionado, en mi versión, el corazón del circuito es un chip multiplexor analógico CD4051, para los entendidos en electrónica, es muy similar a un 74LS151. La diferencia es que este último es digital, por lo que permite sólo enviar señales de HIGH o LOW a través de su salida. OJO, EL 74LS151 debido a que es digital, NO SIRVE.

El CD4051 es un multiplexor analógico, por lo que digamos que nos permite abrir cualquiera de sus 8 puertas, dando como resultado de salida justo lo que hay detrás de las mismas. Es decir, si ponemos un tester midiendo ohmios tocando la salida con una pata y masa con la otra, y en la puerta 1 hay una resistencia de 1K, nos daría de lectura 1K.

Este chip dispone de una entrada de "Enable" para poner en marcha el chip. Para que sea así, debe estar conectada a masa (0V), en caso de recibir señal HIGH (+5V), el chip estaría inhabilitado. Además, para seleccionar una de las 8 entradas que se le puede conectar, tiene 3 entradas adicionales que serán gobernadas por el Arduino, y permitirá las 8 combinaciones posibles. A cada una de estas 8 se le asignará una función determinada.

Si no fuera posible de ninguna forma conseguir este chip, se puede realizar una serie de modificaciones y sustituir el CD4051 por transistores NPN (otra versión que he visto por ahí muy ingeniosa), usando la base como puerta gobernada por el arduino y cada resistencia conectada a cada colector. (emisor a masa).

¿Por qué hablamos de resistencias?

El conector W/R de estos stereos, mide la resistencia que tiene la entrada, y según sea, entiende que se le ordena una función específica.

¿Qué valores son los adecuados?

Los de la tabla adjunta al principio del artículo, serían muy aproximados. Podrían servir.

El primer interfaz que monté, llevaba un chip 4051, con sus resistencias y demás funcionando perfectamente.

Por una mala conexión, la persona a la cual se lo entregué, se le quemó el 4051 y se lo cambié por el mismo chip, pero de otro fabricante (TEXAS INSTRUMENTS, CD4051). El resultado es que la radio se comportaba de forma anormal, no realizando las funciones correctamente.

Resultó que cada chip introduce algo de resistencia adicional en las salidas, por lo que al cambiar de marca es posible que haya que reajustar los valores. Yo pondré aquí los que me han funcionado con las dos marcas que he usado. Por desgracia, del primero no recuerdo la marca, y cuando se quemó lo tiré a la basura.

Otra solución, es modificar el esquema del circuito e introducir resistencias variables para poder reajustarlas siempre. Además así podremos fabricar un interfaz multimarca, ya que entonces para que funcione con un Sony o Kenwood, es cuestión de ajustarlas girando el destornillador.

Esquema eléctrico del interfaz para Arduino / Pioneer:

ESQUEMA ELÉCTRICO DEL INTERFAZ, REALIZADO EN KICAD, http://kicad-pcb.org/
Los valores de las resistencias que están fuera de su cuadro son las finalmente usadas para un CD4051 de Texas Instruments.

Breve explicación del esquema eléctrico.

Intenté realizar el esquema dividido en módulos para mayor comprensión del mismo. Espero haber conseguido mi objetivo.

Regulador de tensión de entrada:

Arduino, como debería saber cualquiera que lo haya usado, se puede alimentar con una tensión entre 5 y 12V. Cuánto mayor sea dicha tensión, más se calentará, pues trabaja realmente a 5V y el excedente lo regula a menos.

Las baterías de los coches, trabajan con 12V. y tienen gran amperaje. 

Por ello, aunque Arduino soportaría, en teoría los 12V de la batería, decidí aprovechar un integrado LM317 que me sobró del ciclo sup. de electrónica para regular la tensión de entrada y dejarla a poco más de 5V, con el fin de alargar la vida del arduino. En el circuito de Chón, se puede ver un 78L05, más sencillo en realidad, ya que este simplemente da los 5V sin regulación necesaria. Cualquiera de los dos se podría usar.

Como se puede ver en el esquema, hay una entrada BATT IN, (+12V), que va hacia la pata IN del LM317. El resto del circuito regulador está calcado del datasheet del integrado LM317T. Luego simplemente con un tester entre masa y "VCC", regulamos el tornillo del potenciómetro RV1, para que nos de los 5V deseados. Le agregué un led con una resistencia en serie al mismo, para saber de forma visual si está recibiendo tensión.

A continuación, podemos ver el conector "ARDUINO POWER", que toma la salida del regulador para darle de comer al arduino. (Iría conectado al pin Vin del Arduino).

Ahora comentar otra modificación sobre el circuito de Chón: 

En el original alimentaba al CD4051 a través de la misma salida del regulador, lo que es posible, pero en los test que realicé ocasionaba ciertos problemas.

Resulta que cuando se pone en marcha la radio, ésta le proporciona los 12V al interfaz a través del cable que en teoría se conecta a la antena externa (para coches que tienen una antena que se despliega cuando se enciende la radio), así es como lo tengo yo conectado, para evitar que el arduino esté permanentemente encendido, incluso con la radio apagada.

Pues bien, el problema venía cuando le llegaba tensión al interfaz y se activaba, en esa fracción de segundo que el arduino arrancaba, se quedaba la salida del CD4051, digamos indeterminada. A mí me provocaba que la radio se volviera a apagar de inmediato. Por lo que al medir la salida del interfaz, resultó que en esa fracción de tiempo le estaba mandando al stereo una resistencia de 1K (SRC), lo que la pioneer, entiende como un "APAGATE". A un amigo que le hice otro interfaz, le ocurría lo mismo (con el chip que se frió), pero le daba señal de MUTE al arrancar. Menos problema, ya que le volvía a dar y funcionaba el sonido. Pero es que a mí al encender me apagaba y no podía usarla.👿

¿De qué manera solucionar este problema?

Ya que el CD4051, requiere menos de 1 microamperio (a 18V de tensión) según su datasheet, le podemos proporcionar los 5V a través de una de las salidas digitales del arduino (PIN 5 DEL CONECTOR "ARDUINO" DEL ESQUEMA), activándola una vez el arduino ha arrancado con un "digitalWrite(HIGH)" a la pata utilizada como alimentación, ya que mientras el Arduino se inicializa, sus entradas / salidas digitales permanecen sin tensión.

Si la intensidad requerida hubiera sido superior, podríamos haber hecho algo similar, pero en ese caso, conectaríamos la salida digital del arduino a la base de un transistor que gobernara la salida de tensión hacia el colector del mismo, para entregar un amperaje superior a través, por ejemplo de la batería del coche hacia su destino (teniendo en cuenta los valores máximos del transistor utilizado). O usando un relé con sus correspondientes diodos de protección...

Pata "inh" de habilitación del CD4051:

Para que el integrado funcione, primero hay que conectarle a masa (0V), la pata "inh" 

Como no queremos que esté permanentemente en marcha, ya que ello supone que estaría enviando una de las 8 salidas posibles a la radio, en cuanto el circuito recibe tensión de la batería, le llegarán los 5V del regulador, lo que hará que permanezca inhabilitado.

Para gobernar esta entrada, lo conectaremos a una salida digital del arduino, que cuando necesite enviar una orden a la radio, cambiará de estado a LOW (0V), lo que hará que funcione como una resistencia "pull-down", haciendo que los 5V del regulador se vayan hacia el arduino, dejando 0V en la pata "inh" del CD4051, y por lo tanto este estaría habilitado.

Vale, y ¿cuál es el problema?

Pues resulta que las salidas digitales del arduino, mientras este se inicializa (cuestión quizás de 1s o menos), permanecen en LOW, por lo que en dicha fracción el CD4051 estará habilitado enviando "alguna" orden a la pioneer.

¿Solución?

Usar una salida digital del Arduino para alimentar al CD4051, así tendremos una segunda pata de habilitación controlada por Arduino. Nos lo podemos permitir, porque requiere muy muy poca intensidad (amperaje) el CD4051.

Resumiendo, estos son los conectores de entrada y salida:

PCB del interfaz ya diseñado por KICAD. Tamaño: 80x60.
Se puede comprar una placa de 80x120 para montar dos.

Vista 3D de KICAD

Aquí se ve como encaja perfectamente el cable del mando con el arduino mini. (está protegido con funda termoretráctil).

Proyecto terminado con su fusible instalado, a falta de conectar en el coche.
En el de la foto aún no se había puesto el conector de alimentación directo del arduino al cd4051.

Conectores de entrada:

• Batería (tensión para motor antena externa de la radio  = PIN 2 = 12V  y PIN 1 =masa) 2 pines. Por seguridad, se conectó un fusible de 0,5 Amperios al positivo, para proteger la placa de sobretensiones o evitar que se produzca un desastre por un cortocircuito.
• Arduino: conector de 5 pines:
• 3 PINES son para elegir la función (2 al cubo = 8 combinaciones), 
• otro para gobernar la inhabilitación del CD4051. (Cuando la placa recibe tensión de la batería, por defecto permanecería inhabilitado, salvo en la fracción de tiempo que se activa el arduino, antes se explicó el por qué).
• Y otro para alimentar al CD4051 a través de una salida digital.

Conectores de salida:

• Conector W/R: Dos pines que salen a un cable con una clavija minijack para conectar a la pioneer.
• Conector +5V y GND para alimentar al Arduino.

Con esto y el arduino, ya tenemos el interfaz entre el mando del volante y la radio Pioneer.

Ahora viene lo mejor, programar el arduino para que gobierne todo como el anillo único (vivan los freak).

Nos queda fabricar la PCB, para ello, se usaron unas placas fotosensibles positivas y una insoladora casera, como no, controlada por arduino (subiré más adelante su fabricación).

Insoladora casera utilizada para fabricar la placa de este proyecto.

Programación del arduino.

Introducción:

Este artículo no va a entrar a explicar de forma básica los comandos usados en el lenguaje arduino, para ello ya está su foro, que es excelente, u otras fuentes.https://www.arduino.cc/ 

El fin que se persigue aquí es comprender como si fuera pseudocódigo lo que se le pide al microcontrolador (aun así, pegaré el código con los comentarios explicativos).

Por lo que para seguir, se deben tener unos conocimientos básicos de arduino y su entorno.

¿Cómo vamos a gestionar con el arduino el control del mando del volante?

Como se ha explicado antes, el mando es muy simple, para enviar una orden a la radio original, se cortocircuita uno de los cables comunes (negro, rojo o marrón), junto con otro de los restantes para realizar algo (subir vol, bajar vol, etc).

La técnica que voy a usar es asignar 3 pines para los comunes, en modo INPUT (entrada), y además en modo PULLUP, por lo que su valor por defecto va a ser HIGH (+5V), decidí hacerlo así, porque para que cambie de estado tendría que conectarse el pin a masa, lo cual es más fiable que al contrario, ya que los cables pueden coger interferencias o corrientes parasitarias que alteren la lectura.

Por contra, los pines que se van a asignar a los tres colores que dan las funciones (Azul, amarillo y verde), se van a inicializar en modo OUTPUT y por defecto en LOW (0V).

Aquí viene el truco:

Supongamos que se pulsa el botón VOL+, (ROJO + AZUL), sabremos que el ROJO ha cambiado a estado LOW, porque uno de los 3 cables posibles se ha pulsado, pero en realidad no sabemos si ha sido el azul, el amarillo o el verde. Así lo sabremos:

• Detectamos una señal LOW en el pin asignado al cable rojo.
• Recorremos los 3 posibles culpables uno a uno.
• ponemos el pin del cable amarillo en HIGH.
• Chequeamos el pin rojo, si ha cambiado a HIGH, (será que no)
• devolvemos el pin rojo a LOW.
• ponemos el pin del cable verde en HIGH.
• Chequeamos el pin rojo si ha cambiado a HIGH (tampoco)
• devolvemos pin verde a LOW.
• Ponemos pin azul en HIGH.
• Chequeamos si ha cambiado de estado el pin rojo (Bingo!)
• Enviamos orden de VOL+ al interfaz.

De esta forma a groso modo vamos chequeando los botones que se van pulsando.
Además se irá ejecutando un bucle mientras el botón siga pulsado, la radio no se enterará que está el arduino por medio.
A la hora de ejecutar la orden que hará que se haga una u otra función, el arduino manejará 3 pines de salida para controlar las 8 combinaciones posibles en las entradas del multiplexor, al mismo tiempo que irá habilitándolo a través del pin correspondiente.

El funcionamiento de la ruleta es similar al de los botones, pero con algo más de dificultad.

• Se inicializan las 3 variables que almacenarán el estado de la ruleta
• Posición actual.
• Posición próxima (subir pista).
• Posición anterior (bajar pista).
• En el loop del programa del arduino se va chequeando si la ruleta cambia de estado para enviar o no una orden a la radio.
• En caso por ejemplo de subir pista, se enviaría la orden correspondiente al multiplexor y se actualizarían las 3 variables que contienen las posiciones actuales y las de subida o bajada de pista. (ver foto con anotaciones para más detalle o el código en sí).

Poco más que añadir, a continuación pego el código fuente completo, y ante cualquier duda sobre algo no escrito o que no esté claro, podéis escribir e intentaré echar una mano.

Se agradecerá cualquier comentario que sea constructivo.

//Interfaz arduino - renault - pioneer (C) Josué Torrico. (Repalankas) 2017

// Se asignan los pines donde irán conectados los cables del mando renault
int pinNegro = 8;
int pinMarron = 10;
int pinRojo = 6;
int pinAzul = 11;            
int pinVerde =7;
int pinAmarillo = 9;

// asignamos variables para almacenar estado de los pines conectados a los cables del mando
int azul;
int verde;
int rojo;
int negro;
int amarillo;
// ruletaSiguiente almacenará la posición que subiría pista desde la posición actual, Anterior la anterior y la ruletaActual, almacenará
// el color del cable que está tocando en el momento actual el codificador rotatorio, junto con el marrón (el común que siempre toca).
int marron, ruletaSiguiente, ruletaAnterior, ruletaActual;
// pulsado almacenará el nº (color) del pin que corresponde al botón pulsado del mando.
// mantiene chequea si hemos soltado o no el botón pulsado. Por ejemplo,
// si se mantiene el botón src, la radio se apagará.
int pulsado,mantiene;
 
void setup() 
{
  //Se inicializan los pines conectados a los cables maestros del mando en modo pull up, es decir,
  //se mantienen en estado HIGH por defecto (mejora la fiabilidad de las señales en caso de ruido eléctrico)
  //se establecen como pines de entrada para leer la posible pulsación del azul, verde o amarillo,
  //que se usarán como pines de salida.
  pinMode(pinMarron, INPUT_PULLUP); // Por defecto los pins de entrada en HIGH (PULLUP)
  pinMode(pinNegro, INPUT_PULLUP);
  pinMode(pinRojo, INPUT_PULLUP);

  pinMode(pinAzul, OUTPUT);
  pinMode(pinVerde, OUTPUT);
  pinMode(pinAmarillo, OUTPUT);

//inicializamos pines a LOW.
  digitalWrite(pinAzul, LOW);
  digitalWrite(pinVerde, LOW);
  digitalWrite(pinAmarillo, LOW);

  pinMode(A0, OUTPUT); // ENTRADA S0 DEL MUX. LSB
  pinMode(A1, OUTPUT); // ENTRADA S1 DEL MUX.
  pinMode(A2, OUTPUT); // ENTRADA S2 DEL MUX. MSB
  pinMode(A3, OUTPUT); // ENTRADA ENABLE DEL MUX. EL TIEMPO QUE TARDA EN INICIALIZARSE EL ARDUINO..., 
                        //...EL A3 ESTÁ EN LOW, POR LO TANTO EL MUX ACTIVADO Y MANDANDO LA SEÑAL SRC- A LA RADIO. LO QUE OCASIONA QUE ESTA SE APAGUE.
  pinMode(A4, OUTPUT); // ALIMENTACION PARA EL 4051. Para subsanar el problema descrito en la línea anterior.
  
  digitalWrite(A3, HIGH); //INICIALIZA EL MUX EN DISABLE.
  digitalWrite(A4, HIGH); //ACTIVAMOS EL 4051, EL PIN A4 DEBE CONECTARSE A LA PATA 16 (VCC) DEL 4051.
//leemos el estado actual de la ruleta para que quede almacenado en la variable
  inicializaRuleta(); // se activa el procedimiento para saber cual es el pin actual, anterior y siguiente de la ruleta
  // y almacenar dicha información en las variables que se declararon para tal cometido.
}

void loop() 
{
 delay(250); //introducimos un retardo de 250 ms para resolver ciertos problemas de sincronismo con la ruleta.
            // aún así, en alguna ocasión puntual al avanzar pista retrocede o viceversa.
 rojo = digitalRead(pinRojo); //leemos el estado del pin rojo y pin negro
 negro = digitalRead(pinNegro); //más abajo leemos la ruleta
 
 if (negro == LOW) // se van leyendo los pines maestros para ver si cambian de estado..
  {               
    pulsado = compruebaPinPulsado(pinNegro);
    if (pulsado == pinAzul)
    {
      teclaMute();    // NEGRO + AZUL = MUTE  
    }
    else if (pulsado == pinVerde)
      {
        teclaSRCMas(); // NEGRO + VERDE = BOTON SRC+
      }
    else if (pulsado == pinAmarillo)
      {
       teclaSRCMenos();   // NEGRO + AMARILLO = BOTON SRC-
      }
    }
  else if (rojo == LOW)
   {
    pulsado = compruebaPinPulsado(pinRojo);
    if (pulsado == pinAzul)
      {
       teclaVolMas(); // ROJO + AZUL = BOTON VOL+
      }
     else if (pulsado == pinVerde)
      {
        teclaSalto();  // ROJO + VERDE = BOTON SALTO CD
      }
      else if (pulsado == pinAmarillo)
      {
       teclaVolMenos();   //ROJO + AMARILLO = BOTON VOL-
      }
    }
  compruebaRuleta();  //MIRAMOS SI LA RULETA HA CAMBIADO.
}

int compruebaPinPulsado(int pinBuscado)  //CAMBIAMOS ESTADO DE LOS 3 PINES ESCLAVOS
                                         //PARA COMPROBAR CUAL HA REALIZADO EL CAMBIO
                                         //EN EL MAESTRO.
{
  digitalWrite(pinAzul, HIGH);
  if (digitalRead(pinBuscado) == HIGH)
    {
      pulsado = pinAzul;
    }
  digitalWrite(pinAzul, LOW);
  digitalWrite(pinVerde, HIGH);
  if (digitalRead(pinBuscado) == HIGH)
    {
      pulsado = pinVerde;
    }

  digitalWrite(pinVerde, LOW);
  digitalWrite(pinAmarillo, HIGH);
  if (digitalRead(pinBuscado) == HIGH)
   {
    pulsado = pinAmarillo;
   }
   digitalWrite(pinAmarillo, LOW);
   return pulsado;
 }

void inicializaRuleta()  //LEEMOS EL ESTADO INICIAL DE LA RULETA AL ENCENDER LA RADIO.
                          //Y ESTABLECEMOS LOS COLORES QUE SERÁN LA SIGUIENTE O LA ANTERIOR PISTA (Y EL ACTUAL)
  {
    ruletaActual = compruebaPinPulsado(pinMarron);
    if (ruletaActual == pinVerde)
    {
    ruletaSiguiente = pinAzul;
    ruletaAnterior = pinAmarillo;
    }
    else if (ruletaActual == pinAzul)
    {
    ruletaSiguiente = pinAmarillo;
    ruletaAnterior = pinVerde;
    }
    else if (ruletaActual == pinAmarillo)
    {
    ruletaAnterior=pinAzul;
    ruletaSiguiente=pinVerde;
    }
  }

void activaMUX()  //HABILITA LA SALIDA DEL MULTIPLEXOR CD4051
{
  digitalWrite(A3,LOW);
  //delay(50);
}

void desactivaMUX() //DESHABILITA MUX 4051.
{
  digitalWrite(A3,HIGH);
}

void compruebaRuleta()
{
  marron = compruebaPinPulsado(pinMarron);
  if (marron != ruletaActual) //COMPROBAMOS SI HA CAMBIADO EL ESTADO DE LA RULETA (SI SE HA GIRADO)
  {
    delay(10);
    if (marron == ruletaSiguiente) //sube una pista Y REORDENAMOS VARIABLES
    {
       teclaRuletaMas();
       ruletaSiguiente = ruletaAnterior;
       ruletaAnterior = ruletaActual;
       ruletaActual = marron; 
    }
    else if (marron == ruletaAnterior) //baja una pista Y REORDENAMOS VARIABLES.
    {
       teclaRuletaMenos();
       ruletaAnterior = ruletaSiguiente;
       ruletaSiguiente = ruletaActual;
       ruletaActual = marron; 
    }
  }
}

// A PARTIR DE AQUÍ, ESTÁN LOS PROCEDIMIENTOS QUE HACEN QUE EL MUX 4051 ABRA UNA U OTRA PUERTA
// PARA QUE EL RECEPTOR PIONEER RECIBA LA ORDEN DESEADA.

void teclaSalto()
{
  digitalWrite(A0, HIGH);
  digitalWrite(A1, HIGH);
  digitalWrite(A2, HIGH);
  activaMUX();
  //Serial.println("PULSADO SALTO");
  do
  {
  mantiene = digitalRead(pinRojo);
  }
  while (mantiene == LOW);
  //Serial.println("SOLTADO SALTO");
  desactivaMUX();
}

void teclaMute()
{
  digitalWrite(A0, HIGH);
  digitalWrite(A1, LOW);
  digitalWrite(A2, HIGH);
  activaMUX();
  //Serial.println("PULSADO MUTE");
  do
  {
  mantiene = digitalRead(pinNegro);
  }
  while (mantiene == LOW);
  //Serial.println("SOLTADO MUTE");
  desactivaMUX();
}

void teclaRuletaMas() // RIGHT
{
  digitalWrite(A0, HIGH);
  digitalWrite(A1, HIGH);
  digitalWrite(A2, LOW);
  //Serial.println("Ruleta abajo");
  activaMUX();
  delay(250);
  desactivaMUX();
}

void teclaRuletaMenos() //LEFT
{
  digitalWrite(A0, LOW);
  digitalWrite(A1, LOW);
  digitalWrite(A2, HIGH);
  //Serial.println("Ruleta arriba");
  activaMUX();
  delay(250);
  desactivaMUX();
}

void teclaVolMas()
{
  digitalWrite(A0, LOW);
  digitalWrite(A1, HIGH);
  digitalWrite(A2, LOW);
  activaMUX();
  //Serial.println("PULSADO VOL + ");
  do
  { 
  mantiene = digitalRead(pinRojo);
  }
  while (mantiene == LOW );
   //Serial.println("SOLTADO VOL+");  
  desactivaMUX();
}

void teclaVolMenos()
{
  digitalWrite(A0, LOW);
  digitalWrite(A1, HIGH);
  digitalWrite(A2, HIGH);
  activaMUX();
  //Serial.println("PULSADO VOL - ");
  do
  {
  mantiene = digitalRead(pinRojo);
  }
  while (mantiene == LOW);
  //Serial.println("SOLTADO VOL - ");
  desactivaMUX();
}

void teclaSRCMenos() //SRC/ON/OFF
{
  digitalWrite(A0, LOW);
  digitalWrite(A1, LOW);
  digitalWrite(A2, LOW);
  activaMUX();
  //Serial.println("PULSADO SRC- ");
  do
  {
  mantiene = digitalRead(pinNegro);
  }
  while (mantiene == LOW);
  //Serial.println("SOLTADO SRC- ");
  desactivaMUX();
}

void teclaSRCMas() // band/esc
{
  digitalWrite(A0, HIGH);
  digitalWrite(A1, LOW);
  digitalWrite(A2, LOW);
  activaMUX();
  //Serial.println("PULSADO SRC+ ");
  do
  {
  mantiene = digitalRead(pinNegro);
  }
  while (mantiene == LOW);
  //Serial.println("SOLTADO SRC+ ");
  desactivaMUX();
}