Mostrando entradas con la etiqueta hardware. Mostrar todas las entradas

4/28/2015

Cómo cambiar la fuente de alimentación de un PC por una nueva

http://www.ajpdsoft.com Cómo cambiar la fuente de alimentación de un PC por una nueva. Mostramos en este videotutorial cómo quitar una fuente de alimentación de un equipo informático (PC de sobremesa) que esté averiada o estropeada y cómo sustituirla por una nueva fuente de alimentación.
Changing the power of a PC with a new one . We show in this video tutorial how to remove a power supply of a computer ( desktop PC ) that is damaged or broken and how to replace it with a new power supply

4/21/2015

Unboxing fuente alimentación silenciosa Tacens Valeo V de 700W

http://www.ajpdsoft.com Unboxing fuente alimentación silenciosa Tacens Valeo V de 700W

1/23/2014

Cómo actualizar el firmware de la cámara GoPro Hero3 Black Edition

9/13/2013

Montar PC desde cero con todos los componentes RAM CPU HD, arranque Windows en 6 segundos

PC arrancando Windows 7 en 6 segundos

1/11/2013

Cómo ampliar la memoria RAM de un portátil

11/19/2012

Conectar pantalla LCD a Arduino UNO e interactuar con ella, mostrar temperatura

Explicamos en este tutorial cómo conectar una pantalla LCD a Arduino UNO. Mostramos varios ejemplos de código para interacturar con los botones del shield LCD (keypad) de la pantalla LCD para movernos por los menús. Explicamos también cómo cambiar la luminosidad de la pantalla LCD (intensidad de la retroiluminación) desde el menú (con los keypad) y cómo conectar un sensor de temperatura y mostrarla en la pantalla LCD.

Cómo conectar display LCD Keypad Shield a Arduino UNO

En este tutorial explicaremos y mostraremos ejemplos para trabajar con una pantalla LCD (display LCD Keypad Shield) conectada a Arduino. Para ello necesitaremos una pantalla LCD (Display LCD Keypad Shield), en concreto usaremos un Arduino LCD Keypad Shield 16x2 HD44780 con un coste aproximado de 18 euros:

Por supuesto necesitaremos un Arduino UNO, en el siguiente tutorial explicamos cómo adquirirlo y cómo conectarlo al PC para transferir el programa:

Adquisición del hardware necesario: Arduino UNO, cable USB tipo A-B y LED.

Conectaremos el LCD a Arduino como mostramos en la imagen:

En el siguiente tutorial explicamos cómo descargar el software para realizar programas y enviarlos a Arduino, también explicamos cómo conectar Arduino a un PC para el envío de programas:

Conectar Arduino UNO a un PC con W7, instalar y configurar Arduino IDE.

Programa Arduino para mostrar texto en display LCD y contador que se va incrementando

Una vez conectado el display LCD a Arduino y conectado Arduino al PC por el puerto USB, desde el IDE de desarrollo de Arduino pegaremos el siguiente programa:

/*
 Ejemplo de uso de display LCD 16x2.  Usando la librería LiquidCrystal
 library compatible con el driver de Hitachi HD44780 driver 
*/

// incluimos la libreria LiquidCrystal
#include 

// inicializamos la librería con los numeros pins del interfaz
// cada LCD puede llevar sus propios numeros
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);

void setup() {
  // establecemos el numero de columnas y filas del display 
  lcd.begin(16, 2);
  // enviamos el mensaje a mostrar en el display
  lcd.print("www.ajpdsoft.com");
}

void loop() {
  // enviamos la posicion del cursor al display
  // (nota: la linea 1 es la segunda fila, empieza a contar en 0
  lcd.setCursor(0, 1);
  // mostramos el numero de segundos desde el inicio del programa
  lcd.print(millis()/1000);
}

Programa Arduino para mostrar texto en display LCD y contador que se va incrementando

Comprobaremos la sintaxis pulsando en "Verificar":

Si todo es correcto pulsaremos en el botón "Cargar" para enviar el programa a Arduino:

Si todo es correcto el programa quedará transferido a la memoria de Arduino y se iniciará, mostrando el texto indicando en el display LCD (en nuestro caso "www.ajpdsoft.com") y un contador de segundos en la segunda línea:

Programa Arduino para mostrar texto en scroll en display LCD

Un ejemplo de programa Arduino para mostrar un texto en movimiento en un display LCD:

// include the library code:
#include 

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);

void setup() {
  // set up the LCD's number of columns and rows: 
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("www.ajpdsoft.com");
  delay(1000);
}

void loop() {
  // scroll 13 positions (string length) to the left 
  // to move it offscreen left:
  for (int positionCounter = 0; positionCounter < 13; positionCounter++) {
    // scroll one position left:
    lcd.scrollDisplayLeft(); 
    // wait a bit:
    delay(150);
  }

  // scroll 29 positions (string length + display length) to the right
  // to move it offscreen right:
  for (int positionCounter = 0; positionCounter < 29; positionCounter++) {
    // scroll one position right:
    lcd.scrollDisplayRight(); 
    // wait a bit:
    delay(150);
  }
  
    // scroll 16 positions (display length + string length) to the left
    // to move it back to center:
  for (int positionCounter = 0; positionCounter < 16; positionCounter++) {
    // scroll one position left:
    lcd.scrollDisplayLeft(); 
    // wait a bit:
    delay(150);
  }
  
  // delay at the end of the full loop:
  delay(1000);
}

Programa Arduino para introducir texto en el LDC con las teclas de desplazamiento

Un ejemplo de programa Arduino para mostrar un texto en la primera línea de una pantalla LCD y en la segunda permite que el usuario introduzca un texto usando las teclas de desplazamiento del display LCD:

#include 

LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);

int adc_key_val[5] = {50, 200, 400, 600, 800 };
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
boolean luzEncendida=true;
boolean cursorActivo=false;
unsigned long time;
int x=0;
char caracterActual = 'A';

void setup()
{
  lcd.clear(); 
  lcd.begin(16, 2);
  lcd.setCursor(0,0); 
  lcd.print("www.ajpdsoft.com");
  time = millis();
  //  pinMode(10, OUTPUT);
}

void loop()
{
  if (millis()-time > 10000) {  // Si han pasado mas de 10 segundos apagamos la luz
    pinMode(10, OUTPUT);
    digitalWrite(10, LOW);
    luzEncendida=false;
  }
  if (millis()-time > 5000) {  // Si han pasado mas de 5 segundos apagamos el cursor
    lcd.noBlink();
    cursorActivo=false;
  } 

  adc_key_in = analogRead(0);    // Leemos el valor de la pulsacion
  key = get_key(adc_key_in);    // Obtenemos el boton pulsado

  if (key != oldkey)   // if keypress is detected
  {
    delay(50);  // Espera para evitar los rebotes de las pulsaciones
    adc_key_in = analogRead(0);    // Leemos el valor de la pulsacion
    key = get_key(adc_key_in);    // Obtenemos el boton pulsado
    if (key != oldkey)    
    {
      time = millis();  // TODO: falta la comprobacion de si se ha desbordado el tiempo
      if (!luzEncendida) {  // Al pulsar cualquier tecla encendemos la pantalla
        pinMode(10, INPUT);
        luzEncendida=true;
      } 
      else {  // si la pantalla esta encendida seguimos funcionando normalmente
        lcd.setCursor(x, 1);
        oldkey = key;
        if (key >=0){  // Si se ha pulsado cualquier tecla
          lcd.blink();  // Mostramos el cursor parpadeando
          cursorActivo=true;
        }
        if (key == 0){  // Se ha pulsado la tecla derecha
          x++;
          if (x>15) x=15;
          caracterActual='A';
        }
        if (key == 1) {  // Se ha pulsado la tecla arriba
          caracterActual++;
          if (caracterActual > 'Z') caracterActual='Z';
          lcd.write(caracterActual);
        }
        if (key == 2) {  // Se ha pulsado la tecla abajo
          caracterActual--;
          if (caracterActual < 'A') caracterActual='A';
          lcd.write(caracterActual);
        }
        if (key == 3) {  // Se ha pulsado la tecla izquierda
          x--;
          if (x<0) x=0;
          caracterActual='A';
        }
        if (key == 4){  // Se ha pulsado la tecla de seleccion
        }
        lcd.setCursor(x, 1);
      }
    }
  }
  delay(100);
}

// Convertimos el valor leido en analogico en un numero de boton pulsado
int get_key(unsigned int input)
{
  int k;

  for (k = 0; k < NUM_KEYS; k++)
  {
    if (input < adc_key_val[k])
    {
      return k;
    }
  }

  if (k >= NUM_KEYS)k = -1;  // Error en la lectura
  return k;
}

Programa Arduino para mostrar menús y submenús en display LCD

Un ejemplo de programa Arduino para mostrar un menú y sus submenús correspondientes en una pantalla LCD:

#include 

LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);

const int numeroDeMenus=5;
const int numeroMaximoDeSubmenus=4;

char tituloMenu[numeroDeMenus][16] = {
  "1  Menu 1    ",
  "2  Menu 2    ",               
  "3  Menu 3    ",
  "4  Menu 4    ",
  "5  Menu 5    " };
  
byte numeroDeSubmenus[numeroDeMenus] = {4,3,2,1,4};

char tituloSubmenu[numeroDeMenus][numeroMaximoDeSubmenus][16] = 
{
  "1.1 Submenu 1","1.2 Submenu 2","1.3 Submenu 3","1.4 Submenu 4",
  "2.1 Submenu 1","2.2 Submenu 2","2.3 Submenu 3","",
  "3.1 Submenu 1","3.2 Submenu 2","","",
  "4.1 Submenu 1","","","",
  "5.1 Submenu 1","5.2 Submenu 2","5.3 Submenu 3","5.4 Submenu 4"};

int adc_key_val[5] ={
  50, 200, 400, 600, 800 };
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
boolean luzEncendida=true;
boolean cursorActivo=false;
unsigned long time;
int x=0;
int y=0;

void setup()
{
  lcd.clear(); 
  lcd.begin(16, 2);
  lcd.setCursor(0,0); 
  lcd.print("www.ajpdsoft.com");
  lcd.setCursor(0,1); 
  lcd.print("Menu version 0.1");
  delay(5000);
  lcd.setCursor(0,0); 
  lcd.print("Muevase con las ");
  lcd.setCursor(0,1); 
  lcd.print("teclas direccion");
  delay(4000);
  lcd.clear();
  lcd.setCursor(0,0); 
  lcd.print("Menu principal");
  lcd.setCursor(0,1); 
  lcd.print(tituloMenu[x]);
  time = millis();
  //  pinMode(10, OUTPUT);
}

void loop()
{
  // Si han pasado mas de 10 segundos apagamos la luz
  if (millis()-time > 10000) {
    pinMode(10, OUTPUT);
    digitalWrite(10, LOW);
    luzEncendida=false;
  }
  // Si han pasado mas de 5 segundos apagamos el cursor
  if (millis()-time > 5000) {
    lcd.noBlink();
    cursorActivo=false;
  } 

  adc_key_in = analogRead(0);    // Leemos el valor de la pulsacion
  key = get_key(adc_key_in);    // Obtenemos el boton pulsado

  if (key != oldkey)   // if keypress is detected
  
    delay(50);  // Espera para evitar los rebotes de las pulsaciones
    adc_key_in = analogRead(0);    // Leemos el valor de la pulsacion
    key = get_key(adc_key_in);    // Obtenemos el boton pulsado
    if (key != oldkey)    
    {
      // TODO: falta la comprobacion de si se ha desbordado el tiempo
      time = millis();  
      if (!luzEncendida) {  // Al pulsar cualquier tecla encendemos la pantalla
        pinMode(10, INPUT);
        luzEncendida=true;
      } 
      else {  // si la pantalla esta encendida seguimos funcionando normalmente
        oldkey = key;
        if (key >=0){  // Si se ha pulsado cualquier tecla
          lcd.blink();  // Mostramos el cursor parpadeando
          cursorActivo=true;
        }
        if (key == 0){  // Se ha pulsado la tecla derecha
          x++;
          if (x>numeroDeMenus-1) x=numeroDeMenus-1;
          y=0;
        }
        if (key == 1) {  // Se ha pulsado la tecla arriba
          y++;
          if (y > numeroDeSubmenus[x]-1) y=numeroDeSubmenus[x]-1;
        }
        if (key == 2) {  // Se ha pulsado la tecla abajo
          y--;
          if (y < 0) y=0;
        }
        if (key == 3) {  // Se ha pulsado la tecla izquierda
          x--;
          if (x<0) x=0;
          y=0;
        }
        if (key == 4){  // Se ha pulsado la tecla de seleccion
        }
        lcd.clear();
        lcd.setCursor(0,0); 
        lcd.print(tituloMenu[x]);
        lcd.setCursor(0,1); 
        lcd.print(tituloSubmenu[x][y]);
      }
    }
  }
  delay(50);
}

// Convertimos el valor leido en analogico en un numero de boton pulsado
int get_key(unsigned int input)
{
  int k;

  for (k = 0; k < NUM_KEYS; k++)
  {
    if (input < adc_key_val[k])
    {
      return k;
    }
  }

  if (k >= NUM_KEYS)k = -1;  // Error en la lectura
  return k;
}

Programa Arduino para mostrar temperatura, opciones modificables, luminosidad en display LCD

Un ejemplo de programa Arduino para mostrar la temperatura de un habitáculo usando un sensor de temperatura (NTC o resistencia variable con la temperatura de coeficiente negativo) en una pantalla LCD Keypad Shield. El programa también permite modificar la luminosidad (intensidad de la retroiluminación) del display LCD, cambiar parámetros, guardar valores en memoria EEPROM, etc.

Para conectar el sensor de temperatura (NTC o resistencia variable con la temperatura de coeficiente negativo) se pueden seguir las intrucciones del siguiente tutorial:

Obtener temperatura con sensor SEN118A2B de cabeza de acero y Arduino.

Con la diferencia de que hemos conectado el sensor de temperatura a la entrada analógica 1 porque la 0 la usa el LCD.

El código del programa completo Arduino:

#include 
#include 
#define ThermistorPIN 1  // Analog Pin 1
#define NUM_KEYS 5

/*
  Circuito del dispaly LCD:
 * LCD RS pin to digital pin 8
 * LCD Enable pin to digital pin 9
 * LCD D4 pin to digital pin 4
 * LCD D5 pin to digital pin 5
 * LCD D6 pin to digital pin 6
 * LCD D7 pin to digital pin 7
 * LCD BL pin to digital pin 10
 * KEY pin to analogl pin 0
 *
 * Esquema del sensor de temperatura:
 *   [Ground] -- [10k-pad-resistor] -- | -- [10k thermistor] --[Vcc (5v)]
 *                                     |
 *                                Analog Pin 1
 */


LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);

const int numeroDeMenus=6;

char tituloMenu[numeroDeMenus][16] = {
  "Fijar Temp.: ",
  "Fijar Tiempo:",               
  "Kp:          ",
  "Kd:          ",
  "Ki:          ",
  "Intensidad:  " };

int adc_key_val[5] ={
  50, 200, 400, 600, 800 };
int adc_key_in;
int key=-1;
int oldkey=-1;
boolean luzEncendida=true;
boolean cursorActivo=false;
boolean enMenu=false;
unsigned long time;
unsigned long tiempoPID;
byte numeroLecturas=0;
int x=0;
int signo=0;
char temp[10];
int lecturas[100];
byte numeroLectura=0;
//int lectura=0;
int maximo, minimo, diferencia, t1, t2, t3;
byte consigna=25;
byte tiempo=1;
byte kp=1;
byte kd=1;
byte ki=1;
byte intensidad=10;


void setup()
{
  cargarConfig();
  pinMode(10, OUTPUT);
  analogWrite(10,intensidad*25);
  Serial.begin(9600); 
  lcd.clear(); 
  lcd.begin(16, 2);
  lcd.setCursor(0,0); 
  lcd.print("www.ajpdsoft.com");
  lcd.setCursor(0,1); 
  lcd.print("C.Ventanas v1.0 ");
  delay(2000);
  //  lcd.setCursor(0,0); 
  //  lcd.print("Muevase con las ");
  //  lcd.setCursor(0,1); 
  //  lcd.print("teclas direccion");
  //  delay(4000);
  lcd.clear();
  lcd.setCursor(0,0); 
  lcd.print("Temperatura:    ");
  lcd.setCursor(0,1);
  int lectura=getTemp(1);
  sprintf(temp, "%3d%c%1d%cC", lectura/100, '.', lectura/10%10,223);
  lcd.print(temp);
  time = millis();
  tiempoPID = millis();
}

void loop()
{
  int lectura = getTemp(ThermistorPIN);
  lecturas[numeroLectura++] = lectura;
  if (millis()-time > 20000) {  // Si han pasado mas de 20 segundos apagamos la luz
    digitalWrite(10, LOW);
    luzEncendida=false;
  }
  if (millis()-time > 7000) {  // Si han pasado mas de 7 segundos salimos del menu
    if (enMenu) guardarConfig();
    enMenu = false;
    x=0;
    time = millis();
    //  }
    //  if (!enMenu) {
    lcd.clear();
    lcd.setCursor(0,0); 
    lcd.print("Temperatura:    ");
    lcd.setCursor(0,1);
    sprintf(temp, "%3d%c%1d%cC", lectura/100, '.', lectura/10%10,223);
    lcd.print(temp);
    //    Serial.print("Temperatura[");
    //    Serial.print(numeroLectura);
    //    Serial.print("]: "); 
    //    Serial.println(temp); 
  }
  if (millis()-time > 5000) {  // Si han pasado mas de 5 segundos apagamos el cursor
    lcd.noBlink();
    cursorActivo=false;
  } 

  adc_key_in = analogRead(0);    // Leemos el valor de la pulsacion
  key = get_key(adc_key_in);    // Obtenemos el boton pulsado

  if (key != oldkey)   // if keypress is detected
  {
    delay(50);  // Espera para evitar los rebotes de las pulsaciones
    adc_key_in = analogRead(0);    // Leemos el valor de la pulsacion
    key = get_key(adc_key_in);    // Obtenemos el boton pulsado
    if (key != oldkey)    
    {
      time = millis();  // TODO: falta la comprobacion de si se ha desbordado el tiempo
      if (!luzEncendida) {  // Al pulsar cualquier tecla encendemos la pantalla
        analogWrite(10,intensidad*25);
        luzEncendida=true;
      } 
      else {  // si la pantalla esta encendida seguimos funcionando normalmente
        oldkey = key;
        char accion = 0;
        if (key >=0){  // Si se ha pulsado cualquier tecla
          lcd.blink();  // Mostramos el cursor parpadeando
          cursorActivo=true;
        }
        if ((key == 0) && (enMenu)){  // Se ha pulsado la tecla derecha
          x++;
          if (x>numeroDeMenus-1) x=numeroDeMenus-1;
        }
        if ((key == 1) && (enMenu)) {  // Se ha pulsado la tecla arriba
          accion++;
        }
        if ((key == 2) && (enMenu)) {  // Se ha pulsado la tecla abajo
          accion = accion-1;
        }
        if ((key == 3) && (enMenu)) {  // Se ha pulsado la tecla izquierda
          x--;
          if (x<0) x = 0;
        }
        if (key == 4){  // Se ha pulsado la tecla de seleccion
        }
        enMenu = true;
        lcd.clear();
        lcd.setCursor(0,0); 
        lcd.print(tituloMenu[x]);
        lcd.setCursor(0,1); 
        switch (x) {
        case 0: // Estamos en fijar temperatura
          consigna += accion;
          lcd.print(consigna);
          lcd.print((char)223);
          lcd.print("C");
          break;
        case 1:  // Estamos en fijar tiempo
          tiempo += accion;
          lcd.print(tiempo);
          lcd.print("0 seg.");
          break;
        case 2:  // Estamos en Kp.
          kp += accion;
          lcd.print(kp);
          break;
        case 3:  // Estamos en Kd.
          kd += accion;
          lcd.print(kd);
          break;
        case 4:  // Estamos en Ki.
          ki += accion;
          lcd.print(ki);
          break;
        case 5:  // Estamos en Ki.
          intensidad += accion;
          if (intensidad > 254) intensidad = 0;
          if (intensidad > 10) intensidad = 10;
          lcd.print(intensidad);
          lcd.print("0%");
          analogWrite(10,intensidad*25);
          break;
        } 
      }
    }
  }
  if ((numeroLectura > 99) && (numeroLecturas < 2)) {
    long suma = 0;
    maximo = -10000;
    minimo = 10000;
    for (int i=0; i < 100; i++){
      suma = suma + lecturas[i];
      if (lecturas[i] > maximo) {
        maximo = lecturas[i];
      }
      if (lecturas[i] < minimo) {
        minimo = lecturas[i];
      }

      //      Serial.print("Temperatura[");
      //      Serial.print(i);
      //      Serial.print("]: "); 
      //      Serial.println(lecturas[i]); 
    }
    diferencia = maximo - minimo;
    suma = suma / 100;
    // Si la diferencia es superior a un grado 
    //es que ha habido un error en la lectura
    if (diferencia > 100) {  
      Serial.println("Lectura no valida");
      // TODO: Descartar lectura y repetir la medida
    } 
    else {
      numeroLecturas++;
      t3=t2;
      t2=t1;
      t1=suma;
    }
    Serial.print("Suma: "); 
    Serial.println(suma); 
/*    Serial.print("Media: "); 
    Serial.print(suma/100); 
    Serial.print(","); 
    Serial.println(suma/10%10); 
    Serial.print("Maximo: "); 
    Serial.print(maximo/100); 
    Serial.print(","); 
    Serial.print(maximo/10%10); 
    Serial.print(" - Minimo: "); 
    Serial.print(minimo/100); 
    Serial.print(","); 
    Serial.print(minimo/10%10); 
    Serial.print(" - Diferencia: "); 
    Serial.print(diferencia/100); 
    Serial.print(","); 
    Serial.println(diferencia/10%10); */
  }
  if (numeroLectura > 99) {
    // Cuando se termina de tomar las 100 
    //lecturas empezamos de nuevo por la primera
    numeroLectura = 0;
  }
  PID();
  delay(10);
  // Si se desborda millis() empieza otra 
  //vez por cero, ocurre cada 50 dias
  if (millis() < time){   
    time = millis();
  }
}

void PID(){
  // Si se desborda millis() empieza otra 
  // vez por cero, ocurre cada 50 dias
  if (millis() < tiempoPID){   
    tiempoPID = millis();
  }
  // Si no ha pasado todavía el timepo de ciclo del PID
  if (millis() < tiempoPID + (tiempo*10*1000)){  
    // entonces mantenemos la fuerza y esperamos mas tiempo
    // s = sActualPID;  
  } 
  else if (numeroLecturas >= 2){
    numeroLecturas--;
    Serial.print("Distancia a la consigna: ");
    Serial.print(t1-consigna*100);
    Serial.print(" - Velocidad: ");
    Serial.println(t1-t2);
    tiempoPID = millis();
  }

}

// Convertimos el valor leido en analogico 
// en un numero de boton pulsado
int get_key(unsigned int input)
{
  int k;

  for (k = 0; k < NUM_KEYS; k++)
  {
    if (input < adc_key_val[k])
    {
      return k;
    }
  }

  if (k >= NUM_KEYS)k = -1;  // Error en la lectura.
  return k;
}

int temperaturaFicticia = 2450;
int ptf= 0;
int getTemp(byte input)
{
  int  celsius = Thermistor(analogRead(input))*100; 
  return celsius;
  temperaturaFicticia += (random(7)-3-ptf);
  if (temperaturaFicticia > 2800) ptf = 1;
  if (temperaturaFicticia < 2000) ptf = 0;
  return temperaturaFicticia;
}

float pad = 10000;  // balance/pad resistor value, set this to
                   // the measured resistance of your pad resistor
// float thermr = 10000; // thermistor nominal resistance

float Thermistor(int RawADC) {
  long Resistance;  
  float Temp;  // Dual-Purpose variable to save space.

  Resistance=((1024 * pad / RawADC) - pad); 
  // Saving the Log(resistance) so not to calculate  it 4 times later
  Temp = log(Resistance); 
  Temp = 1 / (0.001129148 + (0.000234125 * Temp) + 
         (0.0000000876741 * Temp * Temp * Temp));
  Temp = Temp - 273.15;  // Convert Kelvin to Celsius                      

  return Temp;    // Devolver temperatura
}

boolean cargarConfig(){
  if ((EEPROM.read(0) == 27) && (EEPROM.read(1) == 28) && 
     (EEPROM.read(2) == 13) && (EEPROM.read(3) == 18)) {
    // Comprobamos que la eeprom tenga una 
    // configuracion valida con numeros concretos
    // solo cargamos el valor de la configuracion si los valores coinciden
    if (EEPROM.read(4) == EEPROM.read(5)) consigna = EEPROM.read(4);  
    if (EEPROM.read(6) == EEPROM.read(7)) tiempo = EEPROM.read(6);
    if (EEPROM.read(8) == EEPROM.read(9)) kp = EEPROM.read(8);
    if (EEPROM.read(10) == EEPROM.read(11)) kd = EEPROM.read(10);
    if (EEPROM.read(12) == EEPROM.read(13)) ki = EEPROM.read(12);
    if (EEPROM.read(14) == EEPROM.read(15)) intensidad = EEPROM.read(14);
    return true;
  }
  return false;
}

void guardarConfig(){
  EEPROM.write(0,27);
  EEPROM.write(1,28);
  EEPROM.write(2,13);
  EEPROM.write(3,18);
  // Ponemos nmeros concretos en el comienzo 
  // de la EEPROM para confirmar que tiene valores correctos.
  EEPROM.write(4,consigna);
  EEPROM.write(5,consigna);  // almacenamos los valores 2 veces
  EEPROM.write(6,tiempo);
  EEPROM.write(7,tiempo);  // almacenamos los valores 2 veces
  EEPROM.write(8,kp);
  EEPROM.write(9,kp);  // almacenamos los valores 2 veces
  EEPROM.write(10,kd);
  EEPROM.write(11,kd);  // almacenamos los valores 2 veces
  EEPROM.write(12,ki);
  EEPROM.write(13,ki);  // almacenamos los valores 2 veces
  EEPROM.write(14,intensidad);
  EEPROM.write(15,intensidad);  // almacenamos los valores 2 veces
}

Créditos

Artículo realizado íntegramente por Alonsojpd miembro fundador del Proyecto AjpdSoft, con la inestimable colaboración de Antonio RN de RS.

Artículo en inglés.

10/16/2012

Usar HD de 3TB en Windows 7 x64, conectar disco duro SATA a PC

Cómo añadir un nuevo disco duro físico SATA a un PC con Microsoft Windows 7 x64. Mostramos cómo usar un HD de 3TB completo sin particionar en Windows 7 mediante el sistema de particionado GPT. Explicamos también cómo "unir" dos discos duros físicos de 3TB en uno (usando el método distribuido), de forma que podremos disponer, a todos los efectos, de un disco duro de 6TB.

Conexión física de disco duro SATA a placa base de PC

En primer lugar necesitaremos un cable SATA que será el que una el disco duro con la placa base, por el que circularán los datos. Necesitaremos también un conector de alimentación eléctrica compatible con SATA:

Nota: el adaptador de alimentación eléctrica sólo será necesario si la fuente de alimentación no dispone de este tipo de conectores para SATA o si no queda ninguno libre.

Para conectar un disco duro físico a una placa base de un PC abriremos la carcasa, introduciremos el disco duro en la ranura correspondiente y lo atornillaremos a la torre. Cogeremos el cable SATA por el extremo que indique "Drive" (normalmente es indiferente el extremo a usar para el HD y para la placa):

Lo insertaremos en el conector SATA del disco duro a tal efecto:

Realizaremos la misma operación con el cable de alimentación eléctrica:

Insertaremos el conector macho de alimentación eléctrica en su correspondiente conector hembra del disco duro SATA:

Conectaremos el extremo del cable SATA al conector SATA de la placa base, si es el primer disco duro de nuestro PC podremos usar el SATA0, si es el segundo el SATA1 (salvo que esté siendo usado por otro dispositivo). En principio para el caso de SATA es indiferente qué conector de la placa base usar, normalmente tienen cuatro conectores SATA0, SATA1, SATA2 y SATA3:

El extremo de Sys BRD (System Board o placa base) del conector SATA quedará conectado, en nuestro caso, en el SATA0, al tratarse del único disco duro del PC y estar libre:

Activación disco duro, particionado, GPT, 3TB en Windows 7

Tras conectar físicamente el disco duro a la placa base de nuestro equipo, lo arrancaremos, no es necesario acceder a la BIOS pues es un disco duro SATA y será detectado automáticamente por el sistema. Se iniciará el sistema operativo Microsoft Windows 7, una vez iniciada sesión accederemos al administrador de discos, desde el botón "Inicio", pulsaremos sobre "Equipo" con el botón derecho del ratón y seleccionaremos "Administrar":

En la Administración de equipos seleccionaremos "Almacenamiento" - "Administración de discos":

Si no aparece el nuevo disco duro podremos forzar al sistema a que realice un análisis para buscar nuevos discos duros, para ello pulsaremos con el botón derecho del ratón sobre "Administración de discos" y seleccionaremos "Volver a examinar los discos":

El administrador de discos realizará un examen en busca de nuevos dispositivos:

Nos mostrará el nuevo disco duro en la posición del SATA en la que lo hayamos conectado, en nuestro caso como "Disco 2". Podremos observar que Windows 7 no sería capaz de asignar más de 2TB (2000GB) para una partición, por lo que lo divide en "2048GB" y en "746GB". Si no usamos GPT como indicamos a continuación la partición máxima sería de 2TB, teniendo que dividir el disco en dos particiones.

Para evitar esto, convertiremos el disco duro a disco GPT, para ello pulsaremos con el botón derecho del ratón sobre "Disco 2" y en el menú emergente seleccionaremos "Convertir en disco GPT":

Ahora sí podremos usar los 3TB (2800GB aproximadamente) del espacio del disco duro en una única partición:

Para particionar el disco duro GPT de 3TB pulsaremos con el botón derecho del ratón sobre el espacio "No asignado" y seleccionaremos "Nuevo volumen simple":

Se iniciará el asistente para nuevo volumen simple, pulsaremos "Siguiente":

Indicaremos el tamaño para la partición que se creará, por defecto se usará todo el espacio posible (2800GB):

Marcaremos "Asignar la letra de unidad siguiente", en el desplegable podremos elegir la letra que el sistema le asignará la partición del disco duro de 3TB, por defecto la letra libre siguiente a la última que tengamos asignada:

En el siguiente paso del asistente podremos formatear la particion, para ello marcaremos "Formatear este volumen con la configuración siguiente", elegiremos en "Sistema de archivos" la opción "NTFS", marcaremos "Dar formato rápido" y pulsaremos "Siguiente":

El asistente para crear un nuevo volumen simple (partición) nos mostrará todas las opciones elegidas, si son correctas pulsaremos "Finalizar":

Se iniciará la creación del nuevo volumen simple y su formateo:

Tras el formateo el sistema le asignará la letra de unidad que hayamos elegido y ya estará disponible para utilizarla:

Desde el Explorador de Windows podremos comprobar que la unidad existe y está disponible, también su tamaño (3TB aproximadamente):

Unir dos discos duros físicos en uno con volumen distribuido en Windows 7

Windows permite unir dos discos duros físicos en uno lógico de forma que, a todos los efectos, el sistema lo tratará como un único disco sumando el espacio de ambos. Para usar este método de particionado deberemos disponer de dos discos duros físicos sin particionar, en nuestro caso usaremos dos discos duros de 3TB, que previamente hemos convertido a GPT para usar todo su espacio, como indicamos aquí.

Accederemos a la Administración de discos, para ello pulsaremos en el botón "Inicio", pulsaremos sobre "Equipo" con el botón derecho del ratón y seleccionaremos "Administrar":

Unir dos discos duros físicos en uno con volumen distribuido en Windows 7

En la Administración de equipos seleccionaremos "Almacenamiento" - "Administración de discos":

Desde el administrador de discos seleccionaremos uno de los discos duros a unir, pulsaremos con el botón derecho en la parte izquierda y en el menú emergente seleccionaremos "Nuevo volumen distribuido":

Se iniciará el asistente para nuevo volumen distribuido, pulsaremos "Siguiente":

Con el texto: Este asistente le ayuda a crear volúmenes distribuidos en discos. Un volumen distribuido está formado por espacio en disco en más de un disco. Cree un volumen distribuido cuando necesite un volumen con espacio mayor al de un único disco: podrá extenderlo si le agrega espacio disponible de otro disco.

El asistente nos mostrará todos los discos duros del equipo con espacio sin particionar para poder ser usados para el volumen distribuido. En nuestro caso añadiremos todo el disco duro 1 para unirlo con el disco duro 2, para ello seleccionaremos "Disco 1" en la izquierda y pulsaremos "Agregar":

Una vez agregados los discos duros a distribuir (unir en uno lógico), el asistente nos mostrará el tamaño total del volumen distribuido (sumando el espacio de los discos duros seleccionados). Si queremos usar menos espacio del total de cada disco podremos seleccionarlos uno a uno y especificar en "Seleccione la cantidad de espacio" el nuevo tamaño. En nuestro caso usaremos todo el espacio de los dos discos duros por lo que dejaremos el tamaño máximo, que es el que establece por defecto y pulsaremos "Siguiente":

Asignaremos una letra de unidad al nuevo disco lógico marcando "Asignar la letra de unidad siguiente" y pulsaremos "Siguiente":

Para que podamos usarla marcaremos "Formatear este volumen con la configuración siguiente", en "Sistema de archivos" indicaremos "NTFS", marcaremos "Dar formato rápido" y pulsaremos "Siguiente":

El asistente para crear un nuevo volumen distribuido nos mostrará todas las opciones elegidas, si son correctas pulsaremos "Finalizar":

El asistente nos advertirá de que se convertirán los discos duros elegidos de básicos a dinámicos para poder crear el volumen distribuido, pulsaremos "Sí" para continuar:

Con el texto: La operación elegida convertirá los discos básicos seleccionados en discos dinámicos. Si los discos se convierten en dinámicos, no podrá iniciar ningún sistema operativo instalado en los volúmenes de los mismos, a excepción del volumen de arranque actual. ¿Está seguro de que desea continuar?

El proceso tardará unos minutos en función del tamaño de los discos duros a distribuir, cuando concluya, el asistente habrá creado una única unidad de disco con la letra elegida y nos marcará con otro color los dos discos duros físicos que hemos usado para generar el disco duro distribuido:

A partir de este momento ya podremos disponer de una nueva unidad en el equipo con el tamaño suma de ambos discos duros, en nuestro caso 6TB:

Tabla de particiones GUID (GPT)

La tabla de partición GUID (GPT) es un estándar para la colocación de la tabla de particiones en un disco duro físico. Es parte del estándar Extensible Firmware Interface (EFI) propuesto por Intel para reemplazar el viejo BIOS del PC, heredada del IBM PC original. La GPT sustituye al Master Boot Record (MBR) usado con el BIOS.

Mientras que el MBR comienza con el código de arranque maestro (Master Boot Code), que contienen un binario ejecutable que identifica la partición activa e inicia el proceso de arranque, la GPT se basa en las capacidades extendidas del EFI para estos procesos. Con propósitos de protectividad y compatibilidad con el viejo esquema BIOS PC, la GPT propiamente dicha comienza con la cabecera de la tabla de particiones.

GPT usa un moderno modo de direccionamiento lógico (LBA o Logical Block Addressing) en lugar del modelo cilindro-cabeza-sector (CHS) usado con el MBR. La información de MBR heredado está almacenada en el LBA 0, la cabecera GPT está en el LBA 1, y la tabla de particiones en sí en los bloques sucesivos. En los sistemas operativos Windows de 64-bits, 16.384 bytes, o lo que es lo mismo, 32 sectores, están reservados para la GPT, dejando el bloque LBA 34 como el primer sector usable del disco.

GPT proporciona asimismo redundancia. La cabecera GPT y la tabla de particiones están escritas tanto al principio como al final del disco.

El principal propósito del MBR al principio del disco es evitar que utilidades de disco basadas en MBR no reconozcan o estropeen discos basados en GPT. En el MBR heredado se especifica la existencia de una única partición, que abarca toda la unidad GPT. El indicador de sistema (System ID) para esta partición es 0xEE, indicando que debe interpretarse el disco como GPT. A causa de esto, el EFI ignora el MBR. Algunos sistemas operativos de 32 bits que no pueden leer discos GPT reconocen sin embargo este System ID y presentan el disco como disco GPT inaccesible.

Créditos

Artículo realizado íntegramente por Alonsojpd miembro fundador del Proyecto AjpdSoft.

Artículo en inglés.

10/18/2011

Realizar una conexión a Internet con la placa Arduino y un módulo GPRS GSM

Explicamos cómo realizar una conexión a Internet, a una página web por socket mediante Arduino UNO y un módulo GPRS/GSM. Mostramos todos los requisitos hardware y software para realizar este proyecto de prueba con Arduino. Indicamos cómo conectar dos Arduinos para enviar la salida serie de uno de ellos (el que lleva el módulo GPRS/GSM) a otro.

Requisitos para realizar conexión a Internet desde Arduino con GPRS

En la siguiente sección del siguiente artículo explicamos los requisitos hardware y software necesarios para realizar el envío de SMS con Arduino y un módulo GPRS, dichos requisitos son los mismos que para la conexión a Internet:

Requisitos para enviar SMS y hacer llamadas desde placa Arduino

Básicamente necesitaremos un Módulo GPRS (en nuestro caso usamos un GPRS Sagem Quadband Module for Arduino), una Placa Arduino UNO y los requisitos software explicados en este otro artículo, donde también indicamos cómo conectar Arduino al PC paso a paso y cómo enviar programas desde el IDE de Arduino a la memoria Flash de la placa:

Primer proyecto hardware con Arduino, encender un LED

Cómo conectar el módulo GPRS a la placa Arduino UNO

En la siguiente sección del siguiente artículo explicamos paso a paso cómo conectar la antena externa al módulo GPRS y cómo conectar el módulo GPRS a la placa Arduino UNO:

Cómo conectar módulo GPRS a placa Arduino UNO

Consideraciones importantes a tener en cuenta antes de enviar el programa a Arduino para usar el módulo GPRS

Hay que tener en cuenta que el módulo GPRS tiene "dos posiciones" para la conexión con Arduino:

1. Por un lado hay que indicarle al módulo GPRS cuándo está conectado al PC por el puerto USB (serie emulado), esto se hace colocando dos jumpers que incorpora en la parte superior de la siguiente forma:

Es muy importante tener esto en cuenta, cuando queramos enviar el programa a Arduino, los dos jumpers deben estar como se indica en la imagen anterior, si no es así el Upload (envío) del programa dará error.

El error que nos mostrará el IDE de desarrollo de Arduino si no hemos colocado los jumpers correctamente será:

avrdude: stk500_getsync(): not in sync: resp=0x00
avrdude: stk500_disable(): protocol error, expect=0x14, resp=0x51

2. Para probar el programa de conexión a Internet o cualquier otra tarea que hayamos programado con Arduino y el módulo GPRS deberemos desconectarlo del USB del PC y alimentarlo externamente. Además, deberemos cambiar los jumpers mencionados anteriormente a esta nueva posición:

Considereciones importantes a tener en cuenta antes de enviar el programa a Arduino para usar el módulo GPRS

Si no se hace esto, cuando desconectemos Arduino del PC y lo alimentemos externamente, el módulo GPRS no funcionará.

Programar Arduino UNO para realizar una conexión a Internet con el módulo GPRS

Para realizar una conexión a Internet con la placa Arduino UNO, insertaremos una tarjeta SIM en el módulo GPRS con la opción de datos activa, conectaremos el módulo GPRS a la placa Arduino, colocaremos los jumpers del módulo en su posición para conexión con PC y conectaremos Arduino UNO al PC por el puerto USB. Una vez realizados todos estos pasos (explicados anteriormente), abriremos el IDE de desarrollo de Arduino y escribiremos el siguiente programa:

/* 
 *  Conexion a Internet con modulo GPRS y Arduino
*/ 
  
int pinActivarGPRS = 2;  // pin para activar el módulo GPRS

//procedimiento para activar el módulo GPRS
void activarModuloGPRS()
{
  digitalWrite(pinActivarGPRS, HIGH);
  delay(2000);
  digitalWrite(pinActivarGPRS, LOW);
}

void setup()
{
  pinMode(pinActivarGPRS, OUTPUT);
  Serial.begin(19200); //velocidad de conexión con módulo GPRS
  activarModuloGPRS(); //activar el módulo GPRS
 
  delay(20000); //esperamos 20 segundos a que se active el módulo GPRS  

  Serial.println("AT&k3");  //activa el control de flujo RTS/CTS en el modem
  delay(1000);
  Serial.print("AT+KCNXCFG=0,"); //inicia la configuración para el GPRS
  Serial.print(34,BYTE);
  Serial.print("GPRS");  //tipo de conexión
  Serial.print(34,BYTE);
  Serial.print(",");
  Serial.print(34,BYTE);
  Serial.print("gprs-service.com");  //punto de acceso
  Serial.print(34,BYTE);
  Serial.print(",");
  Serial.print(34,BYTE);
  Serial.print("");  //usuario del operador
  Serial.print(34,BYTE);
  Serial.print(",");
  Serial.print(34,BYTE);
  Serial.print("1234");  //contraseña del operador, para Simyo "1234"
  Serial.print(34,BYTE);
  Serial.println();
  delay(1000);
  //establecer configuraciones de tiempos de espera, reintentos de conexion y demas
  Serial.println("AT+KCNXTIMER=0,60,2,70"); 
  delay(1000);
  Serial.println("AT+KCNXPROFILE=0");
  delay(1000);
  Serial.println("AT+CGATT=1");  //para conectarnos a la red movil del operador
  delay(1000);
  Serial.print("AT+KTCPCFG=0,0,");  //para indicar el host o IP al que nos conectaremos
  Serial.print(34,BYTE);
  Serial.print("www.ajpdsoft.com");
  Serial.print(34,BYTE);
  Serial.println(",80");  //puerto por el que se realizará la conexión
  delay(1000);
  Serial.println("AT+KTCPCNX=1"); //para iniciar un intercambio de datos TCP
  delay(7000);
  //para envio de datos a la conexion
  //el 18 indica la cantidad de datos que queremos enviar "GET / HTTP/1.0\r"
  Serial.println("AT+KTCPSND=1,18"); 
  delay(2000);
  Serial.println("GET / HTTP/1.0");
  Serial.print(10,BYTE); //salto de línea
  Serial.print(13,BYTE); //retorno de carro
  Serial.print("--EOF--Pattern--"); //fin de la cadena de envio de datos
  delay(2000);
  Serial.println("AT+KTCPRCV=1,807"); //activar recepcion de datos
  delay(1000);
  Serial.println("AT+KTCPCLOSE=1,1");  //cerrar la conexion
  delay(1000);   
}

void loop()
{ 
}

Como siempre, verificaremos el código pulsando en el botón "Verify" del IDE de desarrollo de Arduino:

Programar Arduino UNO para realizar una conexión a Internet con el módulo GPRS

Y lo enviaremos a la placa Arduino pulsando en "Upload":

Enviar salida serie de un Arduino a otro para comprobar resultado de la conexión a Internet

En este proyecto, para poder comprobar la placa Arduino con el módulo GPRS GSM realiza la conexión a Internet correctamente, deberemos conectar una segunda placa Arduino al primero como explicamos a continuación.

Por un lado conectaremos un cable del pin TX - 1 del Arduino sin el módulo GPRS GSM al jumper USB del módulo GPRS GSM como se muestra en la imagen y por otro lado conectaremos un segundo cable del pin GND del Arduino sin el módulo GPRS al ping GND del Arduino con el módulo:

1. Vista del Arduino con el módulo GPRS GSM:

2. Vista del Arduino sin el módulo GPRS:

3. Vista de los dos Arduinos conectados:

Una vez conectados los dos Arduinos, conectaremos el segundo (el que no lleva el programa ni el módulo GPRS) al PC por el puerto USB, iniciaremos el IDE de Arduino, seleccionaremos el puerto desde el menú "Tools" - "Serial Port":

Enviar salida serie de un Arduino a otro para comprobar resultado de la conexión a Internet

Pulsaremos en el botón "Serial Monitor" y en la ventana que nos mostrará debemos seleccionar la misma velocidad que hayamos indicando en el programa para la conexión serie, en nuestro caso 19200 baud (si no hacemos esto puede que veamos caracteres raros en la pantalla):

Ahora alimentaremos eléctricamente el Arduino con el módulo GPRS GSM, tras unos segundos, si la conexión de los dos Arduinos mediante los dos cables es correcta, iremos viendo la salida serie del primer Arduino en el PC y así podremos verificar y testear el resultado de la conexión a Internet:

Créditos

Artículo realizado íntegramente por Alonsojpd miembro fundador del Proyecto AjpdSoft, con la inestimable colaboración de Antonio RN de RS.

Artículo en inglés.

4/28/2015

4/21/2015

1/23/2014

9/13/2013

8/25/2013

1/11/2013

11/19/2012

Cómo conectar display LCD Keypad Shield a Arduino UNO

Programa Arduino para mostrar texto en display LCD y contador que se va incrementando

Programa Arduino para mostrar texto en scroll en display LCD

Programa Arduino para introducir texto en el LDC con las teclas de desplazamiento

Programa Arduino para mostrar menús y submenús en display LCD

Programa Arduino para mostrar temperatura, opciones modificables, luminosidad en display LCD

Artículos relacionados

Créditos

10/16/2012

Conexión física de disco duro SATA a placa base de PC

Activación disco duro, particionado, GPT, 3TB en Windows 7

Unir dos discos duros físicos en uno con volumen distribuido en Windows 7

Tabla de particiones GUID (GPT)

Artículos relacionados

Créditos

10/18/2011

Requisitos para realizar conexión a Internet desde Arduino con GPRS

Cómo conectar el módulo GPRS a la placa Arduino UNO

Consideraciones importantes a tener en cuenta antes de enviar el programa a Arduino para usar el módulo GPRS

Programar Arduino UNO para realizar una conexión a Internet con el módulo GPRS

Enviar salida serie de un Arduino a otro para comprobar resultado de la conexión a Internet

Artículos relacionados

Créditos