Go Down

### Topic: persistence of vision (POV) Code? (Read 13046 times)previous topic - next topic

#### peps

##### Jan 17, 2009, 11:09 am
Hello guys and girls, am building a 8 led POV, but Im a little stuck when it comes to the programming.

any chance someone can point me in the right direction for a idiots guide?
(this is my first project with the Arduino so please go slow on me!  )

#### peps

#1
##### Jan 18, 2009, 04:48 pm
Really, no ones going to help a girl out......?

Im I even asking in the right section?

#### halley

#2
##### Jan 18, 2009, 05:12 pmLast Edit: Jan 18, 2009, 05:13 pm by halley Reason: 1
Well, saying you're "a little stuck" isn't much of a clue as to how much you understand programming in general.  Have you done the usual tutorials, such as Blink and AnalogInput?  Do you know how to hook up multiple LEDs to multiple outputs?  Do you do any programming on non-Arduino devices or computers?  Do you understand how numbers are encoded into binary bits?  Have you seen the non-Arduino POV kits, such as those that LadyAda sells, so you're familiar with the concepts?

For POV, the general idea is to store your "image" into a sequence of columns, and each column should be stored in such a way as to efficiently send them to a column of LEDs all at once.  Finally, the main loop of your program should just start pushing out your image, one column at a time, through the whole pattern.

Code: [Select]
`........    B00000000    0x00.****...    B01111000    0x78...*.*..    B00010100    0x14...*..*. -> B00010010    0x12...*.*..    B00010100    0x14.****...    B01111000    0x78........    B00000000    0x00`

Can you see the "A"?  Do you see the "A" in the binary bits also?

#### peps

#3
##### Jan 18, 2009, 08:11 pm
Quote
Well, saying you're "a little stuck" isn't much of a clue as to how much you understand programming in general.  Have you done the usual tutorials, such as Blink and AnalogInput?

Yes, i have done a few of them like the blink and the "Knight Rider" loop

Quote
]Do you know how to hook up multiple LEDs to multiple outputs?
Yes i believe so....i designed this schematic based on the RBB and "Knight Rider" to work as a stand alone POV (but it may well be very floored)

Quote
Do you do any programming on non-Arduino devices or computers?

only HTML

Quote
Do you understand how numbers are encoded into binary bits?
is this BCD? as in:
0=0000
1=0001
2=0010
3=0011
4=0100
5=0101

if so I am aware of the theory, but have have 0 experience with application.

Quote
]Have you seen the non-Arduino POV kits, such as those that LadyAda sells, so you're familiar with the concepts?

Yes im familiar with the concept and electronics, its just the issue of the code im totally out of my depth with.

For POV, the general idea is to store your "image" into a sequence of columns, and each column should be stored in such a way as to efficiently send them to a column of LEDs all at once.  Finally, the main loop of your program should just start pushing out your image, one column at a time, through the whole pattern.

Code: [Select]
`........    B00000000    0x00.****...    B01111000    0x78...*.*..    B00010100    0x14...*..*. -> B00010010    0x12...*.*..     B00010100    0x14.****...    B01111000    0x78........    B00000000    0x00`

Quote

Can you see the "A"?  Do you see the "A" in the binary bits also?

yes i see the A  ........so B would be

. . . . . . . .   B00000000
********    B11111111
*. . . *. . *   B10001001
*. . . *. . *   B10001001
*. . . *. . *   B10001001
. *** . **.   B01110110
. . . . . . . .   B00000000

but what are the  0x00,  0x78, 0x14 ect. and how would the above code for A or B fit into the sketch, and is it possible to code a full alphabet onto the sketch, but have a command line that you can just quickly adjust to tell it what word to spell?

thank you

#### Mulder

#4
##### Jan 19, 2009, 10:34 am
I found this font (stored in font.h) in the internet, it uses 7 leds.... after i finished mine half.... *arg*

Code: [Select]
`const byte font[][5] = {            {0x00,0x00,0x00,0x00,0x00},   //   0x20 32            {0x00,0x00,0x6f,0x00,0x00},   // ! 0x21 33            {0x00,0x07,0x00,0x07,0x00},   // " 0x22 34            {0x14,0x7f,0x14,0x7f,0x14},   // # 0x23 35            {0x00,0x07,0x04,0x1e,0x00},   // \$ 0x24 36            {0x23,0x13,0x08,0x64,0x62},   // % 0x25 37            {0x36,0x49,0x56,0x20,0x50},   // & 0x26 38            {0x00,0x00,0x07,0x00,0x00},   // ' 0x27 39            {0x00,0x1c,0x22,0x41,0x00},   // ( 0x28 40            {0x00,0x41,0x22,0x1c,0x00},   // ) 0x29 41            {0x14,0x08,0x3e,0x08,0x14},   // * 0x2a 42            {0x08,0x08,0x3e,0x08,0x08},   // + 0x2b 43            {0x00,0x50,0x30,0x00,0x00},   // , 0x2c 44            {0x08,0x08,0x08,0x08,0x08},   // - 0x2d 45            {0x00,0x60,0x60,0x00,0x00},   // . 0x2e 46            {0x20,0x10,0x08,0x04,0x02},   // / 0x2f 47            {0x3e,0x51,0x49,0x45,0x3e},   // 0 0x30 48            {0x00,0x42,0x7f,0x40,0x00},   // 1 0x31 49            {0x42,0x61,0x51,0x49,0x46},   // 2 0x32 50            {0x21,0x41,0x45,0x4b,0x31},   // 3 0x33 51            {0x18,0x14,0x12,0x7f,0x10},   // 4 0x34 52            {0x27,0x45,0x45,0x45,0x39},   // 5 0x35 53            {0x3c,0x4a,0x49,0x49,0x30},   // 6 0x36 54            {0x01,0x71,0x09,0x05,0x03},   // 7 0x37 55            {0x36,0x49,0x49,0x49,0x36},   // 8 0x38 56            {0x06,0x49,0x49,0x29,0x1e},   // 9 0x39 57            {0x00,0x36,0x36,0x00,0x00},   // : 0x3a 58            {0x00,0x56,0x36,0x00,0x00},   // ; 0x3b 59            {0x08,0x14,0x22,0x41,0x00},   // < 0x3c 60            {0x14,0x14,0x14,0x14,0x14},   // = 0x3d 61            {0x00,0x41,0x22,0x14,0x08},   // > 0x3e 62            {0x02,0x01,0x51,0x09,0x06},   // ? 0x3f 63            {0x3e,0x41,0x5d,0x49,0x4e},   // @ 0x40 64            {0x7e,0x09,0x09,0x09,0x7e},   // A 0x41 65            {0x7f,0x49,0x49,0x49,0x36},   // B 0x42 66            {0x3e,0x41,0x41,0x41,0x22},   // C 0x43 67            {0x7f,0x41,0x41,0x41,0x3e},   // D 0x44 68            {0x7f,0x49,0x49,0x49,0x41},   // E 0x45 69            {0x7f,0x09,0x09,0x09,0x01},   // F 0x46 70            {0x3e,0x41,0x49,0x49,0x7a},   // G 0x47 71            {0x7f,0x08,0x08,0x08,0x7f},   // H 0x48 72            {0x00,0x41,0x7f,0x41,0x00},   // I 0x49 73            {0x20,0x40,0x41,0x3f,0x01},   // J 0x4a 74            {0x7f,0x08,0x14,0x22,0x41},   // K 0x4b 75            {0x7f,0x40,0x40,0x40,0x40},   // L 0x4c 76            {0x7f,0x02,0x0c,0x02,0x7f},   // M 0x4d 77            {0x7f,0x04,0x08,0x10,0x7f},   // N 0x4e 78            {0x3e,0x41,0x41,0x41,0x3e},   // O 0x4f 79            {0x7f,0x09,0x09,0x09,0x06},   // P 0x50 80            {0x3e,0x41,0x51,0x21,0x5e},   // Q 0x51 81            {0x7f,0x09,0x19,0x29,0x46},   // R 0x52 82            {0x46,0x49,0x49,0x49,0x31},   // S 0x53 83            {0x01,0x01,0x7f,0x01,0x01},   // T 0x54 84            {0x3f,0x40,0x40,0x40,0x3f},   // U 0x55 85            {0x0f,0x30,0x40,0x30,0x0f},   // V 0x56 86            {0x3f,0x40,0x30,0x40,0x3f},   // W 0x57 87            {0x63,0x14,0x08,0x14,0x63},   // X 0x58 88            {0x07,0x08,0x70,0x08,0x07},   // Y 0x59 89            {0x61,0x51,0x49,0x45,0x43},   // Z 0x5a 90            {0x3c,0x4a,0x49,0x29,0x1e},   // [ 0x5b 91            {0x02,0x04,0x08,0x10,0x20},   // \ 0x5c 92            {0x00,0x41,0x7f,0x00,0x00},   // ] 0x5d 93            {0x04,0x02,0x01,0x02,0x04},   // ^ 0x5e 94            {0x40,0x40,0x40,0x40,0x40},   // _ 0x5f 95            {0x00,0x00,0x03,0x04,0x00},   // ` 0x60 96            {0x20,0x54,0x54,0x54,0x78},   // a 0x61 97            {0x7f,0x48,0x44,0x44,0x38},   // b 0x62 98            {0x38,0x44,0x44,0x44,0x20},   // c 0x63 99            {0x38,0x44,0x44,0x48,0x7f},   // d 0x64 100            {0x38,0x54,0x54,0x54,0x18},   // e 0x65 101            {0x08,0x7e,0x09,0x01,0x02},   // f 0x66 102            {0x0c,0x52,0x52,0x52,0x3e},   // g 0x67 103            {0x7f,0x08,0x04,0x04,0x78},   // h 0x68 104            {0x00,0x44,0x7d,0x40,0x00},   // i 0x69 105            {0x20,0x40,0x44,0x3d,0x00},   // j 0x6a 106            {0x00,0x7f,0x10,0x28,0x44},   // k 0x6b 107            {0x00,0x41,0x7f,0x40,0x00},   // l 0x6c 108            {0x7c,0x04,0x18,0x04,0x78},   // m 0x6d 109            {0x7c,0x08,0x04,0x04,0x78},   // n 0x6e 110            {0x38,0x44,0x44,0x44,0x38},   // o 0x6f 111            {0x7c,0x14,0x14,0x14,0x08},   // p 0x70 112            {0x08,0x14,0x14,0x18,0x7c},   // q 0x71 113            {0x7c,0x08,0x04,0x04,0x08},   // r 0x72 114            {0x48,0x54,0x54,0x54,0x20},   // s 0x73 115            {0x04,0x3f,0x44,0x40,0x20},   // t 0x74 116            {0x3c,0x40,0x40,0x20,0x7c},   // u 0x75 117            {0x1c,0x20,0x40,0x20,0x1c},   // v 0x76 118            {0x3c,0x40,0x30,0x40,0x3c},   // w 0x77 119            {0x44,0x28,0x10,0x28,0x44},   // x 0x78 120            {0x0c,0x50,0x50,0x50,0x3c},   // y 0x79 121            {0x44,0x64,0x54,0x4c,0x44},   // z 0x7a 122            {0x00,0x08,0x36,0x41,0x41},   // { 0x7b 123            {0x00,0x00,0x7f,0x00,0x00},   // | 0x7c 124            {0x41,0x41,0x36,0x08,0x00},   // } 0x7d 125            {0x04,0x02,0x04,0x08,0x04},   // ~ 0x7e 126      };`

this is my complete code, hope that helps.... im a noob too, so the code is not very clean.... i also have another version where i use bitwise operatosr and the PORTs instead of digitalWrite and an interrupt to start the writing instead of the loop...

Code: [Select]
`#undef int() // fixes a bug with the stdio.h#include <stdio.h> // gives access to function sprintf#include "font.h";//constant definition#define charHeight   7#define charWidth    5#define colDelay   250#define debounce    20#define bufferSize  50#define ledPin      13#define inPin        2//const int povPins[] = {2,3,4,5,6,7,8};const int povPins[] = {9,8,7,6,5,4,3};//variable definitionint switchValue               = 0;int revolutions               = 0;long lastCycleStart           = 0;char stringBuffer[bufferSize] = "I am a very long text! Hopefully I will fit in?!";void setup() {  for ( int n = 0; n < charHeight; n++ )  {    pinMode(povPins[n], OUTPUT);  }    pinMode(ledPin, OUTPUT);  pinMode(inPin, INPUT);} // sets the 7 LEDsvoid setColumn(byte data){  int pinIndex = 0;  for (byte mask = B00000001; mask<128; mask = mask << 1)  {    digitalWrite(povPins[pinIndex], mask & data);      pinIndex++;  }}// writes a letter to POV using standart letter widthvoid writeLetter(byte letter[]){  writeLetter(letter, charWidth);}// writes a letter to POV using custom letter widthvoid writeLetter(byte letter[], int length){  for (int n = 0; n < length; ++n)  {    setColumn(letter[n]);    delayMicroseconds(colDelay);  }  setColumn(BLANK);  delayMicroseconds(colDelay);}void writeASCII(char aCharacter){    int characterFontIndex = getCharIndex(aCharacter);  for (int n = 0; n < charWidth; ++n)  {    setColumn(font[characterFontIndex][n]);    delayMicroseconds(colDelay);  }  setColumn(BLANK);  delayMicroseconds(colDelay);  }//gets the index of our pseudo ASCII table (ascii-32)int getCharIndex(char ch){    if (ch < 32 || ch > 126) ch = 32;    return (ch - 32);}//prints the stringBuffer  void printStringBuffer(){  for ( int n = 0; n < bufferSize; ++n )  {    writeASCII( stringBuffer[n] );  }}// main LOOPvoid loop() {    switchValue = digitalRead(inPin);  // read input value of the magnetic switch    if (switchValue == HIGH) // check if the input is HIGH (button released)  {    //this is spare time    digitalWrite(ledPin, LOW);  // turn LED OFF      }    if (switchValue == LOW && millis() - lastCycleStart > debounce)  {    lastCycleStart = millis();    revolutions++;        digitalWrite(ledPin, HIGH);  // turn LED ON    //sprintf(stringBuffer, "%d", revolutions);        printStringBuffer();  }    }`

#### Mulder

#5
##### Jan 19, 2009, 10:43 am
btw, i bought a 5 euro bike computer and used the magnetic switch to find out when a new revolution starts.

#### halley

#6
##### Jan 19, 2009, 02:16 pm
Quote
but what are the  0x00,  0x78, 0x14 ect.

Take a number like 17 decimal.

The B00010001 notation is how you specify the same numeric value in binary to the compiler.

The 0x11 notation is how you specify the same numeric value in hexadecimal to the compiler.  Each hexadecimal digit corresponds to four binary digits, so it's a little more compact.  With practice, one can see the bits when shown the hexadecimal value... it's like the scene in the Matrix where the operator watches the plain green digits to know what's going on.

#### Ardorlan

#7
##### Jul 04, 2010, 05:42 am
Is there any good chips(LED Drivers) to use for POV to control 64 LEDs? I would like to get 254 Shades of brightness.

#### marklar

#8
##### Jul 06, 2010, 06:48 pm
4 TLC5940 chips can run 64 leds with 4096 levels.

There are some POV samples for this setup as well.

Have you seen this?
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1218174457

Good luck

#### raron

#9
##### Jul 06, 2010, 08:13 pmLast Edit: Jul 07, 2010, 01:03 pm by raron Reason: 1
I've so far never used TLC5940s, and if memory servers wasn't those a bit hard to come by? (Or maybe there is another IC I'm thinking about).

Based on the existing schematics, I'd recommend taking a look at this really nice and simple POV project: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1277270646
In fact it seems to be almost directly applicable to peps's schematics, only thing missing is a sensor wired to analogue input 5, assuming a rotating POV. Of course there is no PWM there (but that's possible to implement in software if wanted).

Go Up

Please enter a valid email to subscribe