Buscador

sábado, 17 de septiembre de 2016

Conexión directa por ethernet a Banana Pro

En esta ocasión explicaré cómo conectarse a nuestra Banana Pro sin necesidad de internet. Usaremos una conexión directa entre el conector ethernet de nuestro ordenador y el que lleva incorporado nuestra Banana Pro.

El sistema que usaré en mi máquina es Ubuntu 16.X y el de mi Banana Pro es Ubuntu 14.X.

Primero configuraremos el ethernet de nuestro ordenador, para ello nos vamos a " System settings " ( supongo que en castellano será algo parecido a " herramientas del sistema ") , una vez ahí, entramos en " network " y accedemos a la opción por cable.




Una vez ahí, buscamos " opciones " o un botón con un nombre parecido en la esquina derecha inferior:



Nos vamos a la pestaña " general " y seleccionamos la opción de conectarse cuando esté disponible.




Seguidamente, pasamos a la pestaña de la configuración de IPV4, donde cambiaremos a " shared to other computers " ( algo parecido a "compartido con otros ordenadores "):





En este punto conectaremos nuestra Banana Pro y ordenador mediante un cable ethernet y encenderemos nuestra Banana Pro, esperamos un par de minutos a que el sistema inicie y seguidamente intentaremos conectarnos mediante SSH.

Para ello, pulsa  ctrl + alt+ t ( abrir una terminal)  y prueba de realizar una conexión. Normalmente el usuario es " bananapi" y el host " lemaker ".


ssh bananapi@lemaker.local


Si todo ha ido bien, veremos algo parecido a esto:


Le escribimos el siguiente password:

bananapi

Y ya estaremos conectados !



Próximamente enseñaré cómo conectar un SATA ( también cómo hacernos nuestro propio cable de alimentación SATA) y que arranque el sistema desde éste. Puede que, aunque no tan seguro, enseñe cómo compilar u-boot desde el código fuente original y cómo montar nuestro propio sistema operativo desde el código fuente.

saludos!


+info

jueves, 22 de octubre de 2015

Guardar estado pulsado de LED en memoria EEPROM interna de Arduino ( petición de Meta)

Muy buenas a tod@s, os adjunto un código sugerido por un visitante de este blog que consiste en crear una combinación binaria con pulsadores ( 4 pulsadores, un nibble ) y con un quinto botón (botón de guardar) que permite almacenar el dato en la EEPROM de nuestro Arduino. De esa forma, aunque se vaya la luz quedará grabada una copia de la combinación hecha.


/*
  Guarda en la EEPROM la combinación de los pulsadores BOTON_1 ~~ BOTON_4  al pulsar el botón " BOTON_GUARDAR "
*/

#include <eeprom.h>

//-----------------------defines --------------------------------------------------------------------------------------------------------
#define BOTON_GUARDAR 2 // se ponen en define para ahorrar memoria. 
                        //Si se usases variables, perderías unos 9~18 bytes de memoria (en función del tipo de variable)

#define LED_1 3
#define LED_2 4
#define LED_3 5
#define LED_4 6

#define BOTON_1 7
#define BOTON_2 8
#define BOTON_3 9
#define BOTON_4 10



#define POISICION_DE_MEMORIA_ESTADO_LED 0

//-----------------------variables globales ----------------------------------------------------------------------------------------------
byte dato_entrada = 0;

//-----------------------funciones -------------------------------------------------------------------------------------------------------
void setup() 
{
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(BOTON_GUARDAR), ISR_guardar_dato, RISING);

  pinMode(BOTON_1,INPUT);
  pinMode(BOTON_2,INPUT);
  pinMode(BOTON_3,INPUT);
  pinMode(BOTON_4,INPUT);
  
  pinMode(LED_1,OUTPUT);
  pinMode(LED_2,OUTPUT);
  pinMode(LED_3,OUTPUT);
  pinMode(LED_4,OUTPUT);
  
 lee_EEPROM_y_muestra_dato();
}

void loop() 
{

}

void ISR_guardar_dato()
{
  leer_pulsadores_y_guardar_en_variable();
  actualiza_estado_de_los_LED();
  actualizar_dato_de_la_EEPROM();
}

void lee_EEPROM_y_muestra_dato() // lee el dato de la EEPROM y actualiza los LED en función del dato
{
  dato_entrada = EEPROM.read(POISICION_DE_MEMORIA_ESTADO_LED);
  actualiza_estado_de_los_LED();
}

void actualizar_dato_de_la_EEPROM() // regrabamos el valor del dato que hay en la EEPROM
{
  EEPROM.write(POISICION_DE_MEMORIA_ESTADO_LED, dato_entrada);
}

void actualiza_estado_de_los_LED() // leemos la EEPROM y actualizamos los LED en función del dato
{  
  digitalWrite(LED_1, ( (dato_entrada >>3) & 0x01 ) ); // pintamos cada led con su bit correspondiente
  digitalWrite(LED_2, ( (dato_entrada >>2) & 0x01 ) );
  digitalWrite(LED_3, ( (dato_entrada >>1) & 0x01 ) );
  digitalWrite(LED_4, ( (dato_entrada >>0) & 0x01 ) );      
}


void leer_pulsadores_y_guardar_en_variable()
{
  byte temp = digitalRead(BOTON_1); // X000
  
  if(temp == 1) {  dato_entrada |= (1 << 3); }// el 3 es porque lo guardaremos en el bit 3 de la variable (guardamos 1 ) 
  else          {  dato_entrada &= ~(1 << 3); }// el 3 es porque lo guardaremos en el bit 3 de la variable ( guardamos 0 ) 
  
  temp = digitalRead(BOTON_2); // 0X00
  
  if(temp == 1) {  dato_entrada |= (1 << 2); }// el 2 es porque lo guardaremos en el bit 2 de la variable (guardamos 1 ) 
  else          {  dato_entrada &= ~(1 << 2); }// el 2 es porque lo guardaremos en el bit 2 de la variable ( guardamos 0 )  
  
  temp = digitalRead(BOTON_3); // 00X0
  
  if(temp == 1) {  dato_entrada |= (1 << 1); }// el 1 es porque lo guardaremos en el bit 1 de la variable (guardamos 1 )
  else          {  dato_entrada &= ~(1 << 1); }// el 1 es porque lo guardaremos en el bit 1 de la variable ( guardamos 0 )  
  
  temp = digitalRead(BOTON_4); // 000X
  
  if(temp == 1) {  dato_entrada |= (1 << 0); } // aqui no desplazamos, porque lo dejamos en el bit 0, donde nos encontramos
  else          {  dato_entrada &= ~(1 << 0); } 
}




Un saludo!
+info

lunes, 29 de diciembre de 2014

Leer código tag con módulo RFID "RFID-RC522"

Viendo que mucha gente lo pedía, he creado un código para leer los tags, el código a continuación:


//GeekChickens
//http://geekchickens.blogspot.com.es/
/*
SDA es el pin 10
SCK es el pin 13
MOSI es el pin 11
MISO es el pin 12
RST es el pin 9
*/
//-----------------------------------------------variables, includes, funciones, etc-------------------------------------------------
#include <SPI.h>
#include <RFID.h>

#define SS_PIN 10
#define RST_PIN 9

RFID rfid(SS_PIN, RST_PIN);

int numero_serie[5]; // aqui guardaremos el número que nuestro sensor RFID detectará

 //-----------------------------------------------variables, includes,funciones, etc-------------------------------------------------

void setup()
{
  Serial.begin(9600);
  SPI.begin();
  rfid.init();
}

void loop()
{
   leer_usuario();
}


void leer_usuario()
{
    if (rfid.isCard())
    {
           if (rfid.readCardSerial())
            {
                Serial.print("Numero usuario: "); // guardamos el numero del usuario
                for(int i=0; i<=4 ; i++)
                {
                  numero_serie[i] = rfid.serNum[i];
                }

                for(int i=0; i<=4 ; i++) // y lo imprimimos
                {
                  Serial.print(numero_serie[i]);
                  Serial.print("    ");
                }

                Serial.println(" "); // espacio para el siguiente código
                delay(500); // para que no se imprima constantemente el mismo numero
             }
    }
    rfid.halt();
}




Código fuente aquí


Fuentes:

http://es.wikipedia.org/wiki/RFID

http://es.wikipedia.org/wiki/Serial_Peripheral_Interface

La librería RFID  que yo he usado, ha sido creada por Miguel Balboa, haz click aquí para ir a su github.

La librería SPI que yo he usado, ha sido creada por Cristian Maglie.
+info

lunes, 20 de octubre de 2014

Programar tu Arduino desde el software oficial de Atmel

En esta ocasión, aprenderemos a programar nuestro Arduino usando la IDE oficial de Atmel. En este tutorial enseñaré a programarlo con su código Arduino, pero tengo pensado subir una serie de tutoriales donde lo programaremos con  AVR-C ( el C usado en la arquitectura AVR, la que lleva el uC Atmega328p que usa nuestro Arduino).


Las opciones por las que personalmente recomiendo este editor son:

· viene con opción de debugger ( aunque yo no lo uso :D )
· puedes numerar las líneas
· permite expandir y contraer funciones, lo que ayuda mucho cuando llevas muchas líneas de código
· tiene autocompletar ( aunque no soy muy aficionado a este)
· compila y quema mucho más rápido! ( como mínimo en mi ordenador, que está hecho un cromo )


Materiales / herramientas:

· Arduino Uno con su cable USB
· Software oficial Atmel Studio ( en estos momentos está la versión 6.2), podéis bajarlo aquí.
· Arduino IDE for Atmel Studio, podéis bajarlo aquí.


Una vez instalado el software, nos dirigimos a la pestaña " tools " y hacemos clic en " extension manager " . Nos aparecerá una nueva ventana con actualizaciones y extensiones.

Tendremos que descargarnos un archivo llamado " Arduino IDE for Atmel Studio 6.1 & 6.2 ", tendréis que registraros para poder bajar actualizaciones y extensiones. (Yo os lo he adjuntado por si no queréis registraros ahora)





Una vez descargado, lo instalamos y reiniciamos la IDE de Atmel Studio. Ahora tocará configurarlo, se nos abrirá una ventana muy parecida a la siguiente ( tenemos que introducir la ruta donde tenemos la carpeta Arduino 1.5.6 ( en mi caso es 1.5.6) y la ruta donde dejar los sketch.





Si todo ha ido bien, se nos habrá añadido la siguiente barra:





Ahora lo configuramos poniendo Arduino Uno en vez de Attiny45 ( o el que tengamos por predeterminado). En este paso hay que conectar nuestro Arduino y seleccionar el puerto.





Una vez hecho esto, configuraremos unas opciones para poder quemar nuestro binario directamente a la placa Arduino. Nos dirigimos a la pestaña " tools " y hacemos clic en " external tools... ". Nos aparecerá la siguiente ventana:






La configuración que yo usé fue:

Title:  ArduinoUno_COM5  ( tan sólo es un nombre, es para identificarlo mejor )
Command:   (esto lo tendréis que modificar según el directorio de vuestro Arduino 1.5.6)  Ruta_de_tu_Arduino\hardware\tools\avr\bin\avrdude.exe
Arguments:

-C Ruta_de_tu_Arduino\hardware\tools\avr\etc\avrdude.conf -patmega328p -carduino -P\\.\COM4 -b115200 -Uflash:w:”$(ProjectDir)Debug\$(TargetName).hex”:i

cambia COM4 por tu COM correcto. Si no te funcionase, prueba sin comillas, así:

-C Ruta_de_tu_Arduino\hardware\tools\avr\etc\avrdude.conf -patmega328p -carduino -P\\.\COM4 -b115200 -Uflash:w:$(ProjectDir)Debug\$(TargetName).hex:i

si aun así tampoco te fuese, prueba a sacar el -C.

Muy importante, seleccionar la opción Use Output Window, nos ayudará a poder ver los mensajes por la " output " inferior de la IDE de Atmel




Una vez hecho eso aceptamos y creamos un nuevo proyecto ( para probar que todo salió bien ). Damos clic en File -> new -> sketch project.





Nos pedirá un nombre, yo puse " Prueba_001 "







Yo escribí el típico código de " blink ". Una vez escrito, vamos a la pestaña " build " y hacemos clic en "build solution"  ( o F7 en su defecto ).





Una vez hecho eso, damos clic en  " Project "  --> " Upload last sketch build "






Si queréis numerar las líneas de código ( algo muy útil cuando da errores) tenéis que ir a:  tools -> options -> text editor -> All languages -> General y ahí buscar en el apartado " Display " y seleccionar " Line numbers "






Esto es todo por ahora, practicad con este editor que es una maravilla!




+info
-