Presentación de un proyecto con SlideShare

Una forma fácil de presentar un proyecto en internet, es con herramientas como SlideShare.

Esta herramienta nos permite subir presentaciones de power point,open office, pdfs, etc. y de una manera simple, incrustarla en cualquier entrada de un blog.

Un ejemplo, Proyecto de Radio FM presentado por los alumnos: Jose Luis Reyes y Diego Sánchez

Espero que esto sea de utilidad

Visitas: [WPeCounter]

Presentación de un proyecto con SlideShare

Proyecto Gutenberg 3D

Primera reunión presencial de coordinación del proyecto Gutenberg 3D en el I.E.S. Juan de la Cierva (Madrid)

La jornada de la mañana se destinó al curso de montaje de impresoras 3D, con la participación del profesorado de los diferentes centros que integrán el proyecto.

https://photos.gstatic.com/media/slideshow.swf

En la tarde se finalizó el montaje de las impresoras y se realizó la reunión de coordinación en la que se trataron los siguientes temas:

1.- Valoración del curso de Montaje de impresión 3D.

2.- Información sobre el evento 3D print Show. (más información en http://granabot.es/3d-printshow/)

3.- Reparto de certificados de asistencia a los participantes de los eventos realizados en Madrid.

4.- Realización de compras centralidadas.

5.-Curso de Android.

6.- Actividades programadas por los centros:

6.1 Robolot: 18 y 19 de abril de 2015.

6.2 Malakabot 7 de mayo de 2015: Se pantea que sea esta actividad la referencia del Proyecto y que asistan todos los centros con participación de alumnado.

6.3 DB-Sariak 15 de mayo de 2015: no está todavía concretada la propuesta

6.4 Maker-fest: No está concretadas las actividades ni las fechas de realización. Está planteada como una propuesta.

Visitas: [WPeCounter]

Proyecto Gutenberg 3D

Proyectos Mantenimiento Electrónico Curso 2014-15

Durante el curso 2014/15 los alumnos de Formación Profesional de Grado Superior de Mantenimiento Electrónico, del I.E.S. Virgen de las Nieves (Granada) han desarrollado los siguientes proyectos:

[padlet key=’57t3uafqg81b’ width=’100%’ height=’480′]

 

1.- Iluminación ambiental mediante LEDs RGB de potencia.

2.- Maqueta simulación movimientos sísmicos

3.- Adquisición de datos: Robot recorre tuberías.

4.- Impresora 3D-Fresadora (con cabezal intercambiable).

5.- Maqueta de aerogenerador marino.

6.- Receptor de radio FM- Mp3.

7.- Desarrollo de juguete electrónico empleando pantalla gráfica a color.

8.- Gestor de sueño.

9.- Central de Alarma electrónica.

10.- Globo sonda. Medida de datos atmosféricos.

 

Para comprender el alcance de cada uno de vuestros proyectos, os sugiero que en cada índice de vuestro proyecto incluyáis una línea de tiempo en la que expliquéis por todas las fases, etapas, etc por la que ha ido evolucionando vuestro proyecto.

 

A modo de ejemplo aquí os dejo una línea de tiempo:

 

Para el presupuesto del proyecto podéis utilizar infogr.am (o para representar gráficas de resultados obtenidos).

Un ejemplo de presupuesto creado con esta herramienta:

Visitas: [WPeCounter]

Proyectos Mantenimiento Electrónico Curso 2014-15

Juego de la Serpiente con Arduino Nano, pantalla gráfica Nokia 5110 y WiiChuck

En primer lugar veremos como utilizar un wiichuck.

Internamente tiene un acelerómetro de 3 ejes (X,Y,Z), un joystick de dos ejes (x,y) y dos pulsadores (C y Z)

dibujoaxis

El diagrama de conexión es el siguiente

nunchuck_plug1

Utilizaremos un adaptador para la conexión del wiichuck con arduino.

nunchuck_adapter

 

La comunicación entre el wiichuck y arduino se establece por el bus I2C. Para ello utilizaremos las entradas A5(SCL->Clock) y A4 (SDA->Data) de nuestro arduino Nano

nano_pins

para verificar el funcionamiento del wiichuck utilizamos la librería  WiiChuck y el siguiente código, que permite ver por el puerto serie los valores de los diferentes elementos:

#include "Wire.h"       //Libreria I2C
#include "WiiChuck.h"   //Libreria WiiChuck
 
WiiChuck chuck = WiiChuck();  //Instancia de WiiChuck
 
void setup()
{
Serial.begin(9600);    //Iniciamos comunicacion serie
chuck.begin();         //Iniciamos WiiChuck
}
 
void loop()
{
chuck.update();        //Actualizamos los valores y los imprimimos por pantalla.
Serial.println("-----------------------");
Serial.print("Eje X: "); Serial.print((int)chuck.readAccelX()); Serial.println();
Serial.print("Eje Y: "); Serial.print((int)chuck.readAccelY()); Serial.println();
Serial.print("Eje Z: "); Serial.print((int)chuck.readAccelZ()); Serial.println();
Serial.println();
Serial.print("Joystick X: "); Serial.print((int)chuck.readJoyX()); Serial.println();
Serial.print("Joystick Y: "); Serial.print((int)chuck.readJoyY()); Serial.println();
Serial.println();
Serial.print("Boton Z: "); Serial.print((int)chuck.zPressed()); Serial.println();
Serial.print("Boton C: "); Serial.print((int)chuck.cPressed()); Serial.println();
Serial.println();
Serial.println("-----------------------");
delay(2000);
}

Compilando y cargado el código en arduino, ejecutamos el terminal del puerto serie obtenemos:

terminal_serie_acelerometro
De los valores leidos establecemos los umbrales de los movimientos (izquierda, derecha, arriba y abajo)
Diagrama de los elementos hardware del montaje:

https://www.mindomo.com/mindmap/412246efaad84f3ba807d731f68a7236

La conexión de la pantalla LCD 84×48 (Nokia 5110) y Arduino Nano la haremos según la siguiente asignación de terminales a patillas. Podéis ver el detalle de control de la pantalla en el post: Pantalla Gráfica LCD Nokia 5110, 3110 (84 x 48 píxeles)

pin 2 – light
pin 3 – Vcc
pin 4 – Serial clock out (SCLK)
pin 5 – Serial data out (DIN)
pin 6 – Data/Command select (D/C)
pin 7 – LCD chip select (CS)
pin 8 – LCD reset (RST)

 

Ahora toca modificar el código del juego de la serpiente (Snake Game by Abhinav Faujdar) para agregarle algunas pantallas de información, control de los movimientos con el wiichuck (joystick x,y) y el pulsador Z para pausar el juego durante 5 segundos.

 

/************ Snake Game by Abhinav Faujdar ***************/
/* Adaptado para Arduino Nano y WiiChuck Gerardo González */
#include <Wire.h>               //Libreria I2C
#include <WiiChuck.h>           //Libreria WiiChuck
#include <EEPROM.h>             //Librería EEPROM
#include <SPI.h>                //Librería Serial Peripheral Interface
#include <Adafruit_GFX.h>       //Librería Gráficos
#include <Adafruit_PCD8544.h>   //Librería LCD 84x48 Nokia 5110
#define Vcc 3
#define Light 2
// Software SPI (slower updates, more flexible pin options):
// pin 2 - light
// pin 3 - Vcc
// pin 4 - Serial clock out (SCLK)
// pin 5 - Serial data out (DIN)
// pin 6 - Data/Command select (D/C)
// pin 7 - LCD chip select (CS)
// pin 8 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(4, 5, 6, 7, 8); //instancia pantalla 5110
WiiChuck chuck = WiiChuck();  //Instancia de WiiChuck
//Vcc    ->  +3.3
//Data   ->  SDA  -> A4
//Clock  ->  SDL  -> A5
//GND    ->  GND
/********* constants *******/
#define MAX_WIDTH 84        //display 84x48
#define MAX_HEIGHT 48
#define speakerPin 13
#define slength_ini 8

boolean dl = false, dr = false, du = false, dd = false; // to check in which direction the snake is currently moving
int x[200], y[200], i, slength, tempx = 10, tempy = 10, xx, yy;
unsigned int high;
uint8_t bh, bl;
int xegg, yegg;
int freq, tb;
int l, r, u, d, p;
unsigned long time = 280, beeptime = 50;
int score = 0, flag = 0;

void setup()
{
  // Inicializa EEPROM High score
  //High score ini 0
  //EEPROM.write(1,0);
  //EEPROM.write(0,0);
  //
  chuck.begin();         //Iniciamos WiiChuck
  // Inicializa pantalla 5110
  pinMode(Light, OUTPUT);
  pinMode(Vcc, OUTPUT);
  digitalWrite(Vcc, HIGH);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(Light, LOW);   // turn the LED on (HIGH is the voltage level)
  display.begin();
  display.clearDisplay();
  pinMode(speakerPin, OUTPUT); //Buzzer pin
 
  display.setContrast(25);
  slength = slength_ini;               //Start with snake length 2
  xegg = (display.width()) / 2;
  yegg = (display.height()) / 2;
  display.setTextSize(2);          //Initial Display
  display.setTextColor(BLACK);
  display.setCursor(10, 4);
  display.print("Snake");
  display.setTextSize(1);
  display.setCursor(6, 26);
  display.print("Gerardo Glez");
  display.setCursor(8, 40);
  display.print("granabot.es");
  display.display();
  delay(4000);
  bh = EEPROM.read(1); //Lectura de High score
  bl = EEPROM.read(0);
  high = (((0xff00 + bh) << 8) + bl);
  display_game_over();
  for (i = 0; i <= slength; i++) //Set starting coordinates of snake
  {
    x[i] = 25 - 3 * i;
    y[i] = 10;
  }
  display.drawCircle(x[0], y[0], 1, BLACK);
  for (i = 1; i < slength; i++)  //Draw the snake
  {
    display.drawCircle(x[i], y[i], 1, BLACK);
  }
  display.display();
  dr = true;  //Going to move right initially
}
//Movement Begins after here
void loop()
{
  movesnake();    //This is called endlessly
}
void movesnake()
{
  chuck.update();
  l =(chuck.readJoyX()<-50)?LOW:HIGH;
  r =(chuck.readJoyX()>50)?LOW:HIGH;
  d =(chuck.readJoyY()<-50)?LOW:HIGH;
  u =(chuck.readJoyY()>50)?LOW:HIGH;
  p=((int)chuck.zPressed()==1)?LOW:HIGH;
  if (flag == 0)
  {
    direct();    //When key is pressed,this will change the coordinates accordingly and set flag to 1
    //flag would be set to 1 so that direction is not changed multiple times in a short duration
  }
  if (millis() % time == 0) //this condition becomes true after every 'time' milliseconds...millis() returns the time since launch of program
  {
    if (flag == 0)                                //flag 0 means no directional key has been pressed in the last 'time' milliseconds
    {
      if (dr == true) {
        tempx = x[0] + 3;  // so the snake moves one step in the direction it is moving currently
        tempy = y[0];
      }
      if (dl == true) {
        tempx = x[0] - 3;  //The new coordinates of head of snake goes in tempx,tempy
        tempy = y[0];
      }
      if (du == true) {
        tempy = y[0] - 3;
        tempx = x[0];
      }
      if (dd == true) {
        tempy = y[0] + 3;
        tempx = x[0];
      }
    }
    flag = 0;
    checkgame();                              //Check if snake has met egg or coincided with itself
    checkegg();
    if (tempx <= 0) {
      tempx = MAX_WIDTH + tempx; //If the new coordinates are out of screen, set them accordingly
    }
    if (tempx >= MAX_WIDTH) {
      tempx = tempx - MAX_WIDTH;
    }
    if (tempy <= 0) {
      tempy = MAX_HEIGHT + tempy;
    }
    if (tempy >= MAX_HEIGHT) {
      tempy = tempy - MAX_HEIGHT;
    }
    for (i = 0; i <= slength; i++) //Change the coordinates of all points of snake
    {
      xx = x[i];
      yy = y[i];
      x[i] = tempx;
      y[i] = tempy;
      tempx = xx;
      tempy = yy;
    }
    drawsnake();           //Draw the snake and egg at the new coordinates
  }
}
void checkgame()       //Game over checker
{
  for (i = 1; i < slength; i++)        //Checking if the coordinates of head have become equal to one of the non head points of snake
  {
    if (x[i] == x[0] && y[i] == y[0])
    {
      bh = EEPROM.read(1);
      bl = EEPROM.read(0);
      high = (((0xff00 + bh) << 8) + bl);
      if (score > high)
      {
        high = score;
        bh = (high >> 8);
        bl = high & 0xff;
        EEPROM.write(1, bh);
        EEPROM.write(0, bl);
      }
      display_game_over();
      display_count_down();
      redraw();              //Restart game by drawing snake with the resetted length and score
    }
  }
}
void checkegg()      //Snake meets egg
{
  if (x[0] == xegg or x[0] == (xegg + 1) or x[0] == (xegg + 2) or x[0] == (xegg - 1)) //Snake in close vicinity of egg
  {
    if (y[0] == yegg or y[0] == (yegg + 1) or y[0] == (yegg + 2) or y[0] == (yegg - 1))
    {
      score += 1;                     //Increase length,score and increase movement speed by decreasing 'time'
      slength += 1;
      if (time >= 90)
      {
        time -= 20;
      }
      display.fillRect(xegg, yegg, 3, 3, WHITE);  //Delete the consumed egg
      display.display();
      beep(35, beeptime);             //Beep with a sound of 35Hz for 'beeptime' ms
      xegg = random(1, MAX_WIDTH - 2);         //Create New egg randomly
      yegg = random(1, MAX_HEIGHT - 2);
      redraw();
    }
  }
}
void direct()                  //Check if user pressed any keys and change direction if so
{
  if (l == LOW and dr == false)  //when key LEFT is pressed ,L will become low
  {
    dl = true; du = false; dd = false;
    tempx = x[0] - 3;            //Save the new coordinates of head in tempx,tempy
    tempy = y[0];
    flag = 1;                   //Do not change direction any further for the ongoing 'time' milliseconds
  }
  else if (r == LOW and dl == false)
  {
    dr = true; du = false; dd = false;
    tempx = x[0] + 3;
    tempy = y[0];
    flag = 1;
  }
  else if (u == LOW and dd == false)
  {
    du = true; dl = false; dr = false;
    tempy = y[0] - 3;
    tempx = x[0];
    flag = 1;
  }
  else if (d == LOW and du == false)
  {
    dd = true; dl = false; dr = false;
    tempy = y[0] + 3;
    tempx = x[0];
    flag = 1;
  }
  else if (p == LOW)            //Pause game for 5 seconds
  {
    display_count_down();
    redraw(); 
  }
}
void drawsnake()        //Draw snake and egg at newly changed positions
{
  display.fillRect(xegg, yegg, 3, 3, BLACK);   //Draw egg at new pos
  display.drawCircle(x[0], y[0], 1, BLACK);    //Draw new head of snake
  display.drawCircle(x[slength], y[slength], 1, WHITE); //Delete old tail of snake
  display.display();
}
void redraw()   //Redraw ALL POINTS of snake and egg
{
  display.fillRect(xegg, yegg, 3, 3, BLACK);
  for (i = 0; i < slength; i++) {
    display.drawCircle(x[i], y[i], 1, BLACK);
  }
  display.display();
}
void beep (int freq, long tb)          //This function creates a sound of frequency 'freq' Hz and for a duration of 'tb' milliseconds
{
  int x;
  long delayAmount = (long)(500 / freq);     //Calculate time duration of half cycle
  long loopTime = (long)(tb / (delayAmount * 2)); //Calculate no. of cycles
  for (x = 0; x < loopTime; x++) 	 // One iteration produces sound for one cycle
  {
    digitalWrite(speakerPin, HIGH);  //High for half cycle
    delay(delayAmount);
    digitalWrite(speakerPin, LOW);   //Low for half cycle
    delay(delayAmount);
  }
  delay(2);    //a little delay to make all notes sound separate
}
void display_count_down(){
  int xm = (display.width()) / 2;
  int ym = (display.height()) / 2;
  for (int i = 5; i >= 1; i--) {
    display.clearDisplay();
    for (int j = 1; j <= 10; j++) {
      display.drawCircle(xm, ym, ym - 20 + 5 * j, BLACK);
    }
    display.setTextColor(BLACK);
    display.setTextSize(6);
    display.setCursor(28, 3);
    display.print(i);
    display.display();
    beep(20, 1000);
  }
  display.clearDisplay();
  display.setTextSize(4);
  display.setCursor(10, 12);
  display.print("Go!");
  display.display();
  beep(20, 500);
  display.clearDisplay();
}
void display_game_over() {
  display.clearDisplay();
  display.setTextColor(BLACK);
  display.setTextSize(1);
  display.setCursor(15, 3);
  display.print("Game Over");
  display.setCursor(15, 15);
  display.print("Score: ");
  display.print(score);
  display.setCursor(15, 25);
  display.print("High: ");
  display.print(high);
  display.display();
  delay(4000);
  display.clearDisplay();
  slength = slength_ini;            //Resetting the values
  score = 0;
  time = 280;
}

 

Para finalizar, una pequeña demostración del juego:

 

 

Visitas: [WPeCounter]

Juego de la Serpiente con Arduino Nano, pantalla gráfica Nokia 5110 y WiiChuck

3D PRINTSHOW

El próximo 13 y 14 de Marzo se celebra en el palacio de Cibeles de Madrid la feria 3D PRINTSHOW.

 

3d_print_show

 

El programa de actividades es el siguiente:

 

Time Madrid, Marzo 12 Madrid, March 12
08:00 – 09:00 Café matinal y networking para ponentes y expositores Speaker & Exhibitor Networking Coffee
09:00 – 18:00 Conferencia de un día: Empresas All-Day Conference: Business
09:30 – 18:00 Mostrar abierta Showfloor Open
09:30 – 12:30 Sesión para especialistas (mañana): Recién llegados Specialist Session (Morning): Newcomer
13:00 – 14:00 Conferencia de un día: Sesión de networking All-Day Conference: Networking Session
14:00 – 17:00 Sesión para especialistas (tarde): Software Specialist Session (Afternoon): Software
18:00 – 19:30 Refrigerio para titulares del Pase VIP y del Pase Conferencia de un día VIP Pass: Networking Drinks
19:30 – 21:00 Bebidas para expositores Exhibitor Drinks

 

 

 

Time Madrid, 13 de Marzo Madrid, March 13
08:00 – 09:00 Pausa de café para entablar contactos entre ponentes y expositores Speaker & Exhibitor Networking Coffee
09:00 – 18:00 Conferencia de un día: Empresas All-Day Conference: Business
09:30 – 18:00 Moestra abierta Showfloor Open
09:30 – 12:30 Sesión para especialistas (mañana): Educación Specialist Session (Morning): Education
13:00 – 14:00 Conferencia de un día: Sesión para entablar de contactos All-Day Conference: Networking Session
14:00 – 17:00 Sesión para especialistas (tarde): Arte Specialist Session (Afternoon): Art

 

 

3D PRINTSHOW

Polarización de diodos LED

[latexpage]

Físicamente el modelado del diodo LED es complejo, os dejo apuntes de la Universidad de Valencia para que veáis el proceso:

 

https://www.yumpu.com/es/embed/view/OFCeczCOSYuXbmxq

 

Aunque la polarización del LED parece tarea fácil hay que tener presente algunos conceptos teóricos:

El modelo matemático más empleado para modelar la característica I-V de cualquier tipo de diodo es la ecuación de Shockley (en honor a William Bradford Shockley) que permite aproximar el comportamiento del diodo en la mayoría de las aplicaciones. La ecuación que liga la intensidad de corriente y la diferencia de potencial es:

$I_{d}=I_{S} left( e^{V_{D}/(n V_{T})}-1 right)$

Donde:

  • $I_{d}$ es la intensidad de la corriente que atraviesa el diodo
  • $V_{D}$ es la diferencia de tensión entre los extremos del dido
  • $I_{S}$ es la corriente de saturación inversa (aproximadamente $10^{-12}$ $A$)
  • $n$ es el coeficiente de emisión, dependiente del proceso de fabricación del diodo y que suele adoptar valores entre 1 (para el germanio) y del orden de 2 (para el silicio)
  • $V_{T}$ es el Voltaje térmico (aproximadamente 25.85mV en 300K), una temperatura cercana a la temperatura ambiente, muy usada en los programas de simulación de circuitos. Para cada temperatura existe una constante conocida definida por:

$V_{T} = frac{k T}{q}$

Donde $k$ es la constante de Boltzmann, $T$ es la temperatura absoluta de la unión pn, y $q$ es la magnitud de la carga de un electrón

La representación gráfica de esta ecuación es:

Diodo_-_curva_característica_(Sockley)
Como podemos observar, la relación entre la corriente y la tensión aplicada al diodo guarda una relación de tipo exponencial.

Analizemos las opciones de polarización de un diodo suponiendo que estamos en polarización directa:

 

1. Polarizar el diodo con una tensión constante.

Si polarizamos al diodo con una fuente de tensión, la corriente que circula guarda una relación exponencial con la tensión aplicada.

Cualquier cambio en la tensión provocará un aumento o disminución exponencial en la corriente que circula por el diodo.

Veamos un ejemplo: un diodo polarizado en directa a $V_{d}=0.7V$

 

$I_{d}=10^{-14} left( e^{0.7/(0.02585)}-1 right) = 5.76mA$

 

con una variación de sólo el 10% en la tensión de polarización 0.77V obtenemos una nueva corriente de:

 

$I_{d}=10^{-14} left( e^{0.77/(0.02585)}-1 right) = 86.46mA$

 

Esto supone un cambio en la corriente de salida de 1400%!

 

2. Polarizar el diodo con una corriente constante.

Si la corriente que polariza el diodo es constante, la diferencia de potencial entre sus extremos será constante. Un cambio en la corriente de polarización del diodo provocará un cambio logaritmico en la tensión de polarización del mismo. El logaritmo tiene una variación prácticamente lineal (si las variaciones son pequeñas).

 

Sigamos con el ejemplo. Ahora el diodo está polarizado con una corriente de 5.76mA, en sus extremos habrá una tensión de 0.7V. si la corriente varía un 10% ¿Cuanto variará la tensión?

La nueva corriente será: Id=6.34mA, para esta corriente la tensión del diodo la podemos calcular:

$V_{D}= V_{T}·ln(I_{d}/I_{s}-1)$

sustituyendo valores se obtiene una tensión de 0.88 V. Esto supone una subida respecto al anterior valor de sólo el 25%.

 

Por ese motivo lo más lógico es polarizar al diodo mediante una fuente de corriente.  Además la intensidad luminosa deseada de un LED es función directa de la corriente que circula por el mismo.

Partiendo de una fuente de tensión, podemos obtener una fuente de corriente, simplemente poniendo una resistencia en serie. (Véase Teorema de Thevening y Norton). Esta resistencia en serie actúa como resistencia limitadora de corriente.

 

diodo_r

 

Características reales proporcionadas por los fabricantes y método de cálculo de la resistencia limitadora

En la siguiente notas de aplicación de HP,  encontramos que los diodos led no son elementos que se deban utilizar de forma aislada, y que precisan de como mínimo una resistencia limitadora de corriente. También encontramos sus principales características y la denominada curva de seguridad, delimitada por la Potencia Máxima disipada del LED.

 

[gview file=”http://granabot.es/wp-content/uploads/2015/02/an1005.pdf”%5D

 

En la siguiente nota de aplicación de HP, trata sobre la reducción del número de horas de vida, cuando el LED es sometido a pulsos de alta corriente.

[gview file=”http://granabot.es/wp-content/uploads/2015/02/abi024.pdf”%5D

 

Conclusión: Siempre que utilicéis un diodo LED lo más recomendable es colocar en serie con el mismo una resistencia limitadora de corriente (ya sea con una tensión continua o con pulsos de tensión)

La ecuación para calcular esta resistencia limitadora es:

$R=frac{V_{CC}-V_{SAT}-V_{F}}{I_{F}}$

 

Visitas: [WPeCounter]

Polarización de diodos LED

Pantalla Gráfica LCD Nokia 5110, 3110 (84 x 48 píxeles) controlada con arduino nano

La pequeña pantalla gráfica LCD de Nokia 5110 y 3110 está montada sobre un PCB de 45mm x 45mm, tiene una resolución de 84 x 48 píxeles sobre la que podemos dibujar gráficos o textos.

La comunicación entre Arduino y la pantalla LCD es de tipo SPI, por lo que podemos controlarla con muy pocos pines y si además utilizamos las librerías desarrolladas por Adafruit hacer que la pantalla muestre gráficos o textos resulta sumamente sencillo.

Tiene 4 leds blancos para iluminar la pantalla, por lo que se puede utilizar en condiciones de poca o ninguna luz.

El módulo LCD está basado en el controlador PCD8544

https://www.yumpu.com/en/embed/view/E1v4jghCIDS2VbMm

 

Para manejar esta LCD se utilizan dos librerías:

  1. Librería PCD8544 desarrollada por Adafruit.
  2. Librería GFX de Adafruit. Contiene los métodos para dibujar circulos, rectángulos, líneas y puntos, además de textos.

 

La asignación de patillas del módulo se pueden ver en la siguiente imagen:
n5110_2

 

Para probar el funcionamiento utilizaré dos Joystick analógicos de dos ejes y pulsador
joy

 

Con el montaje que se muestra acontinuación:
n5110

El código que he utilizado es muy simple:

/* 
Ejemplo de utilización de una pantalla de nokia 5110 con arduino Nano
*/
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

#define Vcc 3
#define Light 2

#define pinX 6
#define pinY 7
#define sw 12

#define pinX2 4
#define pinY2 5
#define sw2 11

// Software SPI (slower updates, more flexible pin options):
// pin 2 light
// pin 3 Vcc
// pin 4 - Serial clock out (SCLK)
// pin 5 - Serial data out (DIN)
// pin 6 - Data/Command select (D/C)
// pin 7 - LCD chip select (CS)
// pin 8 - LCD reset (RST)

Adafruit_PCD8544 display = Adafruit_PCD8544(4, 5, 6, 7, 8);
// Configuración
void setup()   {
  pinMode(Light, OUTPUT);
  pinMode(Vcc, OUTPUT);
  pinMode(sw, INPUT_PULLUP);
  pinMode(sw2, INPUT_PULLUP);
  digitalWrite(Vcc, HIGH);   // turn the LED on (HIGH is the voltage level)
  
  display.begin();
  display.setContrast(50);
  display.display(); // show splashscreen
  display.clearDisplay();   // clears the screen and buffer
}
void loop() {
     int xp= map(analogRead(pinX), 0, 1023, 40, -40);
     int yp= map(analogRead(pinY), 0, 1023, -20, 20);
    
     int xp2= map(analogRead(pinX2), 0, 1023, 40, -40);
     int yp2= map(analogRead(pinY2), 0, 1023, -20, 20);
   
    display.clearDisplay();      
    int s=digitalRead(sw);
    if (s == LOW) {
        display.fillCircle(display.width()/2+xp, display.height()/2+yp, 10, BLACK);
     }
    else {
        display.fillCircle(display.width()/2+xp, display.height()/2+yp, 3, BLACK);
    }
    int s2=digitalRead(sw2);
    if (s2 == LOW) {
      display.fillCircle(display.width()/2+xp2, display.height()/2+yp2, 6, BLACK);
     }
    else {
      display.fillCircle(display.width()/2+xp2, display.height()/2+yp2, 4, BLACK);
    }
    
    digitalWrite(Light, HIGH);
    if (abs(xp-xp2)<3){
      if(abs(yp-yp2)<3){
        digitalWrite(Light, LOW);
       } 
      }
    display.display();
}

¿Sabrías qué hace el código?

 

Visitas: [WPeCounter]

Pantalla Gráfica LCD Nokia 5110, 3110 (84 x 48 píxeles) controlada con arduino nano

Plugins instalados en WordPress

[latexpage]
Recientemente he instalado algunos plugins en WordPress y os comento la forma de uso:

  • JW player
  • WPeCounter
  • WP QuickLaTeX

 

1. JW player


Es un reproductor multimedia para wordpress. Nos permite incrustrar audios y videos subidos directamente al servidor de granabot.

Desde la ventana de edición de entrada: pulsa el  botón “Añadir Objeto” , verás que aparece la opción de Insert JWP PlayList.

 

Un ejemplo de utilización de este reproductor lo encuentras en este post

 

2. WPeCounter


Es un contador de visitas de cada página y entrada del blog.
Si quieres mostrar el número de visitas que tiene una entrada debes incluir por ejemplo al final de la entrada el siguiente código

Visitas: [WPeCounter]

Cuando estés en la ventana de edición de WordPress (todas las entradas), verás que se ha incorporado una columna en la que se visualizan el número de visitas (desde la fecha en la que se hizo la instalación del plugin)

 

3. WP QuickLaTeX


Es un editor latex para WordPress. Lo puedes utilizar por ejemplo si quieres incluir ecuaciones en formato latex en las entradas. Para utilizar este plugin agrega al principio de la entrada el siguiente código:

 

[latexpage]

 

Puedes utilizar un editor de ecuaciones Latex online para posteriormente incluir una ecuación en tu entrada.
por ejemplo con el código:

 

$f(x)=displaystyleint_{-infty}^x e^{-t^2}dt$

 

Visualizarás la siguiente ecuación:

 

$f(x)=displaystyleint_{-infty}^x e^{-t^2}dt$

 

Visitas: [WPeCounter]

Plugins instalados en WordPress

Tiempo de Conversión A/D de Arduino

[latexpage]

Un conversor analógico-digital es un dispositivo electrónico capaz de convertir una señal analógica en un valor binario, en otras palabras, éste se encarga de transformar señales analógicas a digitales (0 y 1).

El dispositivo establece una relación entre su entrada (señal analógica) y su salida (digital) dependiendo de su resolución. La resolución determina la precisión con la que se reproduce la señal original.

 

Esta resolución se pude saber, siempre y cuando conozcamos el valor máximo de la entrada a convertir y la cantidad máxima de la salida en dígitos binarios.

$Resolucion = frac{+Vref}{2^n}$

(donde $n$ son bits)

 

Por ejemplo, un conversor A/D de 8-bits puede convertir valores que van desde 0V hasta el voltaje de referencia ($Vref$) y su resolución será de: $Resolucion = frac{+Vref}{256}$. Lo que quiere decir que mapeará los valores de voltaje de entrada, entre 0 y Vref voltios, a valores enteros comprendidos entre 0 y 255 ($2^{n-1}$).

 

La tarjeta Arduino utiliza un conversor A/D de 10-bits, así que: Resolución = Vref/1024 Mapeará los valores de voltaje de entrada, entre 0 y $Vref$ voltios, a valores enteros comprendidos entre 0 y 1023 ($2^{n-1}$). Con otras palabras, esto quiere decir que nuestros sensores analógicos están caracterizados con un valor comprendido entre 0 y 1023. (Ver analogRead()).

 

Si Vref es igual a 5v, la resolución es aproximadamente de 5 milivoltios. Por lo tanto el error en las medidas de voltaje será siempre de sólo 5 milivoltios.

 

Otro parámetro fundamental de la conversión A/D es el tiempo de conversión. Este valor nos determinará la frecuencia máxima de muestreo que podemos establecer.

 

En las hojas de caracteristicas del microcontrolador encontramos que este valor es de 100 microsegundos, lo que establece una frecuencia máxima de muestreo de 10Khz.

 

La pregunta que me planteo ¿podemos hacer una medida del tiempo de conversión con arduino?.

El código que he utilizado para este fin es el siguiente:

unsigned long tini;
unsigned long tbucle;
unsigned long ttotal;
unsigned long tdummy;
int i=0;
int val=0;
void setup() {
  Serial.begin(9600);
  Serial.println("Comenzamos!");
}
void loop() {
  i++;
  Serial.print("Medida ");
  Serial.print(i);
  Serial.print(":t");
  tini = millis();
 
  tdummy=millis();
  for(unsigned long int i=0;i<10000;i++){
  }
  tbucle=millis();
  
  for(unsigned long int i=0;i<10000;i++){
    al=analogRead(A2);
  }
  ttotal=millis();
  
  Serial.print((float)(ttotal-tbucle-(tbucle-tini))/10.00);
  Serial.println(" uS");
}

Los tiempos obtenidos son:
tiempos_serie

 

En este ejemplo he medido el tiempo de ejecución de una instrucción. Puedes utilizar este procedimiento para verificar los tiempos que tardan en ejecutarse las funciones, rutinas , etc de los programas que estéis realizando. Esto te permitirá saber si tienes alguna rutina que relentiza la ejecución de tu aplicación y si es posible buscar una solución.

¿A qué se debe la diferencia de tiempo?¿Podríamos determinar el tiempo de conversión de manera más precisa?

Visitas: [WPeCounter]

Tiempo de Conversión A/D de Arduino