Peleando con pingüinos.: LCD QC12864B-2

Mostrando entradas con la etiqueta LCD QC12864B-2. Mostrar todas las entradas

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;
   }
   }
}

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

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);
    }