jueves, 12 de mayo de 2016

Mini osciloscopio con arduino y LCD QC12864 (III). Conexión serie. (30Khz)

Antes de nada decir que tal y como compre yo mi lcd no podía comunicarse via serie con el arduino, tuve que desoldar un par de puentes que vienen en el display como resistencias 000.



Sé que en otros modelos no existe ese problema y si puede conectarse así sin ningún problema, en mi modelo no, el mío se quema si no se desuelda. No solo no se ve nada sino que además se quemaría.

En esta página explico lo que tuve que desoldar en mi modelo QC 12864B -1 se hace en un momento, deja libres 5 ó 6 pines frente a la conexión en paralelo, no hay perdidas aparentes de velocidad y puedes seguir conectandolo en paralelo si quieres  igual que siempre.  En el tiempo que yo llevo usandolo no he notado ningún inconveniente, por lo que me pregunto porque lo venderán inutilizado para la conexión en serie. :)

IMPORTANT! For this LCD to work using this method, you need to de-solder R9 and R11 at the back panel of the LCD.






La medición máxima es hasta 5V, puede protegerse el arduino con un zener,  Para medidas mayores debe usarse un divisor resistivo.

El conmutador permite cambiar entre dos modos de funcionamiento, osciloscopio o monitor, su resistencia es de 100Kohm.   
Los pulsadores sirven para aumentar o disminuir el tiempo de muestreo, la resistencia es de 10Kohm, aunque  en este caso si no se pone no pasa nada.

El potenciometro controla el contraste del LCD.

La máxima resolución en modo osciloscópio es de 5,5useg   y en modo monitor de .16 seg.





El programa está basado en la librería u8glib , que puede descargarse aquí y permite dibujar gráficos no sólo en el
QC12864, sino también en otros muchos modelos, tanto en conexión serie como paralelo.
Modificando el Delay del final el escanéo puede ser ralentizado.  La lectura que muestra es la que lee la entrada analógica, esto es entre 0 y 1024  que equivalen de  0 a 5V,


Sketch: DESCARGAR


#include "U8glib.h"

U8GLIB_ST7920_128X64_1X u8g(6, 5, 4 ,7);  //For ST7920_128X64  serie

 unsigned long sensor;  

int x;
int y[130];

 boolean monitor;

int y2;
unsigned long ycal;
// unsigned long tpo;

byte punto;
byte y3;

float mx;
byte mc;
byte fc;

int muestreo;
int boton=6;

void setup(void) {
  pinMode(3,INPUT);
   pinMode(2,INPUT);
     pinMode(10,INPUT);
 
attachInterrupt(0, mas, RISING); 
attachInterrupt(1, menos, RISING);

Serial.begin(9600);

}



void loop(void) {


  u8g.firstPage();

  //

monitor=(digitalRead(10));

  muestreo=boton*3;

Serial.println(monitor);

if (monitor==1) {    // Osciloscopio



  // Prescaler
   
   switch(byte(1+6*float(muestreo/400)))
  {
    case 0: //  =2 Malfuncionamiento
      bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 1:
     bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 2:
      bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,1);
    break;
    case 3:
    bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 4:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,1);
    break;
    case 5:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 6:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,1);;
    break;
  }
 
 

  //Analog Input A0 
 ADMUX=(1<<ADLAR)|(0<<REFS1)|(1<<REFS0)|(0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0); 
 


 // Lectura de datos


   if (muestreo <1 br="" muestreo="" nbsp="" turbo="">
     ycal = micros();


  y[0] = analogReadFast();  
    y[1] = analogReadFast();  
    y[2] = analogReadFast();  
    y[3] = analogReadFast();  
    y[4] = analogReadFast();  
    y[5] = analogReadFast();
    y[6] = analogReadFast();  
    y[7] = analogReadFast();  
    y[8] = analogReadFast();  
    y[9] = analogReadFast();  
    y[10] = analogReadFast();  
    y[11] = analogReadFast();  
    y[12] = analogReadFast();  
    y[13] = analogReadFast();  
    y[14] = analogReadFast();  
    y[15] = analogReadFast();  
    y[16] = analogReadFast();  
    y[17] = analogReadFast();  
    y[18] = analogReadFast();  
    y[19] = analogReadFast();  
        y[20] = analogReadFast();  
    y[21] = analogReadFast();  
    y[22] = analogReadFast();  
    y[23] = analogReadFast();  
    y[24] = analogReadFast();  
    y[25] = analogReadFast();  
    y[26] = analogReadFast();  
    y[27] = analogReadFast();  
    y[28] = analogReadFast();  
    y[29] = analogReadFast();
        y[30] = analogReadFast(); 
    y[31] = analogReadFast();  
    y[32] = analogReadFast();  
    y[33] = analogReadFast();  
    y[34] = analogReadFast();  
    y[35] = analogReadFast();  
    y[36] = analogReadFast();  
    y[37] = analogReadFast();  
    y[38] = analogReadFast();  
    y[39] = analogReadFast();
    y[40] = analogReadFast();
    y[41] = analogReadFast();  
    y[42] = analogReadFast();  
    y[43] = analogReadFast();  
    y[44] = analogReadFast();  
    y[45] = analogReadFast();  
    y[46] = analogReadFast();  
    y[47] = analogReadFast();  
    y[48] = analogReadFast();  
    y[49] = analogReadFast();
    y[50] = analogReadFast();  
    y[51] = analogReadFast();  
    y[52] = analogReadFast();  
    y[53] = analogReadFast();  
    y[54] = analogReadFast();  
    y[55] = analogReadFast();  
    y[56] = analogReadFast();  
    y[57] = analogReadFast();  
    y[58] = analogReadFast();  
    y[59] = analogReadFast();
    y[60] = analogReadFast();  
    y[61] = analogReadFast();  
    y[62] = analogReadFast();  
    y[63] = analogReadFast();  
    y[64] = analogReadFast();  
    y[65] = analogReadFast();  
    y[66] = analogReadFast();  
    y[67] = analogReadFast();  
    y[68] = analogReadFast();  
    y[69] = analogReadFast();
    y[70] = analogReadFast();  
    y[71] = analogReadFast();  
    y[72] = analogReadFast();  
    y[73] = analogReadFast();  
    y[74] = analogReadFast();  
    y[75] = analogReadFast();  
    y[76] = analogReadFast();  
    y[77] = analogReadFast();  
    y[78] = analogReadFast();  
    y[79] = analogReadFast();
    y[80] = analogReadFast();  
    y[81] = analogReadFast();;  
    y[82] = analogReadFast();  
    y[83] = analogReadFast();  
    y[84] = analogReadFast();  
    y[85] = analogReadFast();  
    y[86] = analogReadFast();  
    y[87] = analogReadFast();  
    y[88] = analogReadFast();  
    y[89] = analogReadFast();
    y[90] = analogReadFast();
    y[91] = analogReadFast();
    y[92] = analogReadFast();
    y[93] = analogReadFast();
    y[94] = analogReadFast();
    y[95] = analogReadFast();
    y[96] = analogReadFast();
    y[97] = analogReadFast();
    y[98] = analogReadFast();
    y[99] = analogReadFast();
 y[100] = analogReadFast();
    y[101] = analogReadFast();
    y[102] = analogReadFast();
    y[103] = analogReadFast();
    y[104] = analogReadFast();
    y[105] = analogReadFast();
    y[106] = analogReadFast();
    y[107] = analogReadFast();
    y[108] = analogReadFast();
    y[109] = analogReadFast();
    y[110] = analogReadFast();
    y[111] = analogReadFast();
    y[112] = analogReadFast();
    y[113] = analogReadFast();
    y[114] = analogReadFast();
    y[115] = analogReadFast();
    y[116] = analogReadFast();
    y[117] = analogReadFast();
    y[118] = analogReadFast();
    y[119] = analogReadFast();
    y[120] = analogReadFast();
    y[121] = analogReadFast();
    y[122] = analogReadFast();
    y[123] = analogReadFast();
    y[124] = analogReadFast();
    y[125] = analogReadFast();
    y[126] = analogReadFast();
    y[127] = analogReadFast();

  mx= (micros() - ycal);

}


else {    // muestreo con rapidez alta

  muestreo=muestreo-1;
 ycal = micros();

  for ( punto = 0; punto <= 127; punto++ ) {

    y[punto]=analogReadFast();
   
     delayMicroseconds(muestreo);
  }
 
  mx= (micros() - ycal);
   
  
  }

sensor = mx;   // tpo muestreo
 
  

  
       // fin muestro
       

 
  /// Estimación frecuencia   f= picos/tpo muestreo

     mx=0;
  
for ( punto = 0; punto <= 127; punto++ ) {
  
     mx=max(mx,y[punto]);
  
  }
 

 
  fc = 0;
 
  mx = mx*.9  ;  // Pico > 10%


  for ( punto = 0; punto <= 127; punto++ ) {

    if ( (mx < y[punto]) && (mc == 0)) {
      fc = fc + 1;
      mc = 1;
    }

    if (y[punto] < mx) {
      mc = 0;
    }
  }
}                          // <-- br="" cierre="" nbsp="" osciloscopio="">


else {                         // monitoreo del pin A0


mx=millis();
   y[128]=0; //media total

x=0;


  y[127]=analogRead(A0)/4;
  retardo();

  ycal=0;
  for ( punto = 0; punto <= 126; punto++ ) {
   
 y[punto]=y[punto+1];

      ycal=ycal+y[punto];
  }


  mx=millis()-mx;

y[128]=(ycal+y[127])/128;

}                    // cierre de monitoreo



  /// Dibujar

  do {

    draw();
  } while ( u8g.nextPage() );


  // delay(5000);   // Para congelar imagen entre muestreo y muestreo.
}  // fin loop



void retardo()   // retardo monitor
{

if (x<((170*(boton)))) {
    y[127]=((analogRead(A0)/4)+y[127])/2;
  x=x+1;
       delayMicroseconds(35);
retardo();
}

}

///////////////////    GRAFICA

void draw(void) {

  // graphic commands to redraw the complete screen should be placed here

  // u8g.drawFrame(0,0,128,56);  //marco exterior

  for ( punto = 21; punto <= 106; punto = punto + 42 ) {       // punto vertical cada 1V

    u8g.drawPixel(punto, 10);  u8g.drawPixel(punto, 21); u8g.drawPixel(punto, 32); u8g.drawPixel(punto, 43);

  }

 u8g.setFontPosTop();
 

  // Grafica de la onda

  y3 = 55 - 28 * float(y[0]) / 128;  ///  54/1024

  for ( punto = 1; punto <= 127; punto++ ) {


    ycal = 55 - 28 * float(y[punto]) / 128;    ///  54/1024


    u8g.drawLine(punto - 1, y3, punto, ycal);

    y3 = ycal;
  }


  // Leyenda

  u8g.setFont(u8g_font_04b_03);

  u8g.setPrintPos(0, 56);
 
  if (monitor==0){

    u8g.print(String(float(y[127])*5/256) +"V.  /"+ String(float(.16+mx/1000)) + " Seg.  Med: "+String(float(y[128])*5/256)+"V.");   ///   x5V
  }
  else {
    u8g.print( String(float((sensor+.5)/1000)) + " mSeg. /Estm: " + String(long(float(1000000*fc/(sensor+.5) ))) + " Hz ");
   }

}



//Read ADC
int analogReadFast()
{

ADCSRA|=(1<<ADSC);
 // ADSC is cleared when the conversion finishes
 while (bit_is_set(ADCSRA, ADSC));
        return ADCH;

}


void mas()  // aumentar tpo de muestreo
{
   if (boton<175 br="">       if (boton>15){
   boton=boton+5;
       }
       else
   {
    boton=boton+1;
   }
   }
}  


void menos()    // disminuir tpo de muestreo
{
  if (boton>0){
      if (boton>15){
   boton=boton-5;
      }
   else
   {
    boton=boton-1;
   }
   }
}

 



domingo, 27 de marzo de 2016

Mini osciloscopio con 2 arduino y QC12864. II (30Khz). Conexión paralelo.

En este post hacíamos un pequeño osciloscopio con un arduino nano y un lcd qc12864.
Tras comprobar las limitaciones de modificar el prescaler  en el arduino con casi todos sus pines analógicos trabajando, pensé en el otro pequeñín que tenía guardado en un cajón que podía ocuparse de hacer el muestreo de la señal, enviarselo al otro via serie que sería el encargado de los cálculos y la representación gráfica.
Al fin y al cabo los osciloscopios basados en arduino "más" decentes que he visto en internet funcionan así, aunque también hay otra opción con un solo arduino: conectarlos en serie.

De esta manera he logramos logrado una resolución de 6useg./pixel o lo que es lo mismo todo el ancho de pantalla menor de 1 milisegundo, con el potenciometro podemos variar la duración del muestreo hasta 200 mSeg. a partir de ahí el comportamiento del programa cambia y monitorea el valor de la señal.

El sketch viene preparado, descomentando una de las líneas finales del void(loop), para insertar un potenciometro al pin A7 y estabilizar la imagen, sobre todo en las frecuencias medias.



El funcionamiento del programa es similar al anterior, aunque ahora el arduino maestro envía una señal cuyo valor es la resolución requerida, tomada del potenciometro a través de A1, que a demás es la señal que indica al arduino esclavo que inicie el muestreo. ( Si hay un desajuste temporal, por ejemplo los encendemos en momentos distintos,  se va a quedar esperando esa señal indefinidamente, y habrá que reiniciar el arduino maestro para que coienze de nuevo - botón rset-).

Una vez hecho el muestreo se envían al maestro los datos a través del puerto serie, siendo el último dato el tiempo invertido en el muestreo, para que este los analice y represente en el lcd.

La lectura de la frecuencia es sólo una estimación y no es el propósito de este programa, aunque es bastante aproximada si vemos varias ondas en la pantalla,


Nuestro osciloscopio sólo admite valores de entrada entre 0 y +5V,  y otros valores lo pueden dañar, así que para visualizarlos  hay que usar divisores resistivos o  zener.



Para que funcionen  los sketch hay que tener instalada la librería U8glib.


Las conexiones son practicamente las mismas que en el osciloscopio anterior, con algunas pequeñas modificaciones para posibilitar la comunicación entre arduinos.




Los arduinos se conectan entre sí a través de los pines Tx y Rx con un cable cruzado, también deben compartir la masa, La señal se escanea a través del pin A0 del arduino esclavo.




Sketch 1. Arduino maestro (conectado al lcd) Descargar





#include "U8glib.h"


U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);  //For ST7920_128X64 paralelo

unsigned long sensor;

int x;
int y[130];

boolean monitor;

int y2;
unsigned long ycal;

byte punto;
byte y3;

float mx;
byte mc;
byte fc;


void setup(void) {

  Serial.begin(115200);
}



void loop(void) {


  u8g.firstPage();

  // Envio del tpo de muestreo

  sensor = analogRead(A1)/2;
 

if (sensor < 256) {    // Osciloscopio

  monitor=0;
 
   if ( sensor <64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo="">

   Serial.write(byte(sensor));

 // Lectura de datos

  for ( punto = 0; punto <= 129; punto++ ) {
   
 while( Serial.available()==0){
 }

    y[punto] = Serial.read();
   
  
  }

sensor = (y[128]);   // tpo muestreo
 
   } // fin muestreo os. seg arduino
  

   else {   // muestreo propio arduino

   
y[129]=0;
mx=millis();


ycal=8*(sensor-64); // calibrado tiempo

 for ( punto = 0; punto <= 127; punto++ ) {  //muestreo pinA0 arduino maestro
    x=1;
    y[punto] = analogRead(A0);

  // delayMicroseconds(ycal);

   retardo0();

  }

 sensor= (millis()-mx)*4;
 
for ( punto = 0; punto <= 127; punto++ ) {
    y[punto] = y[punto]/4;
     y[129]=max(y[129],y[punto]);
  
  }
 
   
   }  // fin osciloscopio arduino  maestro

  
  /// Estimación frecuencia   f= picos/tpo muestreo

 
  fc = 0;
 
  mx = y[129]*.9  ;  // Pico > 10%


  for ( punto = 0; punto <= 127; punto++ ) {

    if ( (mx < y[punto]) && (mc == 0)) {
      fc = fc + 1;
      mc = 1;
    }

    if (y[punto] < mx) {
      mc = 0;
    }
  }
}                          // <-- br="" cierre="" nbsp="" osciloscopio="">

else {                         // monitoreo del pin A0

   monitor=1;

mx=millis();
   y[128]=0; //media total

x=100;


  y[127]=analogRead(A0)/4;
  retardo();
 
   for ( punto = 0; punto <= 126; punto++ ) {
   
 y[punto]=y[punto+1];

       y[128]=y[128]+y[punto];
  }


  mx=millis()-mx;

y[128]=y[128]/128;

}                    // cierre de monitoreo

  /// Dibujar

  do {

    draw();
  } while ( u8g.nextPage() );


//   delayMicroseconds(analogRead(A7)*50);   // Para congelar imagen entre muestreo y muestreo conviene controlar este parametro mediante potenciómetro.



}


void retardo0()    // retardo osciloscopio arduino maestro
{
   if (x   y[punto]=(analogRead(A0)+y[punto])/2;
  x=x+2;
     retardo0();
   }

}

void retardo()   // retardo monitor
{

if (x<((30*(analogRead(A1)-512)))) {
    y[127]=((analogRead(A0)/4)+y[127])/2;
  x=x+1;
retardo();
}

}

///////////////////    GRAFICA

void draw(void) {

  // graphic commands to redraw the complete screen should be placed here

  // u8g.drawFrame(0,0,128,56);  //marco exterior

  for ( punto = 21; punto <= 106; punto = punto + 42 ) {       // punto vertical cada 1V

    u8g.drawPixel(punto, 10);  u8g.drawPixel(punto, 21); u8g.drawPixel(punto, 32); u8g.drawPixel(punto, 43);

  }

 u8g.setFontPosTop();
 

  // Grafica de la onda

  y3 = 55 - 27 * float(y[0]) / 128;  ///  54/1024

  for ( punto = 1; punto <= 127; punto++ ) {


    ycal = 55 - 28 * float(y[punto]) / 128;    ///  54/1024


    u8g.drawLine(punto - 1, y3, punto, ycal);

    y3 = ycal;
  }


  // Leyenda

  u8g.setFont(u8g_font_04b_03);

  u8g.setPrintPos(0, 56);
 
  if (monitor==1){

    u8g.print(String(float(y[127])*5/255) +"V.  /"+ String(float(.17+mx/1000)) + " Seg.  Med: "+String(float(y[128])*5/255)+"V.");   ///   x5V
  }
  else {
    u8g.print( String(float((sensor+.5)/4)) + " mSeg. /Estm: " + String(long(float(fc / (sensor+.5) * 4000))) + " Hz ");
  }

}


<64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo=""><-- br="" cierre="" nbsp="" osciloscopio="">
<64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo=""><-- br="" cierre="" nbsp="" osciloscopio=""><64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo=""><-- br="" cierre="" nbsp="" osciloscopio="">

<64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo=""><-- br="" cierre="" nbsp="" osciloscopio="">
<64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo=""><-- br="" cierre="" nbsp="" osciloscopio=""><64 arduino="" br="" con="" nbsp="" osciloscopio="" segundo=""><-- br="" cierre="" nbsp="" osciloscopio="">






Sketch 2. Arduino esclavo ( encargado de la obtención de datos.) Descargar

 


 void setup() {
  Serial.begin(115200);

    }

//////


void loop(void) {

byte punto;

byte y[130];

int sensor;

unsigned long ycal;


  // Muestreo

  
 while( Serial.available()==0){
 }    

   sensor=Serial.read();


 //Prescaler
  //ADPS2 - ADPS1 - ADPS0 - Division Factor
  //0       - 0      - 0         ->2
  //0       - 0      - 1         ->2
  //0       - 1      - 0         ->4    >
  //0       - 1      - 1         ->8    ***
  //1       - 0      - 0         ->16
  //1       - 0      - 1         ->32
  //1       - 1      - 0         ->64
  //1       - 1      - 1         ->128
 
 // A partir de 4 funciona bien, el 2 distorsiona mucho. Cuanto más subimos el osciloscopio es más lento pero más preciso

switch(byte(1+6*sensor/64))
  {
    case 0: //  =2  distorsionado
      bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 1:
     bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 3:
      bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,1);
    break;
    case 4:
    bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 5:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,1);
    break;
    case 6:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 7:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,1);;
    break;
 
  }

 
  //Analog Input A0
ADMUX=(1<<ADLAR)|(0<<REFS1)|(1<<REFS0)|(0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0);



 sensor=sensor*1.2;

  if (sensor ==0) {
  

///  MUESTREO turbo

 ycal = micros();

  //


  y[0] = analogReadFast();
  
    y[1] = analogReadFast();
  
    y[2] = analogReadFast();
  
    y[3] = analogReadFast();
  
    y[4] = analogReadFast();
  
    y[5] = analogReadFast();
  
    y[6] = analogReadFast();
  
    y[7] = analogReadFast();
  
    y[8] = analogReadFast();
  
    y[9] = analogReadFast();
  
    y[10] = analogReadFast();
  
    y[11] = analogReadFast();
  
    y[12] = analogReadFast();
  
    y[13] = analogReadFast();
  
    y[14] = analogReadFast();
  
    y[15] = analogReadFast();
  
    y[16] = analogReadFast();
  
    y[17] = analogReadFast();
  
    y[18] = analogReadFast();
  
    y[19] = analogReadFast();
  
        y[20] = analogReadFast();
  
    y[21] = analogReadFast();
  
    y[22] = analogReadFast();
  
    y[23] = analogReadFast();
  
    y[24] = analogReadFast();
  
    y[25] = analogReadFast();
  
    y[26] = analogReadFast();
  
    y[27] = analogReadFast();
  
    y[28] = analogReadFast();
  
    y[29] = analogReadFast();

        y[30] = analogReadFast();
  
    y[31] = analogReadFast();
  
    y[32] = analogReadFast();
  
    y[33] = analogReadFast();
  
    y[34] = analogReadFast();
  
    y[35] = analogReadFast();
  
    y[36] = analogReadFast();
  
    y[37] = analogReadFast();
  
    y[38] = analogReadFast();
  
    y[39] = analogReadFast();
        y[40] = analogReadFast();
  
    y[41] = analogReadFast();
  
    y[42] = analogReadFast();
  
    y[43] = analogReadFast();
  
    y[44] = analogReadFast();
  
    y[45] = analogReadFast();
  
    y[46] = analogReadFast();
  
    y[47] = analogReadFast();
  
    y[48] = analogReadFast();
  
    y[49] = analogReadFast();
    y[50] = analogReadFast();
  
    y[51] = analogReadFast();
  
    y[52] = analogReadFast();
  
    y[53] = analogReadFast();
  
    y[54] = analogReadFast();
  
    y[55] = analogReadFast();
  
    y[56] = analogReadFast();
  
    y[57] = analogReadFast();
  
    y[58] = analogReadFast();
  
    y[59] = analogReadFast();
    y[60] = analogReadFast();
  
    y[61] = analogReadFast();
  
    y[62] = analogReadFast();
  
    y[63] = analogReadFast();
  
    y[64] = analogReadFast();
  
    y[65] = analogReadFast();
  
    y[66] = analogReadFast();
  
    y[67] = analogReadFast();
  
    y[68] = analogReadFast();
  
    y[69] = analogReadFast();
        y[70] = analogReadFast();
  
    y[71] = analogReadFast();
  
    y[72] = analogReadFast();
  
    y[73] = analogReadFast();
  
    y[74] = analogReadFast();
  
    y[75] = analogReadFast();
  
    y[76] = analogReadFast();
  
    y[77] = analogReadFast();
  
    y[78] = analogReadFast();
  
    y[79] = analogReadFast();
        y[80] = analogReadFast();
  
    y[81] = analogReadFast();
  
    y[82] = analogReadFast();
  
    y[83] = analogReadFast();
  
    y[84] = analogReadFast();
  
    y[85] = analogReadFast();
  
    y[86] = analogReadFast();
  
    y[87] = analogReadFast();
  
    y[88] = analogReadFast();
  
    y[89] = analogReadFast();
        y[90] = analogReadFast();
  
    y[91] = analogReadFast();
  
    y[92] = analogReadFast();
  
    y[93] = analogReadFast();
  
    y[94] = analogReadFast();
  
    y[95] = analogReadFast();
  
    y[96] = analogReadFast();
  
    y[97] = analogReadFast();
  
    y[98] = analogReadFast();
  
    y[99] = analogReadFast();
 y[100] = analogReadFast();
  
    y[101] = analogReadFast();
  
    y[102] = analogReadFast();
  
    y[103] = analogReadFast();
  
    y[104] = analogReadFast();
  
    y[105] = analogReadFast();
  
    y[106] = analogReadFast();
  
    y[107] = analogReadFast();
  
    y[108] = analogReadFast();
  
    y[109] = analogReadFast();
  
    y[110] = analogReadFast();
  
    y[111] = analogReadFast();
  
    y[112] = analogReadFast();
  
    y[113] = analogReadFast();
  
    y[114] = analogReadFast();
  
    y[115] = analogReadFast();
  
    y[116] = analogReadFast();
    y[117] = analogReadFast();
    y[118] = analogReadFast();
    y[119] = analogReadFast();
    y[120] = analogReadFast();
    y[121] = analogReadFast();
    y[122] = analogReadFast();
    y[123] = analogReadFast();
    y[124] = analogReadFast();
    y[125] = analogReadFast();
    y[126] = analogReadFast();
    y[127] = analogReadFast();

  y[128]= (micros() - ycal)/250;

}

else {    // muestreo con retardo
 
 ycal = micros();

  for ( punto = 0; punto <= 127; punto++ ) {


    y[punto]=analogReadFast();
   

    delayMicroseconds(sensor);
  }
  y[128]= (micros() - ycal)/250;
}


  // ENVIO al  otro arduino

  for ( punto = 0; punto <= 127; punto++ ) {
   
  y[129]=max(y[129],y[punto]);  //Pico
   Serial.write(y[punto]);
    
  }
  Serial.write(y[128]); Serial.write(byte(y[129]));


    y[129]=0; // Pico

}

 //Read ADC
int analogReadFast()
{
ADCSRA|=(1<<ADSC);
 // ADSC is cleared when the conversion finishes
 while (bit_is_set(ADCSRA, ADSC));
        return ADCH;
}


viernes, 11 de marzo de 2016

Mini osciloscopio (2KHz) con arduino y lcd QC12864

Este es un intento de osciloscopio con arduino, el nano tiene poca velocidad de proceso y poca memoria, por lo que es muy limitado,  apenas para 1 KHz, pero sirve por ejemplo para ver la onda sinusoidal de la red eléctrica o de un 555 configurado a bajas frecuencias.  Un arduino  DUE sería algo más adecuado para esto por trabajar a 82 Mhz en vez de 16.  También se puede dedicar otro arduino exclusivamente a capturar los datos, mejorandose mucho el rendmiento

El zener de 5 V funciona como protección, pues un voltaje mayor de 5V quemaría el arduino aunque podría afectar negativamente al circuito que vamos a medir, para medir voltajes mayores se puede usar un divisor resistivo y con menores de 5V el zener es prescindible.  La punta de prueba negra va a masa y la morada al + del circuito a visualizar.

Uno de los potenciómetros es para controlar el contraste de la pantalla y el otro controla el tiempo que dura el muestreo de datos, la frecuencia muestrada es solo una estimación parcial  basada  en el numero de picos representados en el tiempo muestreado, por lo que sólo va a ser precisa cuando se vean muchos picos,  el motivo de esta inexactitud es para mentener cierta agilidad en la visualización de nuestro mini osciloscopio..

He incluido una variación del sketch donde se modifica el prescaler del arduino y se consigue un muestreo unas 8 veces más rápido, pero su funcionamiento es algo menos fluido . El valor divisor mínimo que admite sin que la visualización resulte muy afectada es 16, con las pruebas configurado a 32 el funcionamiento ha sido impecable y se ganaba una velocidad de aproximadamente el triple.

A partir de 5 mseg, el comnportamiento del programa cambia, se convierte en un pequeño monitor de la tensión adecuado a otros usos.

Para que funcionen  los sketch hay que tener instalada la librería U8glib.







_______________________________________________________________________________________________________


Visualización de una salida PWM de otro arduino y de su filtrado con condensador de 100uF.

Hemos configurado un segundo arduino  producir una salida de tensión PWM , pudiendola variar  mediante un potenciometro y poder visualizarla. Después la hemos filtrado y vemos como se muestra.

PWM 0.3 V
osciloscopio arduino 

 filtrada con condensador en paralelo:


PWM  3V
filtrada (100uF):


PWM 5V:

Video:






Onda senoidal 50Hz (red eléctrica, a través de unas espiras próximas a un  transformador 12V.)






Onda cuadrada IC 555.






Sketch con el prescaler modificado. Descargar.


#include "U8glib.h"

U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);  //For ST7920_128X64 paralelo

 unsigned long sensor; 

int muestreo;
int x;
int y[130];

boolean monitor;

int y2;
unsigned long ycal;
// unsigned long tpo;

byte punto;
byte y3;

float mx;
byte mc;
byte fc;


void setup(void) {
 
}



void loop(void) {


  u8g.firstPage();

  // Captación de muestreo

  muestreo =analogRead(A1);
 

if (muestreo < 512) {    // Osciloscopio


  monitor=0;
 
             if ( muestreo <256 a="" br="" mecha="" nbsp="" osciloscopio="" toda="">

   switch(byte(4+2*float(muestreo/256)))
  {
    case 0: //  <4 br="" malfuncionamiento="">      bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 1:
    bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 2:
      bitWrite(ADCSRA,ADPS2,0);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,1);
    break;
    case 3:
    bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 4:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,0);  bitWrite(ADCSRA,ADPS0,1);
    break;
    case 5:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,0);
    break;
    case 6:
      bitWrite(ADCSRA,ADPS2,1);  bitWrite(ADCSRA,ADPS1,1);  bitWrite(ADCSRA,ADPS0,1);;
    break;
  }
 
    //Analog Input A0 ADMUX=(1<<ADLAR)|(0<<REFS1)|(1<<REFS0)|(0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0);



 muestreo=muestreo/3;



 // Lectura de datos


   if (muestreo <3 br="" muestreo="" nbsp="" turbo="">
     ycal = micros();


  y[0] = analogRead(A0); 
    y[1] = analogRead(A0); 
    y[2] = analogRead(A0); 
    y[3] = analogRead(A0); 
    y[4] = analogRead(A0); 
    y[5] = analogRead(A0);
    y[6] = analogRead(A0); 
    y[7] = analogRead(A0); 
    y[8] = analogRead(A0); 
    y[9] = analogRead(A0); 
    y[10] = analogRead(A0); 
    y[11] = analogRead(A0); 
    y[12] = analogRead(A0); 
    y[13] = analogRead(A0); 
    y[14] = analogRead(A0); 
    y[15] = analogRead(A0); 
    y[16] = analogRead(A0); 
    y[17] = analogRead(A0); 
    y[18] = analogRead(A0); 
    y[19] = analogRead(A0); 
        y[20] = analogRead(A0); 
    y[21] = analogRead(A0); 
    y[22] = analogRead(A0); 
    y[23] = analogRead(A0); 
    y[24] = analogRead(A0); 
    y[25] = analogRead(A0); 
    y[26] = analogRead(A0); 
    y[27] = analogRead(A0); 
    y[28] = analogRead(A0); 
    y[29] = analogRead(A0);
        y[30] = analogRead(A0);
    y[31] = analogRead(A0); 
    y[32] = analogRead(A0); 
    y[33] = analogRead(A0); 
    y[34] = analogRead(A0); 
    y[35] = analogRead(A0); 
    y[36] = analogRead(A0); 
    y[37] = analogRead(A0); 
    y[38] = analogRead(A0); 
    y[39] = analogRead(A0);
    y[40] = analogRead(A0);
    y[41] = analogRead(A0); 
    y[42] = analogRead(A0); 
    y[43] = analogRead(A0); 
    y[44] = analogRead(A0); 
    y[45] = analogRead(A0); 
    y[46] = analogRead(A0); 
    y[47] = analogRead(A0); 
    y[48] = analogRead(A0); 
    y[49] = analogRead(A0);
    y[50] = analogRead(A0); 
    y[51] = analogRead(A0); 
    y[52] = analogRead(A0); 
    y[53] = analogRead(A0); 
    y[54] = analogRead(A0); 
    y[55] = analogRead(A0); 
    y[56] = analogRead(A0); 
    y[57] = analogRead(A0); 
    y[58] = analogRead(A0); 
    y[59] = analogRead(A0);
    y[60] = analogRead(A0); 
    y[61] = analogRead(A0); 
    y[62] = analogRead(A0); 
    y[63] = analogRead(A0); 
    y[64] = analogRead(A0); 
    y[65] = analogRead(A0); 
    y[66] = analogRead(A0); 
    y[67] = analogRead(A0); 
    y[68] = analogRead(A0); 
    y[69] = analogRead(A0);
    y[70] = analogRead(A0); 
    y[71] = analogRead(A0); 
    y[72] = analogRead(A0); 
    y[73] = analogRead(A0); 
    y[74] = analogRead(A0); 
    y[75] = analogRead(A0); 
    y[76] = analogRead(A0); 
    y[77] = analogRead(A0); 
    y[78] = analogRead(A0); 
    y[79] = analogRead(A0);
    y[80] = analogRead(A0); 
    y[81] = analogRead(A0);
    y[82] = analogRead(A0); 
    y[83] = analogRead(A0); 
    y[84] = analogRead(A0); 
    y[85] = analogRead(A0); 
    y[86] = analogRead(A0); 
    y[87] = analogRead(A0); 
    y[88] = analogRead(A0); 
    y[89] = analogRead(A0);
    y[90] = analogRead(A0);
    y[91] = analogRead(A0);
    y[92] = analogRead(A0);
    y[93] = analogRead(A0);
    y[94] = analogRead(A0);
    y[95] = analogRead(A0);
    y[96] = analogRead(A0);
    y[97] = analogRead(A0);
    y[98] = analogRead(A0);
    y[99] = analogRead(A0);
 y[100] = analogRead(A0);
    y[101] = analogRead(A0);
    y[102] = analogRead(A0);
    y[103] = analogRead(A0);
    y[104] = analogRead(A0);
    y[105] = analogRead(A0);
    y[106] = analogRead(A0);
    y[107] = analogRead(A0);
    y[108] = analogRead(A0);
    y[109] = analogRead(A0);
    y[110] = analogRead(A0);
    y[111] = analogRead(A0);
    y[112] = analogRead(A0);
    y[113] = analogRead(A0);
    y[114] = analogRead(A0);
    y[115] = analogRead(A0);
    y[116] = analogRead(A0);
    y[117] = analogRead(A0);
    y[118] = analogRead(A0);
    y[119] = analogRead(A0);
    y[120] = analogRead(A0);
    y[121] = analogRead(A0);
    y[122] = analogRead(A0);
    y[123] = analogRead(A0);
    y[124] = analogRead(A0);
    y[125] = analogRead(A0);
    y[126] = analogRead(A0);
    y[127] = analogRead(A0);

  mx= (micros() - ycal);

}

else {    // muestreo con rapidez alta
 
 ycal = micros();

  for ( punto = 0; punto <= 127; punto++ ) {

    y[punto]=analogRead(A0);
  
     delayMicroseconds(muestreo);
  }
 
  mx= (micros() - ycal);
  
 
  }

sensor = mx;   // tpo muestreo
 
   } // fin muestreo os. seg arduino

 

   else {   // muestreo rapidez media

  
mx=micros();

ycal=9*(muestreo-256); // calibrado tiempo

 for ( punto = 0; punto <= 127; punto++ ) {  //muestreo pinA0 arduino maestro
    x=1;
    y[punto] = analogRead(A0);

   retardo0();

  }

 sensor= (micros()-mx);


 }          // fin osciloscopio


 
  /// Estimación frecuencia   f= picos/tpo muestreo

     mx=0;
 
for ( punto = 0; punto <= 127; punto++ ) {
 
     mx=max(mx,y[punto]);
 
  }
 

 
  fc = 0;
 
  mx = mx*.9  ;  // Pico > 10%


  for ( punto = 0; punto <= 127; punto++ ) {

    if ( (mx < y[punto]) && (mc == 0)) {
      fc = fc + 1;
      mc = 1;
    }

    if (y[punto] < mx) {
      mc = 0;
    }
  }
}                          // <-- br="" cierre="" nbsp="" osciloscopio="">


else {                         // monitoreo del pin A0

   monitor=1;

mx=millis();

   y[128]=0; //media total

x=100;


  y[127]=analogRead(A0);
  retardo();

  ycal=0;
 
   for ( punto = 0; punto <= 126; punto++ ) {
  
 y[punto]=y[punto+1];

       ycal=ycal+y[punto];
  }


  mx=millis()-mx;

y[128]=(ycal+y[127])/128;

}                    // cierre de monitoreo

  /// Dibujar

  do {

    draw();
  } while ( u8g.nextPage() );


  // delay(5000);   // Para congelar imagen entre muestreo y muestreo. Puede ser interesante controlar este parametro mediante potenciómetro.



}


void retardo0()    // retardo osciloscopio arduino maestro
{
   if (x   y[punto]=(analogRead(A0)+y[punto])/2;
  x=x+2;
     retardo0();
   }

}

void retardo()   // retardo monitor
{

if (x<((30*(analogRead(A1)-512)))) {
    y[127]=((analogRead(A0))+y[127])/2;
  x=x+1;
retardo();
}

}

///////////////////    GRAFICA

void draw(void) {

  // graphic commands to redraw the complete screen should be placed here

  // u8g.drawFrame(0,0,128,56);  //marco exterior

  for ( punto = 21; punto <= 106; punto = punto + 42 ) {       // punto vertical cada 1V

    u8g.drawPixel(punto, 10);  u8g.drawPixel(punto, 21); u8g.drawPixel(punto, 32); u8g.drawPixel(punto, 43);

  }

 u8g.setFontPosTop();
 

  // Grafica de la onda

  y3 = 55 - 27 * float(y[0]) / 512;  ///  54/1024

  for ( punto = 1; punto <= 127; punto++ ) {


    ycal = 55 - 28 * float(y[punto]) / 512;    ///  54/1024


    u8g.drawLine(punto - 1, y3, punto, ycal);

    y3 = ycal;
  }


  // Leyenda

  u8g.setFont(u8g_font_04b_03);

  u8g.setPrintPos(0, 56);
 
  if (monitor==1){

    u8g.print(String(float(y[127])*5/1024) +"V.  /"+ String(float(.19+mx/1000)) + " Seg.  Med: "+String(float(y[128])*5/1024)+"V.");   ///   x5V
  }
  else {
    u8g.print( String(float((sensor+.5)/1000)) + " mSeg. /Estm: " + String(long(float(1000000*fc/(sensor+.5) ))) + " Hz ");
  }

}


int analogReadFast()
{
 ADCSRA|=(1<<ADSC);
 // ADSC is cleared when the conversion finishes
 while (bit_is_set(ADCSRA, ADSC));
        return ADCH;
}




domingo, 29 de noviembre de 2015

Monitoreo sensor de distancia con Qc12864-B

   SKETCH



    #include "U8glib.h"
   

    U8GLIB_ST7920_128X64_1X u8g(6, 5, 4 ,7); // CONEXION SERIE
 
   
  
    float sensor=1025 ;
   
    byte x;
    float y[128];
    byte punto;
    long distancia;
long tiempo;
   
    void draw(void) {
      // graphic commands to redraw the complete screen should be placed here 
     
    u8g.drawFrame(0,0,128,56);
      u8g.setFont(u8g_font_04b_03);
      u8g.setFontPosTop();
    u8g.drawStr(0, 56, "Distanc:");
    u8g.setFontPosTop();
   
    // punto
   
for( punto = 1; punto <= 127; punto++ ) {
  
   u8g.drawPixel(punto,55-54*y[punto]/1024);


}
    // barra de nivel
   
    u8g.drawFrame(32,57,75,6);
    u8g.drawBox(33,58,74*(sensor/1024),4);
    u8g.setColorIndex(0);
    u8g.drawBox(33+74*(sensor/1024),58,73-74*(sensor/1024),4);
    u8g.setColorIndex(1);
    //u8g.drawFrame(32,57,75,6);
   
    //leyenda
     
   
     String s =  String(int( distancia)) ;
       
 u8g.setPrintPos(109, 56);
  u8g.print(s);
 //  u8g.drawStr(109, 56, s);
     }
   
    void setup(void) {
 //      Serial.begin(9600);

pinMode(9, OUTPUT); /*activación del pin 9 como salida: para el pulso ultrasónico*/
  pinMode(8, INPUT); /*activación del pin 8 como entrada: tiempo del rebote del ultrasonido*/
         
                  
    }
   
    void loop(void) {
      // picture loop
   
   u8g.firstPage();  

       digitalWrite(9,LOW); /* Estabilización del sensor*/
  delayMicroseconds(5);
  digitalWrite(9, HIGH); /* envío del pulso */
  delayMicroseconds(10);
  tiempo=pulseIn(8, HIGH);
  distancia= int(0.017*tiempo);
     
   
      sensor=1024*distancia/338;
    
    // 
    x= x+1;
    if (x>=126) {
     x=1;
     }
    y[x]=(sensor);

   
    for( punto = 1; punto <= 127; punto++ ) {

    }
    //  // rebuild the picture after some delay
      do {
        draw();
      } while( u8g.nextPage() );
   
   
     
   
   
     // delay(100);
    }




CONEXIONES:
IMPORTANTE: Para conectar en serie con el arduino y no quemar nada tube que desoldar dos resistencias como indico aquí. No hay que hacelo con todos los LCD, pero con mi modelo de lcd de no hacerlo se puede quemar.


lunes, 16 de noviembre de 2015

Monitoreo de un sensor con QC12864-B y arduino.(Conexión serie.)




En este caso, por  simplicidad y dejar libre el mayor número de pines, hemos utilizado comunicación serie entre el arduino y el LCD.  En mi modelo, el QC1286-B-1, para poder hacerlo hay que quitar un par de resistencias de 0 Ohmios de la trasera del LCD: R9 y R11, y esto es importante porque de no hacerlo estaremos puenteando los 5V con masa y en el mejor de los casos no va a funcionar, y en el peor nos  cargaremos el arduino y/o el LCD. 

IMPORTANT! For this LCD to work using this method, you need to de-solder R9 and R11 at the back panel of the LCD.

Por lo que he visto en internet, en la misma pagina donde saqué la información del desoldado  , en otros proyectos podremos seguir usando nuestro LCD en modo paralelo uniendo el pin PSD  a la salida 5V, tal y como se hacía con otros modelos anteriores de QC12864 . (5V+.conexión paralelo y a masa para serie). Quien tenga uno de los  modelos más antiguos no va a tener  que hacerles nada porque ya vienen sin el puenteo de estas resistencias.






También puede usarse en modo paralelo, por lo que se gana algo en velocidad, pero tan poca que no merece la pena sacrificar esos 8 pines ni el cableado, como ventaja no hay que desoldar nada, pero las conexiones que yo indico en el esquema  para paralelo no sirven y habrá que hacer otras, también utilizará 7 ó 8  pines más del arduino, de ahí la conveniencia de usar la conexión en serie.



Conexiones.


Para simular el sensor he representado un potenciómetro, el de arriba de la imagen. El de la parte inferior será de 10K y sirve para elegir el contraste adecuado.

La foto de los pines es la parte trasera del LCD, lo que queda abajo, entonces una vez apollada en el protoboard la parte de arriba corresponde con la derecha del esquema de conexiones y la de abajo con la izquierda.

 





El sketch
El programa está basado en la librería u8glib , que puede descargarse aquí y permite dibujar gráficos no sólo en el
QC12864, sino también en otros muchos modelos, tanto en conexión serie como paralelo.
Modificando el Delay del final el escanéo puede ser ralentizado.  La lectura que muestra es la que lee la entrada analógica, esto es entre 0 y 1024  que equivalen de  0 a 5V,



      https://www.youtube.com/watch?v=pQ-HUbdc4Cg
    #include "U8glib.h"
  

    U8GLIB_ST7920_128X64_1X u8g(6, 5, 4 ,7);  // For ST7920_128X64  serie - QC12864
    //     U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);  //For ST7920_128X64   paralelo
  
    float sensor=1025 ;
  
    byte x;
    float y[128];
    float y2;
    float ycal;
    byte punto;
  
    void draw(void) {
    
      // graphic commands to redraw the complete screen should be placed here
    
    u8g.drawFrame(0,0,128,56);
      u8g.setFont(u8g_font_04b_03);
      u8g.setFontPosTop();
    u8g.drawStr(0, 56, "Sensor:");
    u8g.setFontPosTop();
  
    // punto
  
for( punto = 1; punto <= 127; punto++ ) {
 
   ycal=55-54*y[punto]/1024;
   u8g.drawLine(punto-1,y2,punto,ycal);

 y2=ycal;
}
    // barra de nivel
  
    u8g.drawFrame(32,57,75,6);
    u8g.drawBox(33,58,74*(sensor/1024),4);
    u8g.setColorIndex(0);
    u8g.drawBox(33+74*(sensor/1024),58,73-74*(sensor/1024),4);
    u8g.setColorIndex(1);

  
    // Lectura en número    
  
     String s =  String(int( sensor)) ;
      
 u8g.setPrintPos(109, 56);
  u8g.print(s);

     }



    ////////////////////
  
    void setup(void) {

    
      // assign default color value
      if ( u8g.getMode() == U8G_MODE_R3G3B2 )
        u8g.setColorIndex(255);     // white
      else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
        u8g.setColorIndex(3);         // max intensity
      else if ( u8g.getMode() == U8G_MODE_BW )
        u8g.setColorIndex(1);         // pixel on
  
                 
    }
  
    void loop(void) {
      // picture loop
  
   u8g.firstPage(); 

   
         //u8g.prepare();
       
      sensor=analogRead(A0);
   
    //   Posición x


    for( x= 0; x <= 126; x++ ) {
    y[x]= y[x+1];
  
         }
       
    y[127]=(sensor);

/// Dibujar

      do {
        draw();
      } while( u8g.nextPage() );
 
  
     // delay(100);
    }

domingo, 11 de agosto de 2013

Mapas geológicos de España en el GPS del movil.

Dos de mis tres pasiones son las geología y la informatica y llevaba tiempo dando vueltas a como meter los mapas del IGME en el movil y así saber exactamente sobre que terreno  me hallo gracias al GPS.  quizá halla otras formas, pero esta es relativamente  rápida y sencilla.

Necesitamos instalar en el movil la aplicación para GPS  Track@way, sirve que sea la versión Free,  yo recomendaría familiarizarse bien con ella antes de nada porque su uso aunque se coge rápido requiere algún aprendizaje.

Y  luego descargar de la web del Instituto geografico nacional las hojas que queramos tener en el movil,  podemos descargarlas en la escala que queramos hasta la 1:50000 que es la que a mi me  parece más práctica.




Una vez descargada la hoja y metida en la tarjeta del movil, arrancamos la aplicación Track@way.

Esta es una aplicación muy completa para GPS que permite entre otras cosas grabar recorridos o importar rutas de terceros y de páginas como wikiloc y ver en el campo donde estamos situados en un mapa.
Usa mapas que descarga mediante la conexión a internet o  grabados previamente en la memoria, y es esta última función la que aprovecharemos para tener el mapa geológico en el telefono.

______________________________________________________________________________________________

Las capacidades que vamos a aprovechar del programa son que permite utilizar imagenes, en este caso un mapa y si conocemos las coordenadas cartográficas de sus esquinas los va a situar correctamente en la posición que ocuparía en la superficie terrestre ( Georeferenciación )  y mira  por donde las hojas del mapa geológico tienen en sus cuatro esquinitas acompañando cual si fueran los angelitos que acompañan mi cama, las coordenadas de la latitud y longitud de esa misma esquina.


Bién, despues de toda esta arida introducción vamos al tajo que es  lo que interesa, puede parecer complicado pero haciendo bien los pasos en 5 minutos tendremos una hoja en el GPS, con la leyenda incluida:



 1º - Con la aplicación Trackaway abierta abrimos el gestor de mapas del menu inferior,   luego pulsamos Import para poder importar la hoja del mapa geológico,   Add maps..  y seleccionamos la hoja del IGME que hemos descargado.



Pulsamos el   Importar !  de abajo y la aplicación hará las gestiones necesarias para poder utilizar la imagen.


2º.  Ahora que ya tenemos la imagen cargada en Phone, cliclamos sobre el nombre del mapa para poder calibrarlo, es decir, indicar al programa sobre que coordenadas de latitud y longitud deberá dibujar la imagen.


Pulsamos Calibración manual...



Y aparecerá la imagen del mapa, ahora viene lo más complicado, hemos de ir a cada una de las 4 esquinas del mapa y anotar las latitudes y longitudes porque luego tenemos que introducirlas manualmente.


,

Ahora movemos el mapa para situar cada esquina sobre el puntito rojo central, una vez situada una, cliclamos la +, superior y aparecerá la pantalla donde introducir las coordenadas:




Ahí escribiremos las coordenadas previamente anotadas, proceso que habrá que repetir con cada una de las 4 esquinas, damos a Confirmar y luego a Guardar,



3º-  Repetimos con las otras tres esquinas, sin olvidarnos de que en la mayoría de España la longitud es Oeste y tendremos que cambiar el aspa que viene por defecto.

Damos a guardar las veces que haga falta, 



4º-  Cambiamos a la visualización de mapas del menu inferior y ya podemos ver el mapa en el GPS.  Si este no aparece donde debiera seguramente habrá un error en alguan coordenada o es que habremos olvidado marcar Oeste




Por experiencia própia y debido a que estos mapas fueron escaneados de papel he observado pequeñas diferencias de decenas de metros o incluso cientos que pude corregir superponiendo uno de los mapas que trae la aplicación y restando la diferencia de   grados de un mismo punto entre un mapa y otro  y después  volviendola a introducir según la forma descrita.

Por otro lado las hojas conservan las leyendas originales   y los cortes geológidos de las hojas Magna  para poder consultarlas,   pero si cargamos varios mapas contiguos estos se van a solapar y habrá que activar la visulización de unos u otros en el gestor de mapas y después refrescar la pantalla del visualizador con el icono de mapas de la parte superior derecha.


El programa para android:

http://www.trackaway.org/index.php/download-for-android/summary/3-android-releases/13-track-wayfree-2-1-5-for-android


 Mapas del Alto Tajo ( Cuenca- Guadalajara ) e instrucciones para instalar.

 https://drive.google.com/file/d/0B5-j5Fx18jbwb1JHQnctaDAtems/view?usp=sharing