Tres en raya

Después de más de un año sin publicar vuelvo a la carga con un montaje para jugar al tres en raya con arduino. Para ello usaré una pantalla LCD y un joystick. El esquema es el siguiente:

En él hemos usado una pantalla Nokia LCD 5110, un módulo joystick, 6 resistencias de 560 Ω y 6 de 1KΩ. Las resistencias bajan el voltaje de 5V a 3.3V, que es el que usa el módulo LCD. Las conexiones del módulo LCD, que no se aprecian en el esquema son las siguientes:

• Cables rojos. Pines VCC y Led
• Cable amarillo. Pin RST
• Cable verde. Pin D/C
• Cable azul. Pin DN(MOSI)
• Cable naranja. Pin SCLK
• Cables negros. Pines GND y SCE

El joystick tiene los siguientes pines:

• GND. Conectado a tierra
• SW. Nombrado como SEL en el esquema. Es un pin digital. Detecta cuándo se ha pulsado el botón del joystick. En el que he usado devuelve LOW cuando se pulsa y HIGH en posición normal.
• VRx. Nombrado como Xout en el esquema. Es un pin analógico que devuelve un valor entre 0 y 1023 dependiendo de la posición del eje X del joystick.
• VRy. Nombrado Yout en el esquema. Es un pin analógico que devuelve un valor entre 0 y 1023 dependiendo de la posición del eje Y del joystick.
• +5V. Nombrado Vcc en el esquema. Es la alimentación del joystick.

El funcionamiento es muy sencillo. Con el joystick moveremos un cursor por la pantalla LCD y al pulsar el botón del joystick pondremos nuestra ficha en la casilla seleccionada. Inmediatamente el microcontrolador hará su jugada y nos devolverá el control para la siguiente.

Aquí está montado en la placa de prototipo:

Y el montaje en funcionamiento:

El código fuente del sketch se divide en dos ficheros:

• types.h. Este fichero es necesario porque el compilador de arduino obliga a que los tipos de datos definidos por el usuario y las funciones que tienen como valor de retorno alguno de estos tipos estén en un fichero separado del principal.

enum cellState{empty,black,white}; //Estados de cada casilla del juego

struct boardGame{
  byte xCursor; //Coordenada x del cursor  byte yCursor; //Coordenada y del cursor
  cellState board[3][3]{{empty,empty,empty},{empty,empty,empty},{empty,empty,empty}}; //Tablero de juego
  byte emptyCells=9; //Numero de casillas sin fichas
  bool stopPlay=false; //Parar el juego
};


/*****************************************************************************/
/* Funcion winner. Devuelve el color de la jugada ganadora en el  */
/* estado actual del juego. Empty si nadie gana                             */
/*                                                                                                    */
/* Parametros:                                                                                */
/* boardGame b-->Tablero de juego                                                */
/*****************************************************************************/

cellState winner(boardGame b){
 
  for(byte i=0;i<3;++i){
    for(byte j=0;j<3;++j){
      if(b.board[i][j]!=empty){
       
        //horizontal
        bool tmpWin=true;
        for(byte x=1;x<3;++x){
          tmpWin=tmpWin && (b.board[x][j]==b.board[x-1][j]);
        }
        if(tmpWin){
          return b.board[i][j];
        }
        //vertical
       
        if(!tmpWin){
          tmpWin=true;
          for(byte y=1;y<3;++y){
            tmpWin=tmpWin && (b.board[i][y]==b.board[i][y-1]);
          }
        }
       
        if(tmpWin){
          return b.board[i][j];
        }
        //diagonalVID_20151226_131816
       
        if(!tmpWin && i==0 && j==0){
          tmpWin=true;
           for(byte x=1,y=1;x<3 && y<3;++x,++y){
             tmpWin=tmpWin && (b.board[x][y]==b.board[x-1][y-1]);
          }
        }
        if(tmpWin){
          return b.board[i][j];
        }
       
        if(!tmpWin && i==0 && j==2){
          tmpWin=true;
            for(byte x=1,y=1;x>0 && y<3;++x,--y){
              tmpWin=tmpWin && (b.board[x][y]==b.board[x-1][y+1]);
             
            }
        }
        if(tmpWin){
          return b.board[i][j];
        }
       }
     }
    }
    return empty;
}

     

• 3EnRaya.ino

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>
#include "types.h"


//LCD

const byte SCLKpin = 13;
const byte DNpin = 11;
const byte DCpin = 12;
const byte RESETpin = 10;


//Joystick

const int xAxis=A1;
const int yAxis=A0;
const int button=2;

const char contrast=0;
int fontWidth=6;
int fontHeigth=10;
int textSize=2;

boardGame board;

Adafruit_PCD8544 lcd(SCLKpin,DNpin,DCpin,RESETpin);

/******************************************************************/
/* Funcion evaluatePlay. Devuelve el numero de jugadas ganadoras  */
/* si se juega una ficha en una casilla determinada               */
/*                                                                */
/* Parametros:                                                    */
/* boardGame b-->Tablero de juego                                 */
/* short x-->Coordenada x de la casilla que vamos a evaluar       */
/* short y-->Coordenada y de la casilla que vamos a evaluar       */
/* cellState c-->Color de la ficha con la que se pretende jugar   */
/******************************************************************/

short evaluatePlay(boardGame b,short x,short y,cellState c){
 
  short winCount=0;
  short cellCount=0;
  //Horizontal
  for(byte j=0;j<3;++j){
    if(b.board[x][j]==c || b.board[x][j]==empty){
      ++cellCount;
    }
  }
  if(cellCount==3){
    ++winCount;
  }
  cellCount=0;
  //Vertical
  for(byte i=0;i<3;++i){
    if(b.board[i][y]==c || b.board[i][y]==empty){
      ++cellCount;
    }
  }
  if(cellCount==3){
    ++winCount;
  }
  cellCount=0;
  // diagonal
  if(x==y){
    for(byte i=0,j=0;i<3 && j<3;++i,++j){
       if(b.board[i][j]==c || b.board[i][j]==empty){
         ++cellCount;
        }
     }
     if(cellCount==3){
       ++winCount;
     }
  }
  cellCount=0;
  if(x==y || abs(x-y)==2){
    for(byte i=0,j=0;i>0 && j<3;++i,--j){
       if(b.board[i][j]==c || b.board[i][j]==empty){
         ++cellCount;
       }
    }
    if(cellCount==3){
       ++winCount;
     }
  }
  return winCount;
}

/******************************************************************/
/* Funcion drawWinnerPlay. Dibuja una linea sobre la jugada       */
/* ganadora                                                       */
/*                                                                */
/* Parametros:                                                    */
/* boardGame b-->Tablero de juego                                 */
/******************************************************************/

void drawWinnerPlay(boardGame b){
 
  for(byte i=0;i<3;++i){
    for(byte j=0;j<3;++j){
      if(b.board[i][j]!=empty){
       
        //horizontal
        bool tmpWin=true;
        for(byte x=1;x<3;++x){
          tmpWin=tmpWin && (b.board[x][j]==b.board[x-1][j]);
        }
        if(tmpWin){
         
          lcd.drawLine(0, ((j+1)*16)-8, 84, ((j+1)*16)-8, BLACK);
        }
        //vertical
       
        if(!tmpWin){
          tmpWin=true;
          for(byte y=1;y<3;++y){
            tmpWin=tmpWin && (b.board[i][y]==b.board[i][y-1]);
          }
          if(tmpWin){
           
            lcd.drawLine(((i+1)*28)-14, 0, ((i+1)*28)-14, 84, BLACK);
          }
        }
       
       
        //diagonal
       
        if(!tmpWin && i==0 && j==0){
          tmpWin=true;
           for(byte x=1,y=1;x<3 && y<3;++x,++y){
             tmpWin=tmpWin && (b.board[x][y]==b.board[x-1][y-1]);
          }
          if(tmpWin){
           
            lcd.drawLine(0, 0, 84, 84, BLACK);
          }
        }
       
       
        if(!tmpWin && i==0 && j==2){
          tmpWin=true;
            for(byte x=1,y=1;x>0 && y<3;++x,--y){
              tmpWin=tmpWin && (b.board[x][y]==b.board[x-1][y+1]);
             
            }
           if(tmpWin){
            
              lcd.drawLine(0, 47, 84, 0, BLACK);
          }
        }
       
       }
     }
    }
}

/******************************************************************/
/* Funcion play. Ejecuta la jugada de la maquina                  */
/*                                                                */
/******************************************************************/

void play(){
  byte x;
  byte y;
  short maxEvaluation=-32768;
  short currentEvaluation=0;
  bool stopIteration=false;
  //Compruebo si alguna jugada me da la victoria
  for(byte i=1;i<4 && !stopIteration;++i){
    cellState *statesArray=board.board[i-1];
    for(byte j=1;j<4 && !stopIteration;++j){
     
      if(board.board[i-1][j-1]==empty){
       
        statesArray[j-1]=white;
        if(winner(board)==white){
         
          stopIteration=true;
          board.stopPlay=true;
        }
        else{
          statesArray[j-1]=empty;
        }
       }
      }
    }
    //Compruebo si alguna jugada da la victoria al oponente
    for(byte i=1;i<4 && !stopIteration;++i){
      cellState *statesArray=board.board[i-1];
      for(byte j=1;j<4 && !stopIteration;++j){
     
        if(board.board[i-1][j-1]==empty){
         
          statesArray[j-1]=black;
          if(winner(board)==black){
           
            statesArray[j-1]=white;
            stopIteration=true;
          }
          else{
            statesArray[j-1]=empty;
          }
         }
        }
      }
   
    if(!stopIteration){
      for(byte i=1;i<4;++i){
        for(byte j=1;j<4;++j){
          if(board.board[i-1][j-1]==empty){
           
            currentEvaluation=evaluatePlay(board,i-1,j-1,white);
           
            if(currentEvaluation>maxEvaluation){
              maxEvaluation=currentEvaluation;
              x=i;
              y=j;
            }
           }
          }
        }
       
        cellState *statesArray=board.board[x-1];
        statesArray[y-1]=white;
      }
     
  }

/******************************************************************/
/* Funcion drawTile. Dibuja una ficha en una posicion             */
/*                                                                */
/* Parametros:                                                    */
/* byte x-->Coordenada x de la casilla donde vamos a jugar        */
/* byte y-->Coordenada y de la casilla donde vamos a jugar        */
/* int color-->Color de la ficha con la que se pretende jugar     */
/******************************************************************/

void drawTile(byte x,byte y,int color){
  lcd.drawCircle((x*28)-14, (y*16)-8, 5,BLACK);
  if(color==BLACK){
    lcd.fillCircle((x*28)-14, (y*16)-8,5,color);
  }
}

/******************************************************************/
/* Funcion drawCross. Dibuja el cursor en una posicion            */
/*                                                                */
/* Parametros:                                                    */
/* byte x-->Coordenada x de la casilla donde vamos a jugar        */
/* byte y-->Coordenada y de la casilla donde vamos a jugar        */
/* int color-->Color de la ficha con la que se pretende jugar     */
/******************************************************************/

void drawCross(byte x,byte y,int color){
  lcd.drawFastVLine((x*28)-14,(y*16)-13, 10, color);
  lcd.drawFastHLine((x*28)-19, (y*16)-8, 10, color);
}

/******************************************************************/
/* Funcion drawGameScreen. Dibuja el tablero de juego             */
/*                                                                */
/******************************************************************/

void drawGameScreen(){
 
  lcd.drawRoundRect(0, 0, 84, 48,10,BLACK);
  lcd.drawLine(28, 0, 28, 84, BLACK);
  lcd.drawLine(56, 0, 56, 84, BLACK);
  lcd.drawLine(0, 16, 84, 16, BLACK);
  lcd.drawLine(0, 32, 84, 32, BLACK);
  lcd.drawLine(0, 32, 84, 32, BLACK);
 
  for(byte i=1;i<4;++i){
    cellState *statesArray=board.board[i-1];
    for(byte j=1;j<4;++j){
      if(statesArray[j-1]!=empty){
        drawTile(i,j,(statesArray[j-1]==black)?BLACK:WHITE);
      }
    }
   }
  
   cellState *statesArray=board.board[board.xCursor-1];
   drawCross(board.xCursor,board.yCursor,(statesArray[board.yCursor-1]==empty || statesArray[board.yCursor-1]==white)?BLACK:WHITE);
   drawWinnerPlay(board);
}



void setup(){            
  Serial.begin(115200) ;
 
  lcd.begin();
  lcd.clearDisplay();
  lcd.setTextColor(BLACK);
  lcd.setTextSize(textSize);
  board.xCursor=2;
  board.yCursor=2;
  drawGameScreen();
  lcd.display();
  pinMode(button,INPUT_PULLUP);
}

void loop(){ 
 
    if(!board.stopPlay){
      bool redrawScreen=false;
     
      if(analogRead(xAxis)==1023 && board.xCursor>1){
        //Se ha movido el joystick a la izquierda 
        board.xCursor--;
        redrawScreen=true;
      }
     else if(analogRead(xAxis)==0 && board.xCursor<3){
       //Se ha movido el joystick a la derecha
       board.xCursor++;
       redrawScreen=true;
     
     }
     else if(analogRead(yAxis)==1023 && board.yCursor<3){
       //Se ha movido el joystick hacia arriba
      board.yCursor++;
      redrawScreen=true;
     }
     else if(analogRead(yAxis)==0 && board.yCursor>1){
       //Se ha movido el joystick hacia abajo
      board.yCursor--;
      redrawScreen=true;
     }
     else if(!digitalRead(button)){
       //Se ha pulsado el boton
       cellState *statesArray=board.board[board.xCursor-1];
       if(statesArray[board.yCursor-1]==empty){
         statesArray[board.yCursor-1]=black;
         board.emptyCells--;
         if(board.emptyCells>0){
           play();
         }
         else{
           board.stopPlay=true;
         }
         redrawScreen=true;
       }
     }
  
     if(redrawScreen){
       lcd.clearDisplay();
        drawGameScreen();
        lcd.display();
        delay(500);
     
     }
    }
   
  }

     

Detectando intrusos

Hace unos días que me ha llegado la última remesa de juguetes para cacharrear con Arduino. Entre ellos hay un sensor de movimiento que ya hace tiempo que me apetecía probar. Es un sensor PIR que son las siglas de Passive Infrared, o lo que es lo mismo un detector de infrarrojos. El dispositivo detecta las variaciones de luz infrarroja y altera el voltaje del pin de salida cuando se produce. El resultado es que podemos detectar la presencia humana, o de cualquier ser vivo, ya que la radiación infrarroja no es más que calor. Al pasar por delante del sensor alteramos la radiación infrarroja detectada y salta la alarma. Vamos a empezar con un montaje básico para irlo complicando en sucesivas entradas hasta construir un sistema de alarma que nos envíe un aviso al móvil cuando detecte movimiento. Para el montaje de hoy vamos a usar un led, un piezo y el sensor PIR. El esquema es el siguiente:

Y aquí el esquema montado en la placa de prototipo

El funcionamiento del circuito es muy simple, cuando detecte movimiento encenderá el LED y el piezo emitirá un sonido. Aquí tenemos una imagen del PIR visto por la parte de abajo:

Como podemos ver, la información sobre la función de cada pin brilla por su ausencia. En este caso en concreto, el pin de la izquierda es GND, el del centro es el de datos y el de la derecha es VCC. Tenemos además los jumpers de la parte inferior izquierda que sirven para determinar cómo responderá el pin de datos si el evento de detección de movimiento se repite. Se puede configurar de modo que el pin de datos esté siempre en alto cuando detecte movimiento constantemente, o para que al detectar movimiento devuelva un pulso a HIGH y después vuelva a LOW, de forma que al detectar movimiento repetidamente devuelva una secuencia de unos y ceros. El de la foto está configurado del segundo modo. Para que esté siempre en alto solo hay que cambiar el jumper para que abarque los dos pines de arriba. Y por último, los dos tornillos anaranjados de la parte inferior sirven para modificar la distancia a la que detectará la variación de infrarrojos, es decir, lo cerca que tienes que estar para que te detecte, y el tiempo de la variación.
Y a continuación el sketch:

const byte sensorPin=2;
const byte ledPin=4;
const byte piezoPin=8;

const char contrast=57;

void setup(){
  Serial.begin(115200);
  pinMode(sensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(piezoPin, OUTPUT);
  Serial.println("Inicializacion OK");
}

void loop(){
    if(digitalRead(sensorPin)){
      digitalWrite(ledPin,HIGH);
      tone(piezoPin,3000,10);
    }
    else{
      digitalWrite(ledPin,LOW);
    }
    delay(250);
     
} 

El código es muy sencillo. Simplemente consulta el estado del sensor cada 250 milisegundos y enciende el led y hace sonar el piezo si se detecta movimiento. En caso contrario se apaga el led.

Nivelando superficies con un acelerómetro

Cómo funciona un acelerómetro

Un acelerómetro, como su nombre indica, mide la aceleración a la que está sometido. Si lo movemos, nos medirá no sólo la aceleración, sino hacia dónde acelera. Para ello nuestro acelerómetro tiene una entrada para cada dimensión del espacio y nos devolverá los tres componentes del vector aceleración. Pero no solo es capaz de medir la aceleración, sino que en reposo mide la componente de la gravedad que soporta cada uno de sus ejes. Si lo conectamos y lo ponemos sobre una mesa en su posición normal veremos cómo las entradas de los ejes x e y tienen más o menos el mismo valor, pero la del eje z no. Esto es porque está perpendicular al centro de la tierra y por lo tanto la atracción gravitatoria recae enteramente sobre el eje z.

Si lo inclinamos un poco z disminuirá al repartirse la gravedad entre los tres ejes.

Así pues, la superficie sobre la que se apoye el acelerómetro estará nivelada cuando el eje perpendicular a ella soporte toda la fuerza de la gravedad si estamos nivelando en horizontal y ninguna fuerza si estamos nivelando en vertical. Un detalle importante es que el acelerómetro puede detectar la gravedad pero no la orientación, es decir, que si lo rotamos alrededor de uno de los ejes no se enterará. Para detectar el giro necesitaríamos un giróscopo . Este detalle es importante a la hora de mostrar en la pantalla LCD la inclinación que tiene el acelerómetro, ya que nos obliga a orientar correctamente los ejes para realizar el nivelado de superficies verticales.

El acelerómetro

Para el circuito vamos a usar un acelerómetro GY-61. Como podemos ver en la imagen tiene dibujados los ejes para que podamos orientarlo. Para que el sketch funcione correctamente lo tenemos que orientar de forma que el eje Z quede perpendicular a la placa de prototipo. El acelerómetro funciona a 3.3V, por lo que tenemos que ir con cuidado de no conectarlo al pin de 5V de Arduino sino al 3.3V ya que lo podemos quemar.

La pantalla LCD

Para mostrar la orientación del acelerómetro vamos a usar una pantalla Nokia LCD 5110. Supuestamente es la que llevan varios modelos de móviles Nokia, así que, al menos en teoría, los podríamos desmontar y reutilizar la pantalla. En mi caso la he comprado, ya que tampoco tienen un precio excesivo. Para programarla usaremos la biblioteca de arduino desarrollada por Adafruit. La podemos descargar aquí. También tenemos que descargar la biblioteca GFX también desarrollada por Adafruit.

La pantalla LCD también funciona a 3.3V y por lo tanto también tendremos que conectarla al pin 3.3V de arduino. Además tendremos que usar resistencias para bajar el voltaje que le llega desde los pines digitales, ya que su voltaje de salida es 5V. En la conexión del acelerómtro no las necesitamos porque únicamente vamos a leer, pero en los pines del LCD vamos a escribir y por lo tanto les tenemos que enviar 3.3V en lugar de 5V, que es lo que sale de los pines del arduino. El esquema de conexión es el siguiente:

  

El pin LED del LCD es el que se encarga de iluminar la pantalla. Lo hemos conectado a corriente para que esté siempre iluminada. Si quisiéramos encenderla mediante programación tendríamos que conectarla a uno de los pines digitales de arduino y encenderla o apagarla con la función analogWrite poniendo el pin a HIGH o LOW. El resto de pines digitales son los estándares del protocolo SPI que es el que usa la biblioteca de Adafruit. Un detalle importante es que conectamos el pin VCC y LED directamente a corrienta porque todo el circuito está funcionando a 3.3V. Si conectamos el LCD a un circuito cuyos componentes funcionen a 5V deberemos ponerles una resistencia de 10kΏ o correremos el riesgo de quemar el LCD. Aquí lo tenemos montado en la placa de prototipo

El sketch

El sketch va a dibujar en el LCD dos círculos, uno señalará el punto en el que la superficie está nivelada y el otro se moverá conforme vayamos inclinando el acelerómetro. La superficie estará nivelada cuando el segundo círculo esté dentro del primero.
Antes de poder usar el acelerómetro tenemos que calibrarlo para averiguar los valores para 1g, 0g y -1g. Para ello lo colocaremos sobre una superficie horizontal y anotaremos los valores para el eje Z, que será 1g, y el valor para X o Y que serán 0g. Para averiguar el -1g pondremos el acelerómetro al revés y lo rotamos hacia ambos lados. El menor valor que tome será -1g. Las constantes que guardan estos valores son:

const int negativegValue=270;
const int zerogValue=350;
const int onegValue=424;

El código fuente completo:

#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

const int xPin = 0;
const int yPin = 1;
const int zPin = 2;

const byte SCLKpin = 13;
const byte DNpin = 11;
const byte DCpin = 12; 
const byte RESETpin = 10;

const byte ballRadius=5;
const byte errorMargin=1;
int xReadOld=0;
int yReadOld=0;
int zReadOld=0;

const int negativegValue=270;
const int zerogValue=350;
const int onegValue=424;
char contrast=57;
char buffer[10];

Adafruit_PCD8544 lcd(SCLKpin,DNpin,DCpin,RESETpin);

void setup(){
  Serial.begin(115200); 
  lcd.begin();
  lcd.setContrast(contrast);
}


void loop(){

  int xRead = analogRead(xPin);
  int yRead = analogRead(yPin);
  int zRead = analogRead(zPin);
  int currentX;
  int currentY;
  /* Elegimos la orientacion que estamos nivelando por el valor del eje z que siempre sera perpendicular a la superficie
  Cambiaremos segun su valor este mas cerca de cero o de 1g*/
  if(zRead<(zerogValue+((onegValue-zerogValue)/2))){
    //Orientacion vertical
    //currentX=lcd.width()/2;
    currentX=map(zerogValue,negativegValue,onegValue,0,lcd.width());
    currentY=map(zRead,negativegValue,onegValue,0,lcd.height());
  }
  else{
    currentX=map(xRead,negativegValue,onegValue,0,lcd.width());
    currentY=map(yRead,negativegValue,onegValue,0,lcd.height());
  }
  
  if(abs(zRead-zReadOld)>=errorMargin){
  
    lcd.clearDisplay();
    
    drawBall(currentX,currentY,5);
    
    xReadOld=xRead;
    yReadOld=yRead;
    zReadOld=zRead;
  }
  
  
  Serial.print("xRead: ");
  Serial.print(xRead);
  Serial.print(" | yRead: ");
  Serial.print(yRead);
  Serial.print(" | zRead: ");
  Serial.println(zRead);

  

  delay(100);
}

void drawBall(int x,int y,int radius){
  
  for(int i=0;i<radius;i++){
    lcd.drawCircle(x,y,i,BLACK);
  }
lcd.drawCircle((int)map(zerogValue,negativegValue,onegValue,0,lcd.width()),(int)map(zerogValue,negativegValue,onegValue,0,lcd.height()),radius+2,BLACK);
  lcd.display();
}

Básicamente lo que hace el sketch es leer los valores de los tres ejes del acelerómetro y redibujar la pantalla cuando el eje Z se ha movido más de un margen de error indicado en la variable errorMargin. La orientación de la superficie a nivelar lo decidimos en función del valor del eje Z, si está más cerca de 1g asumiremos que estamos nivelando una superficie horizontal y si está más cerca de 0g asumiremos que nivelamos una superficie vertical. Para las superficies horizontales la bola se moverá en cualquier dirección del plano XY y para las verticales sólo se moverá arriba y abajo. Para que funcione correctamente con las superficies verticales tenemos que situar el acelerómetro con la flecha del eje Y apuntando hacia el centro de la Tierra. Aquí tenemos un vídeo mostrando su funcionamiento

Construcción de una caja musical con arduino V

Vamos a concluir la construcción de la caja musical con la soldadura y el montaje.En las imágenes vemos todos los componentes soldados al shield

Y el conjunto completo con el altavoz y el botón de encendido

El montaje ya dentro de la caja

Para el encendido y apagado del microcontrolador hemos usado un botón en la parte posterior de la caja, conectado a una pila por un extremo y al microcontrolador por el otro. El botón deja pasar la corriente cuando está pulsado, de forma que al abrir la tapa lo pulsa y cierra el circuito.

Y aquí tenemos la caja acabada y funcionando

Artículos relacionados

Construcción de una caja musical con arduino IV
Construcción de una caja musical con arduino III
Construcción de una caja musical con arduino II
Construcción de una caja musical con arduino I

Construcción de una caja musical con arduino IV

El sketch que hemos creado hasta ahora reproduce canciones indefinidamente sin interrumpirlas en ningún momento. En este artículo vamos a añadir el mecanismo para que la música se interrumpa cuando se cierra la caja y vuelva a sonar cuando se abre. Existen varias formas de hacerlo, pero en este artículo me voy a centrar en dos.

Utilizando una fotorresistencia

Una fotorresistencia funciona igual que el potenciómetro del artículo anterior, pero la resistencia varía con la cantidad de luz que detecta. La idea es que al cerrar la caja la fotorresistencia detecte la variación de luz al abrir y cerrar la caja para interrumpir o reanudar la música. En la foto podemos ver una fotorresistencia y una resistencia

El fotorresistor está conectado en serie con una resistencia de 10 KΩ. El valor devuelto por el fotoresistor lo leeremos por el pin analógico 2. El esquema es el siguiente

Y por último el montaje del prototipo

En el siguiente vídeo podemos ver el prototipo en funcionamiento.

El sketch

En el sketch hemos definido un umbral mínimo de luz por debajo del cual la música se interrumpirá. Cuando la luz vuelva a estar por encima del valor mínimo se volverá a elegir una nueva canción y se reproducirá. 

#include <SPI.h>

#include <Adafruit_VS1053.h>

#include <SD.h>

#define MP3_XCS 6   // CS Registros

#define MP3_XDCS 7  // CS Datos (BSYNC)

#define MP3_DREQ 2  // Interrupción chip disponible

#define MP3_RESET 5 // Reset activo bajo

#define VOLUME_PIN A1

#define PHOTO_PIN A2

#define MIN_VOLUME 70

#define MIN_LIGHT_LEVEL 900

bool isSdOpened=false;

File root;

File entry;

long fileCount;

unsigned long totalBytes;

int currentVolume=MIN_VOLUME-map(analogRead(VOLUME_PIN),0,1023,0,MIN_VOLUME);

int oldVolume=currentVolume;

int currentLightLevel=analogRead(PHOTO_PIN);

bool active=currentLightLevel>=MIN_LIGHT_LEVEL;

Adafruit_VS1053_FilePlayer musicPlayer = Adafruit_VS1053_FilePlayer(MP3_RESET, MP3_XCS, MP3_XDCS, MP3_DREQ, 10);

void setup(){

  pinMode(10,OUTPUT);

  Serial.begin(115200);

  musicPlayer.begin();

  

  while(!isSdOpened){

    isSdOpened=SD.begin(10);

  

    Serial.print("SD.begin ");

    Serial.println(isSdOpened);

  }

   musicPlayer.useInterrupt(VS1053_FILEPLAYER_PIN_INT); 

   musicPlayer.setVolume(currentVolume,currentVolume);

  

  root=SD.open("/");

  root.rewindDirectory();

  fileCount=0;

  entry=root.openNextFile();

  while(entry){

    fileCount++;

    Serial.print(entry.name());

    Serial.print("\t");

    if(entry.isDirectory()){

      Serial.println("Directorio");

    }

    else{

      Serial.println(entry.size(), DEC);

    }

    entry.close();

    entry=root.openNextFile();

  }

  root.rewindDirectory();

  Serial.print("Numero de ficheros: ");

  Serial.println(fileCount);

  randomSeed(analogRead(0));

  

  Serial.print("Volumen: ");

  Serial.println(currentVolume);

  Serial.println("Reset finalizado");

  

}

void loop(){

  

  currentLightLevel=analogRead(PHOTO_PIN);

  

  delay(1000);

  

  if(currentLightLevel>=MIN_LIGHT_LEVEL){

    active=true;

    if(!musicPlayer.playingMusic){

     

      

      Serial.print("currentLightLevel: ");

      Serial.print(currentLightLevel);

      Serial.print(" MIN_LIGHT_LEVEL: ");

      Serial.println(MIN_LIGHT_LEVEL);

     root.rewindDirectory();

  

     int randNumber = random(1,fileCount+1);

  

     Serial.print("Numero aleatorio: ");

     Serial.println(randNumber);

  

     for(int i=0;i<randNumber;i++){

       entry=root.openNextFile();

       entry.close();

    

      }

      Serial.print("Fichero: ");

      Serial.println(entry.name());

      

      musicPlayer.startPlayingFile(entry.name());

    }

    else{

      delay(500);

      currentVolume=MIN_VOLUME-map(analogRead(VOLUME_PIN),0,1023,0,MIN_VOLUME);

      if(currentVolume!=oldVolume){

        musicPlayer.setVolume(currentVolume,currentVolume);

        oldVolume=currentVolume;

        Serial.print("Volumen: ");

        Serial.println(currentVolume);

     }

   }

  }

  else if(active){

    Serial.print("currentLightLevel: ");

      Serial.print(currentLightLevel);

      Serial.print(" MIN_LIGHT_LEVEL: ");

      Serial.println(MIN_LIGHT_LEVEL);

      active=false;

      asm volatile ("  jmp 0");

      

     

    }

  }

Comentarios al código fuente

Hemos definido dos nuevas variables, PHOTO_PIN y MIN_LIGHT_LEVEL para definir el pin al que hemos conectado el fotorresistor y el umbral mínimo de luz para reproducir una canción. En la función loop() verificamos si la luz detectada por el fotoresistor es mayor que el umbral mínimo y si es mayor ejecutamos el mismo código que en el sketch anterior. En caso contrario comprobamos la variable active que determina si al leer un valor por debajo del umbral mínimo de luz la música estaba activa, lo cual significa que acabamos de bajar del umbral y por lo tanto hay que interrumpir la música. La forma más fácil de interrumpir la música es reiniciar el programa con la instrucción asm volatile ("  jmp 0").

Utilizando una pila

El problema del enfoque anterior es que el microcontrolador necesita estar siempre activo, es decir, consumiendo energía para poder detectar los cambios de luz. Esto nos lleva al problema de cómo proveer de energía a nuestra caja. El microcontrolador Arduino Uno puede alimentarse por USB, con un adaptador de corriente (según la documentación necesita entre 7 y 12 Voltios, pero puede soportar hasta 20) y a través del pin VIN. Las posibles opciones son:

• Cable USB. Es poco práctico tener la caja siempre conectada a un ordenador en marcha.
• Adaptador de corriente. Es una buena opción si vamos a tener la caja siempre en el mismo sitio, pero hay que tener en cuenta que siempre que la enchufemos estará consumiendo energía a menos que el adaptador tenga un interruptor que habría que conectar antes de abrir la caja.
• Pilas. Se puede conectar uno de los varios adaptadores que existen para alimentarlo mediante pilas. Los hay que se conectan a la entrada DC y también que se conectan al pin VIN. Dado que el microcontrolador estará siempre consumiendo energía es poco práctico a menos que añadamos un un interruptor, o quitar la pila cuando no la usemos para que no la consuma.
• Panel solar. El panel solar sólo estará alimentando en microcontrolador cuando reciba luz. Esta sería la solución ideal si siempre fuésemos a tener suficiente luz, ya que nos permite proveer de energía sin cables y si la ponemos en el interior de la caja solo recibirá luz cuando se abra. La ventaja adicional es que no tenemos que modificar el sketch que hemos programado en el artículo anterior.

Para terminar el diseño de la caja me he decantado por alimentarlo con la pila, que sólo alimentará el circuito se accione un pequeño interruptor que pondremos en la tapa de la caja de forma que se accione cuando la tapa se abra o se cierre. Conectaremos el pulsador de forma que cuando se presione abra el circuito, y lo cierre cuando se libere, es decir, lo presionará la tapa cuando se cierre la caja y se liberará cuando se abra. Aquí tenemos el interruptor:

Lo vamos a conectar en la entrada de corriente del circuito, que será una pila de 9 voltios

La ventaja de este montaje es que no hay que modificar el sketch del artículo anterior para que funcione y además sólo consumirá energía cuando reproduzca la música. Este es pues el diseño definitivo de nuestra caja. En el próximo artículo soldaremos los componentes a un shield para conectarlo al microcontrolador y atornillarlo a la caja.

Artículos relacionados

Construcción de una caja musical con arduino V
Construcción de una caja musical con arduino III
Construcción de una caja musical con arduino II
Construcción de una caja musical con arduino I

Construcción de una caja musical con arduino III

En este artículo vamos a añadir un potenciómetro a nuestro prototipo para ajustar el volumen del decodificador MP3. Un potenciómetro es un resistor variable que normalmente posee algún tipo de control que nos permite ajustar su resistencia y por lo tanto el voltaje que leeremos por unos de los pins analógicos del microcontrolador. En la foto vemos dos tipos de potenciómetros. En uno el ajuste de la resistencia se hace mediante una rueda que se puede girar fácilmente los dedos. En el otro se hace mediante un pequeño tornillo. Obviamente para nuestra caja usaremos el primero, ya que no queremos que el usuario tenga que ajustar el volumen con un destornillador ;-)

El potenciómetro tiene tres pines, dos de ellos van a corriente y tierra, y el tercero va conectado a uno de los pines analógicos del microcontrolador. El esquema de conexión es el siguiente

Y aquí está montado en la placa de prototipo

El sketch

El código fuente modificado para que al girar la rueda del potenciómetro se ajuste el volumen es el siguiente:

#include <SPI.h>
#include <Adafruit_VS1053.h>
#include <SD.h>

#define MP3_XCS 6   // CS Registros
#define MP3_XDCS 7  // CS Datos (BSYNC)
#define MP3_DREQ 2  // Interrupción chip disponible
#define MP3_RESET 5 // Reset activo bajo
#define VOLUME_PIN A1
#define MIN_VOLUME 70


bool isSdOpened=false;
File root;
File entry;
long fileCount;
unsigned long totalBytes;
int currentVolume=MIN_VOLUME-map(analogRead(VOLUME_PIN),0,1023,0,MIN_VOLUME);
int oldVolume=currentVolume;

Adafruit_VS1053_FilePlayer musicPlayer = Adafruit_VS1053_FilePlayer(MP3_RESET, MP3_XCS, MP3_XDCS, MP3_DREQ, 10);


void setup(){
  pinMode(10,OUTPUT);
  Serial.begin(115200);

  musicPlayer.begin();

  while(!isSdOpened){
    isSdOpened=SD.begin(10);

    Serial.print("SD.begin ");
    Serial.println(isSdOpened);
  }

   musicPlayer.useInterrupt(VS1053_FILEPLAYER_PIN_INT);
   musicPlayer.setVolume(currentVolume,currentVolume);

  root=SD.open("/");
  root.rewindDirectory();
  fileCount=0;
  entry=root.openNextFile();
  while(entry){
    fileCount++;
    Serial.print(entry.name());
    Serial.print("\t");
    if(entry.isDirectory()){
      Serial.println("Directorio");
    }
    else{
      Serial.println(entry.size(), DEC);
    }
    entry.close();
    entry=root.openNextFile();
  }
  root.rewindDirectory();
  Serial.print("Numero de ficheros: ");
  Serial.println(fileCount);
  randomSeed(analogRead(0));

  Serial.print("Volumen: ");
  Serial.println(currentVolume);

}


void loop(){

  if (! musicPlayer.playingMusic) {
    musicPlayer.softReset();
    delay(1000);
    root.rewindDirectory();

    int randNumber = random(1,fileCount+1);

    Serial.print("Numero aleatorio: ");
    Serial.println(randNumber);

    for(int i=0;i<randNumber;i++){
      entry=root.openNextFile();
      entry.close();
 
    }
    Serial.print("Fichero: ");
    Serial.println(entry.name());
    musicPlayer.startPlayingFile(entry.name());
  }
  else{
    currentVolume=MIN_VOLUME-map(analogRead(VOLUME_PIN),0,1023,0,MIN_VOLUME);
    if(currentVolume!=oldVolume){
      musicPlayer.setVolume(currentVolume,currentVolume);
      oldVolume=currentVolume;
      Serial.print("Volumen: ");
      Serial.println(currentVolume);
    }
  }
}

Comentarios al código fuente

En la instrucción currentVolume=MIN_VOLUME-map(analogRead(VOLUME_PIN),0,1023,0,MIN_VOLUME) leemos el valor de la entrada analógica y lo adaptamos al rango de valores que vamos a pasarle a la funcion setVolume(). La función analogRead(VOLUME_PIN) devuelve un valor entre 0 y 1023, pero a setVolume() le vamos a pasar un valor entre 0 y 70. La función map() devuelve un valor extrapolado de un rango a otro. En nuestro caso le pasamos un valor entre 0 y 1023 y devuelve su valor proporcional en el rango 0 a 70. Y por último restamos el valor devuelto por map() a 70 porque cuanto menor es el valor que le pasamos a setVolume() mayor es el volumen de la canción, es decir, el valor cero es el máximo volumen.
En la función loop(), cuando no se está reproduciendo la canción leemos el valor del potenciómetro y si ha cambiado ajustamos el valor con setVolume().

Con esto ya tenemos las funcionalidades básicas de nuestra caja. En la próxima entrada veremos cómo hacer que la música se reproduzca o pare cuando se abre o cierra la caja.

Artículos relacionados

Construcción de una caja musical con arduino I

Construcción de una caja musical con arduino II
Construcción de una caja musical con arduino IV
Construcción de una caja musical con arduino V

 

Construcción de una caja musical con arduino II

Seguimos con la construcción de la caja musical que empezamos en Construcción de una caja musical con arduino I. Esta vez vamos a conectar el decodificador MP3 para que lea el fichero de la tarjeta SD que hemos seleccionado aleatoriamente y lo reproduzca. Para ello vamos a usar un módulo decodificador de MP3 basado en el chip VS1003/VS1053.

El esquema es el siguiente:

Y aquí lo tenemos montado en la placa de prototipo:

Como hemos visto en el esquema, el lector de tarjetas y el decodificador MP3 comparten algunas conexiones. Esto es consecuencia del uso del protocolo SPI  para la comunicación del microcontrolador con ambos dispositivos. De esta forma necesitamos menos pines para conectar varios dispositivos. Básicamente la idea es que haya un dispositivo master (el microcontrolador) y varios dispositivos esclavos (el lector de tarjetas y el decodificador MP3). El controlador elige con qué dispositivo se comunica desactivando los demás y usando las vías de comunicación comunes a todas ellas. El decodificador MP3 usa además otros cuatro pines además de los de corriente (5V y GND). La entrada XCS conectada al pin digital 6 del microcontrolador es la de Chip Select, que ha de ponerse a LOW para seleccionar el dispositivo. La entrada XDCS conectada al pin digital 7 es la de Data Chip Select, que ha de ponerse a LOW para enviar datos. La entrada DREQ conectada al pin digital 2 es la de Data Request, que estará a HIGH cuando el buffer de datos está vacío y por lo tanto podemos enviarle más. Y por último la entrada XRST conectada al pin digital 5 es la de reset, para reiniciar el dispositivo. Como veremos en el sketch, todo esto no debe preocuparnos ya que vamos a usar una biblioteca que nos permite obviar todos los detalles del protocolo SPI.

El sketch

Vamos a modificar el sketch del primer artículo de la serie para enviar el fichero seleccionado de la tarjeta al decodificador MP3. Para ello vamos a usar la biblioteca Adafruit VS1053 que se puede descargar aquí, ya que no viene por defecto en el IDE de arduino. Para instalarla hay que copiar los dos ficheros, Adafruit_VS1053.h y Adafruit_VS1053.cpp en una carpeta que crearemos donde están el resto de bibliotecas de nuestro IDE. O bien los podemos importar desde cualquier otra carpeta con la opción Sketch/Importa biblioteca.../Añadir del propio IDE de arduino. El código fuente del sketch es el siguiente:

#include <SPI.h>
#include <Adafruit_VS1053.h>
#include <SD.h>

#define MP3_XCS 6   // CS Registros
#define MP3_XDCS 7  // CS Datos (BSYNC)
#define MP3_DREQ 2  // Interrupción chip disponible
#define MP3_RESET 5 // Reset activo bajo


bool isSdOpened=false;
File root;
File entry;
long fileCount;
unsigned long totalBytes;

Adafruit_VS1053_FilePlayer musicPlayer = Adafruit_VS1053_FilePlayer(MP3_RESET, MP3_XCS, MP3_XDCS, MP3_DREQ, 10);


void setup(){
  pinMode(10,OUTPUT);
  Serial.begin(115200);

  musicPlayer.begin();

  while(!isSdOpened){
    isSdOpened=SD.begin(10);

    Serial.print("SD.begin ");
    Serial.println(isSdOpened);
  }

  musicPlayer.setVolume(10,10);

   musicPlayer.useInterrupt(VS1053_FILEPLAYER_PIN_INT);

  root=SD.open("/");
  root.rewindDirectory();
  fileCount=0;
  entry=root.openNextFile();
  while(entry){
    fileCount++;
    Serial.print(entry.name());
    Serial.print("\t");
    if(entry.isDirectory()){
      Serial.println("Directorio");
    }
    else{
      Serial.println(entry.size(), DEC);
    }
    entry.close();
    entry=root.openNextFile();
  }
  root.rewindDirectory();
  Serial.print("Numero de ficheros: ");
  Serial.println(fileCount);
  randomSeed(analogRead(0));

}


void loop(){

  if (! musicPlayer.playingMusic) {
    musicPlayer.softReset();
    delay(1000);
    root.rewindDirectory();

    int randNumber = random(1,fileCount+1);

    Serial.print("Numero aleatorio: ");
    Serial.println(randNumber);

    for(int i=0;i<randNumber;i++){
      entry=root.openNextFile();
      entry.close();
 
    }
    Serial.print("Fichero: ");
    Serial.println(entry.name());
    musicPlayer.startPlayingFile(entry.name());
  }

}

Comentarios al código fuente

La primera línea que hemos añadido es #include <Adafruit_VS1053.h> para poder usar las funciones de acceso al decodificador MP3. En la instrucción Adafruit_VS1053_FilePlayer musicPlayer = Adafruit_VS1053_FilePlayer(MP3_RESET, MP3_XCS, MP3_XDCS, MP3_DREQ, 10) estamos inicializando el decodificador MP3 con los valores de los pines a los que lo hemos conectado. Y finalmente musicPlayer.startPlayingFile(entry.name()) reproduce el fichero. Hemos añadido el if (! musicPlayer.playingMusic) porque la función de reproducción devuelve el control al programa inmediatamente, lo cual es importante si queremos hacer más cosas mientras se reproduce la canción como es nuestro caso. Pero esto ya lo veremos en la tercera entrega donde conectaremos un potenciómetro para controlar el volumen al que se reproducirá la canción.

Artículos relacionados

Construcción de una caja musical con arduino I
Construcción de una caja musical con arduino III
Construcción de una caja musical con arduino IV
Construcción de una caja musical con arduino V

Construcción de una caja musical con arduino I

Empiezo el blog con una serie de artículos en los que construiré una caja musical que al abrirla reproduzca un fichero mp3 aleatorio almacenado en una tarjeta SD. Para ello añadiremos la circuitería necesaria a una caja de madera.

Vamos a empezar conectando un módulo lector de tarjetas SD a un microcontrolador Arduino uno. Nuestro módulo lector de tarjetas es un YL-30.

La conexión de los pines al microcontrolador es el siguiente:

Pin CS (Chip Select) al pin digital 10
Pin MOSI (Master Out Slave In) al pin digital 11
Pin MISO (Master In Slave Out) al pin digital 12
Pin SCK (System Clock) al pin digital 13
Pin +5V al pin 5V
Pin GND al pin GND

Es importante no cambiar la conexión de los pines ya que en el sketch vamos a usar la biblioteca SD de arduino, que a su vez usa la SPI,para acceder al sistema de ficheros de la tarjeta. Esta biblioteca usa estos pines para comunicarse con el módulo YL-30.

Y aquí lo tenemos montado en la placa de prototipo

El sketch

Una vez montado nuestro prototipo tenemos que crear un sketch que generará un número aleatorio y seleccionará el fichero de la tarjeta que corresponda al número generado. Para ello usaremos el entorno de programación de arduino.

#include <SD.h>

bool isSdOpened;
File root;
File entry;
long fileCount;


void setup(){
  pinMode(10,OUTPUT);
  isSdOpened=SD.begin(10);
  Serial.begin(9600);
  Serial.print("SD.begin ");
  Serial.println(isSdOpened);
  root=SD.open("/");
  root.rewindDirectory();
  fileCount=0;
  entry=root.openNextFile();
  while(entry){
    fileCount++;
    Serial.print(entry.name());
    Serial.print("\t");
    if(entry.isDirectory()){
      Serial.println("Directorio");
    }
    else{
      Serial.println(entry.size(), DEC);
    }
    entry.close();
    entry=root.openNextFile();
  }
  root.rewindDirectory();
  Serial.print("Numero de ficheros: ");
  Serial.println(fileCount);
  randomSeed(analogRead(0));

}

void loop(){
  root.rewindDirectory();

  int randNumber = random(1,fileCount+1);

  for(int i=0;i<randNumber;i++){
    entry=root.openNextFile();
    entry.close();
 
  }
  Serial.print("Numero aleatorio: ");
  Serial.println(randNumber);
  Serial.print("Fichero: ");
  Serial.println(entry.name());
  delay(10000);
}

Más información sobre el lenguaje de programación de arduino aquí. Está basado en C y básicamente lo que hace es ejecutar una vez la función setup y repetir indefinidamente la función loop.

Comentarios al código fuente

La primera instrucción de la función setup pinMode(10,OUTPUT)  pone el pin al que hemos conectado el pin CS del módulo SD en modo salida. Sin esta instrucción las demás funciones de acceso a los ficheros de la tarjeta no funcionarán.

La siguiente instrucción isSdOpened=SD.begin(10) inicializa el módulo lector para que podamos usarlo. Por defecto usa el pin 10 del microcontrolador, así que si lo hemos montado tal como indica el esquema la podemos pasar sin parámetros.

Siguiendo con la función setup, una vez inicializado el módulo abrimos el directorio raiz con la instrucción root=SD.open("/"). La siguiente instrucción root.rewindDirectory() lo que hace es volver al primer fichero del directorio y en teoría no es necesaria cuando acabas de abrir un directorio, pero parece ser que hay un bug que provoca errores si no se rebobina el directorio al abrirlo. Una vez abierto el directorio, lo recorremos en el bucle while para contar el número de ficheros y poder sacar así el número aleatorio dentro del rango correcto.

Un detalle muy importante a tener en cuenta es que los experimentos se hacen con gaseosa, es decir, no uses la tarjeta SD de tu cámara cuyas fotos aún no has pasado al ordenador para hacer las pruebas porque lo puedes lamentar amargamente. Y lo digo por las instrucciones entry=root.openNextFile() y entry.close(), que hacen lo que indica su nombre, abrir y cerrar ficheros. El peligro, que he tenido ocasión de comprobar, es que una operación de apertura sin su correspondiente cierre puede corromper el fichero.

En la instrucción randomSeed(analogRead(0)) inicializa el generador aleatorio de números para que la función random() no genere siempre la misma secuencia de números aleatorios. El uso de la función analogRead(0) como parámetro de randomSeed() es porque necesitamos inicializar el generador de números aleatorios con un número diferente cada vez. En un ordenador lo haríamos pasando como parámetro a randomSeed() la hora del sistema, pero nuestro microcontrolador no tiene reloj así que lo que hacemos es leer de un pin que no está conectado a nada cuyo valor es imprevisible. El problema es que la función analogRead() devuelve un valor entre 0 y 1023, con lo cual es bastante probable que con el uso se repitan secuencias de números, pero como tampoco vamos a generar claves de cifrado no creo que suponga mucho inconveniente.

En la función loop() lo que hacemos es generar un número aleatorio entre 1 y el número de ficheros con int randNumber = random(1,fileCount+1) y accedemos a él con el bucle for.

La salida del sketch por el puerto serie es la siguiente:

SD.begin 1
01-BOB~1.MP3 3368960
02-BOB~1.MP3 3897344
03-BOB~1.MP3 4413505
04-BOB~1.MP3 6598656
05-BOB~1.MP3 7415808
06-BOB~1.MP3 5928960
07-BOB~1.MP3 3074048
08-BOB~1.MP3 4009984
09-BOB~1.MP3 3710976
10-BOB~1.MP3 3268608
11-BOB~1.MP3 3045376
12-BOB~1.MP3 5967872
13-BOB~1.MP3 6866944
14-BOB~1.MP3 4851712
15-BOB~1.MP3 6514688
16-BOB~1.MP3 7540736
17-BOB~1.MP3 3913728
18-BOB~1.MP3 7213056
Numero de ficheros: 18
Numero aleatorio: 17
Fichero: 17-BOB~1.MP3
Numero aleatorio: 8
Fichero: 08-BOB~1.MP3
Numero aleatorio: 16
Fichero: 16-BOB~1.MP3
Numero aleatorio: 8
Fichero: 08-BOB~1.MP3
Numero aleatorio: 1
Fichero: 01-BOB~1.MP3
Numero aleatorio: 10
Fichero: 10-BOB~1.MP3
Numero aleatorio: 5
Fichero: 05-BOB~1.MP3
Numero aleatorio: 8
Fichero: 08-BOB~1.MP3
Numero aleatorio: 7
Fichero: 07-BOB~1.MP3
Numero aleatorio: 12
Fichero: 12-BOB~1.MP3
Numero aleatorio: 14
Fichero: 14-BOB~1.MP3

Los más viejos del lugar habrán reconocido la estructura 8+3 de los ficheros que se usaba en windows 95 y 98. La biblioteca SD de arduino sólo soporta los sistemas de ficheros FAT16 y FAT32, pero para el caso que nos ocupa es más que suficiente.

En la próxima entrega conectaremos el módulo reproductor de MP3 al prototipo que hemos creado y modificaremos el sketch para que reproduzca el fichero que hemos seleccionado aleatoriamente.

Artículos relacionados

Construcción de una caja musical con arduino II
Construcción de una caja musical con arduino III
Construcción de una caja musical con arduino IV
Construcción de una caja musical con arduino V