Pages: [1]   Go Down
Author Topic: Voltage Time Graph - GLCD (192x64)  (Read 1258 times)
0 Members and 1 Guest are viewing this topic.
Devon, UK
Offline Offline
Full Member
***
Karma: 4
Posts: 234
Arduino rocks my socks, yes the socks are rocking!
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Hi all,
I refrain from calling this a scope on this forum because we know it isn't, but it is quite close to what an Arduino could call a scope, right?  smiley-wink
Anyway, there is now a video on YouTube.  I am going to try to add some logging to it, but I need a new thermistor first (I might have melted the last one, hense the croc clip as a probe smiley-razz)

Anyway, here is the video:

[media]http://www.youtube.com/watch?v=FTFTgq19RPM[/media]

/me
Logged

Phoenix, Arizona USA
Offline Offline
Faraday Member
**
Karma: 39
Posts: 5557
Where's the beer?
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

A few comments:

1) Nice - and ugly - but nice!
2) Get a tripod...
3) Get a macro lens...
4) Get me outta here!
5) Code? Schematic? Please?

Seriously - that looks interesting, it was hard to follow what was going on with all the bouncing around, but the basics could be seen.

Something that I have thought about doing (but will probably never get around to) is using an Arduino and a GLCD to create a simple digital logic analyser; basically quickly sampling one port (6 bits) for HIGH/LOW transitions using direct port I/O in the quickest manner possible (likely using an unrolled loop), and storing the results in memory (triggered off one of the pins in the port, an internal trigger, or a different external trigger pin), then showing the results on the GLCD (scrolling, zooming, examining different pins side-by-side, allowing for a dump to the serial port, etc).

While it wouldn't be fast, for most users of the Arduino I think it could be very useful...

 smiley
Logged

I will not respond to Arduino help PM's from random forum users; if you have such a question, start a new topic thread.

Lancashire, UK
Offline Offline
Edison Member
*
Karma: 9
Posts: 1991
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
5) Code? Schematic? Please?

Times two.....  smiley
Logged


Devon, UK
Offline Offline
Full Member
***
Karma: 4
Posts: 234
Arduino rocks my socks, yes the socks are rocking!
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

The code has developed from when this was shot (only hours ago) - sorry about the shakey camera man, but it was the best I could do (am student therefore skint)

Code:
Code:
#include <EEPROM.h>
#include <ks0108.h>
#include "SystemFont5x72.h"  // system font
#include "ArduinoIcon.h"     // bitmap

unsigned long startMillis;
unsigned int loops = 0;
unsigned int iter = 0;
int Benchcount = 0;
int InputPin = 5;
int PlotVoltage = 0;
int VoltageValue = 0;
int DisplayFromEEPROM = 1;  // 0 = Record, 1 = Display
int EEPROMPosition = 0;     // Store the current location in memory.
int d = 1;
  int p = 0;
  int x = 0; //x graph coordinate
  int y = 0; //y graph coordinate
  int a = 0; //old x graph coordinate
  int b = 0; //old y graph coordinate

int delayTime = 1000;        // Change how often data is recorded (will change recording duration - total (MS) = 512 * delayTime)

// Get things ready
void setup(){
  GLCD.Init(NON_INVERTED);   // initialise the library, NON_INVERTED writes pixels onto a "white screen"
  GLCD.ClearScreen();        // Clear the GLCD Screen memory ready for drawing on.
  GLCD.SelectFont(new_Font); // switch to fixed width system font
}


void  loop(){   // run over and over again
  // TODO:
  //  o Add a physical toggle for read/record
  //  o Add more information down the right side
  //    - High
  //    - Low
  //    - Mode (playback, reccording)
  //  o Add some welcome images and even Images
  //  o Maybe add Mass storage for logging
  //  o Add another line from another pin out?
  //  o Serial out the readings
  //  o Add a pause between readings so the memory doesn't fill so quickly
  //     and more information is on the graph
  //      - Ajustable by a POT
  //      - Change the playback speed for long "exposure" graphs, so time travels faster.
  //  o Buy a Thermistor and perhaps record tempreture
    
  //Dotted Line to Center Plot Graph Area Horizontally
  d = 0;
  for (int i=0; i <= 63; i++){ //dotted graph line
    GLCD.SetDot(d, 32, BLACK);
    d = d + 2;
  }

  GLCD.DrawRect(0,0,128,63, BLACK);
  
  static float p;
  static float x;
  
  // Erase Previous Information Panel Pixels
  GLCD.FillRect(129, 0, 64, 62, WHITE);
  
  if(DisplayFromEEPROM == 0)
  {
    //Read input
    PlotVoltage = analogRead(InputPin);  // Each byte of EEPROM memory can hold 1 reading. So a ATMega 328 can store 512 readings.  About 3 screens full.
    
    if(EEPROMPosition > 511)
    {
     EEPROMPosition = 0;
    }
    //Record Input
    EEPROM.write(EEPROMPosition, PlotVoltage / 4);
    
    GLCD.GotoXY(130,22);
    GLCD.Puts("Recording");
  }
  else
  {
    if(EEPROMPosition > 511)
    {
     GLCD.ClearScreen();
     GLCD.CursorTo(0,0);
     GLCD.Puts("End of memory, restarting");
     GLCD.CursorTo(0,2);
     GLCD.Puts("To change record speed please");
     GLCD.CursorTo(0,3);
     GLCD.Puts("edit the loop delay.");
     delay(5000);
     GLCD.ClearScreen();
     EEPROMPosition = 0;
    }
    GLCD.GotoXY(130,22);
    GLCD.PutChar(127);// 127 the address of the Play symbol in the "System" font.
    GLCD.Puts("Playback");
    
    // Read Input
    PlotVoltage = EEPROM.read(EEPROMPosition) * 4;
  }
  
  //Move on the EEPROM Read Location
  EEPROMPosition++;
  
  VoltageValue = (PlotVoltage / 2.04799979);
  int whole = VoltageValue / 100;
  int fraction = VoltageValue - whole * 100;
    
  // Write the progress through the memory (reading or writing)
  GLCD.GotoXY(130, 34);
  int progress =  EEPROMPosition * 0.1953125;
  GLCD.PrintNumber(progress);
  GLCD.Puts("%  Prog");
  
  //Draw Rectangles on top and bottom corners to display RAW Data from Analog Reading
  GLCD.GotoXY(130,02);
  GLCD.Puts("Bin: ");
  GLCD.PrintNumber(PlotVoltage);          

  GLCD.GotoXY(130, 12);
  GLCD.Puts("");
  GLCD.PrintNumber(whole);
  GLCD.PutChar('.');
  GLCD.PrintNumber(fraction);
  GLCD.GotoXY(158, 12);
  GLCD.Puts("Volt");
  
  if (PlotVoltage > p){ //print peak graph value
     // GLCD.FillRect(97, 05, 29, 10, WHITE);
     // GLCD.GotoXY(98,119);
     // GLCD.PrintNumber(PlotVoltage);
     p = PlotVoltage;
  }
  
 //Add Scaling...Bottom most line (y=63 is 0V, y=1 is 5V)
 GLCD.DrawLine(0, 0, 0, 63, BLACK);  //Line for Scaleing Tally Marks
 GLCD.DrawLine(0, 0, 4, 0, BLACK);   //Topmost Mark
 GLCD.DrawLine(0, 8, 2, 8, BLACK);
 GLCD.DrawLine(0, 16, 4, 16, BLACK);
 GLCD.DrawLine(0, 24, 2, 24, BLACK);
 GLCD.DrawLine(0, 32, 4, 32, BLACK); //Center Mark
 GLCD.DrawLine(0, 40, 2, 40, BLACK);
 GLCD.DrawLine(0 ,48, 4, 48, BLACK);
 GLCD.DrawLine(0, 56, 2, 56, BLACK);
 GLCD.DrawLine(0, 63, 4, 63, BLACK);//BottomMost Mark

  
  int y = 63 - (PlotVoltage /16);   //y coordinate of graph curve  ***Careful when adjusting the '/16' part. Y should be where you want the lowest reading displayed and
  if(b == 0){                       //                            the divisor number adjusts the scaleing (sensitivity) based on where that line is...
  b = y;                            //                            The lower the number, the higher sensitivity/max reading is plotted on graph
  }
  
  GLCD.DrawLine(a,b,x,y, BLACK);
  x++;                              // Add 1 to old x coordinate for line drawing in right direction
  
  if (x == 128){                    //clean screan when graph cycle will start again from left
  GLCD.ClearScreen();
  x = 0;                            //x coordinate to start graph from left again

  }
  
  a = x;                           //old x coordinate to use for drawing line to new x coordinate
  b = y;                           //old y coordinate to use for drawing line to new y coordinate
  
  delay(delayTime);                //Make the memory "last" longer by taking readins less often
}

I modified the code out of a post from Metalfan1185.  I changed it to support 192x64 screen size, then I added some recording and commented it a little more.  After this you can see my todo list.  Originally the delay in the loop wasn't explicit but caused by calculation time, I have added a delay (and ajustablility) to the loop too to change the recording duration.

Data is automatically logged in the EEPROM, if you have anything important in yours I suggest you comment out the writing part should you run the program.
[edit]I may also buy an EEPROM chip standalone for the storage (as opposed to an SD card) and perhaps show elapsed time too.[/edit]
« Last Edit: April 27, 2010, 03:59:13 pm by Gray_Malkin » Logged

Pages: [1]   Go Up
Jump to: