Go Down

Topic: [Request] Has anyone made a "Message Wand"? (Read 2066 times) previous topic - next topic

promocom

Its a single row of leds made in a "wand" shape and when you wave it back and forth preprogrammed text or shapes appear in the air. I think that could be a interesting project I'd like to build, but is beyond my skill.

mowcius

you are looking for a wand type POV device.

Google arduino POV and you should find a few.
There is a kit you can buy as well but I can't remember who makes it.

Mowcius

TchnclFl

Quote
There is a kit you can buy as well but I can't remember who makes it.


It's Adafruit's "Mini POV":

http://www.adafruit.com/index.php?main_page=product_info&cPath=5&products_id=20

promocom

Thanks guys, these are great. Is there one in color with more leds?

mowcius

Quote
Thanks guys, these are great. Is there one in color with more leds?

Short answer: No.
If you want to make your own however, you might want to look at this:
http://www.instructables.com/id/RGBike-POV-Open-project/

raron

#5
May 11, 2010, 10:29 pm Last Edit: May 11, 2010, 10:33 pm by raron Reason: 1
Hm, not sure I should post this here, not being arduino at all, but since you kinda requested it: Yeah, I did actually make one such "message wand" (why didn't I think of that name?) a good while ago, in 2001. I called it a flutter display, or simply "the stick".

Not sure if this is helpful at all though. Also I hope it is alright to post even if it isn't arduino-related.

Since I am borrowing a video camera atm, I uploaded it to youtube :) http://www.youtube.com/watch?v=-9O_IkhqDjo
(I know, terrible design, basically just "wirewrapped" to a stick)


This was basically a one-off thing I did back then, basically built with scrap parts I had at hand. Also since I had a 16C84 and a programmer. For direction change sensing I hacked a relay, soldered a somewhat heavy, stiff copper wire to the middle moving contact of the relay. It fitted through a hole in one of the other relay contacts, and I just coiled it at the end, so it wouldn't stick too far out. You can see it in the video how it works. Actually, this idea was the one that made me make this thing! Prior to that I had no real handle on how to sense the change-of-direction.

Oh, and it's not really finished :P Will probably never be, though I might have an arduino go sometime in the undecided future.
I had in mind making the display work in both directions, but this one only displays while going one way. I had some trouble aligning the image both ways so I "temporarily" disabled it. I also made 2 rows of LED's, one red row and one green, with a possible future addition of a blue row, for colors. Except in this demo I only use the red row, displaying my old nick. I didn't bother to change it, as I would have to figure out how to program the thing again.


I build it on a piece of stripboard I had, so I never made any PCB or a layout of any kind. The only "schematics" is this one, which I actually found. It is of course not tidied up at all, its more of a back-of-napkin kind of drawing actually. Beware it seems to contain some errors, omissions and otherwise an unrelated pinout for a LM324 for some reason :P Only showing 2 of the 8 LED's pr. row (red and green row), from the 74LS245.




I guess I can post my code too (with some spelling errors I just discovered). So my first exhibition is a non-arduino one :P
Seems I ran it on around 500 kHz (not 1,2 or 4 MHz as stated in the schematics). I didn't use a crystal, but made a RC oscillator with a schmitt-trigger NAND gate. The output of that is connected to the clock input I think.

Part #1 of 2 of the code:

Code: [Select]
;**********************************************************************
;                                                                     *
;    Program        : "THE STICK" - display driver v1.00              *
;    File Version   : 1.12                                            *
;    Dates          : 2001.10.03                                      *
;                     2001.10.04                                      *
;                                                                     *
;      (C) 2001    ARON                                               *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Files required:  p16C84.inc                                      *
;                                                                     *
;                                                                     *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Notes:                                                           *
;                                                                     *
;Clock mode is XT, because the clock is external osc. approx. 500 KHz *
;                                                                     *
;                                                                     *
;EEprom data used as 8* 64 display matrix.                            *
;                                                                     *
; Port B is display output, LSB is lower LED, MSB is upper            *
;                                                                     *
; Port A:                                                             *
;  (in)    RA0 = Motion-LEFT sensor  (1 = left movement begun)        *
;  (in)    RA1 = Motion-RIGHT sensor (1 = right movement begun)       *
;  (out)   RA2 = RED GND (1 = GND active, ie. RED LED's ON)           *
;  (out)   RA3 = GREEN GND                                            *
;  (out)   RA4 = UNUSED  (Future: BLUE GND?)                          *
;                                                                     *
;                                                                     *
; Further notes: This version displays text ARON during left scan in  *
; red LED's. right scan turned off because of alignment troble,       *
; possibly in delay-part of scan-routines.                            *
;                                                                     *
; Also, display data is longer than neccesary to compensate for a     *
; bad delay-routine, filled with zero's....                           *
;                                                                     *
;**********************************************************************


     list      p=16C84             ; list directive to define processor
     #include <p16C84.inc>         ; processor specific variable definitions

     __CONFIG   _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC


;**** Constants

MATRIX            EQU      0x27      ; Set matrix size here, 1-64 / 0x01 - 0x40
FRAMETIME      EQU      0xFF      ; Arbitrarily choosen initial frame-scanning time
DELAYPIX      EQU      0x08      ; Pixel-delay before/after display

;***** VARIABLE DEFINITIONS

scantime      EQU      0x0C      ; Measured time for last frame
rowtime            EQU      0x0D      ; timeslot for one row of display data
wait            EQU      0x0E      ; wait-variable for time-waste subroutine
matrixsize      EQU      0x0F      ; Size-of-matrix

value            EQU      0x10      ; value to be divided by divident
divident      EQU      0x11
subcounter      EQU      0x12      ; Nr. of subtractions (answear of division)

delay            EQU      0x13      ; Beg/end delay-time in matrix-pixels measurements
nextrtime      EQU      0x14      ; When to display the next row

scanpos            EQU      0x15      ; just a position counter
row            EQU      0x16      ; display row index
totsize            EQU      0x17      ; total display size (width) included delay
stopdisp      EQU      0x18


; *** Declaring EEPROM data

           ORG      0x2100            ; start dummy address of EEprom

           de      0x1f,0x3f,0x68,0xc8,0xc8,0x68,0x3f,0x1f,0x00      ; A
           de      0xff,0xff,0xc8,0xce,0x7b,0x31,0x00            ; R
           de      0x3c,0x66,0xc3,0xc3,0x66,0x3c,0x00            ; O
           de      0xff,0xff,0x60,0x18,0x06,0xff,0xff            ; N
           de      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00      ;fillbytes for alignment cheating

;**********************************************************************

           ORG     0x000            ; processor reset vector

init            bcf      INTCON,GIE      ; Disable interrupts for my un-interuptable program

; --- init ports
           clrf      PORTB            ; set portb = 00000000
           clrf      PORTA
           bsf      STATUS,RP0      ; select bank 1
           movlw      0x00            ; All bits in portb = outputs
           movwf      TRISB            ; set port b data direction register
           movlw      0x03            ; bit #0 and #1 is inputs, the rest outputs in port A
           movwf      TRISA
           movlw      B'11000111'      ; prescaler assigned to TMR0
           movwf      OPTION_REG
           bcf      STATUS,RP0      ; select bank 0

; --- other inits
           movlw      MATRIX
           movwf      matrixsize
           movlw      FRAMETIME
           movwf      scantime      ; initial scan-time (approx guess)
           movlw      DELAYPIX
           movwf      delay

           movf      matrixsize,W
           addwf      delay,W
           movwf      stopdisp      ; Display-scan-stop position in matrix-pixels
           addwf      delay,W            ; W = matrix + 2 * delay
           movwf      totsize            ; total "size" of matrix included display delay



; **** Blink all LED's initially

           bsf      PORTA,2            ; test-blink RED LEDs
           bsf      PORTA,3            ; no test-blink GREEN LEDs

           movlw      0x80
           movwf      wait            ; initial blinking time

blinkinit      comf      PORTB,F            ; complement port B
           call      timerwait
           movf      PORTA,W            ; W = portA
           andlw      0x03            ; Is one of port A's lowest bits set??
           btfsc      STATUS,Z      ; check      Zero-flag, W>=1 => Z=0...
           goto blinkinit




; **** Which direction to scan the display?

main

testleft      btfsc      PORTA,0            ; test if bit0 is set (left-scanning display)
           goto      lscaninit      ; yes..
           goto      rscaninit      ; no...



raron

Part #2 of 2 of the code (the same file)
Code: [Select]

; ***** RIGHT SCANNING DISPLAY
; --- blank display and check for direction change from left to right

waitforright      clrf      PORTB            ; blank display after stop-pos
           btfss      PORTA,1            ; check if right-swing is registered
           goto      waitforright
endlscan      movf      TMR0,W
           movwf      scantime      ; new scantime (or rather, the one just finished..)

rscaninit      clrf      TMR0            ; clear timer
           clrf      PORTB            ; Initially clear display
           clrf      scanpos
           clrf      row
           clrf      nextrtime

; TEST *****
           bcf      PORTA,2
           bcf      PORTA,3            ;Set / Clear display during this scan

           movf      totsize,W
           movwf      divident
           movf      scantime,W
           movwf      value
           call      divide            ; subcounter = scantime / totsize
           movf      subcounter,W
           movwf      rowtime            ; find time allowed pr. row
           movwf      nextrtime      ; set initial delay


rscan            movf      nextrtime,W
           subwf      TMR0,W            ; W = TMR0 - nextrtime
           btfsc      STATUS,C      ; skip if nextrtime < TMR0
           goto      rrowdisp
           btfss      PORTA,0            ; check if left-swing is registered (END R-SCAN)
           goto      rscan
           goto      endrscan

rrowdisp      incf      scanpos,F      ; next row abs. position
           movf      rowtime,W
           addwf      nextrtime,F      ; next row time-start in TMR0-steps

           movf      delay,W
           subwf      scanpos,W      ; W = scanpos - delay
           btfss      STATUS,C      ; skip if scanpos > delay
           goto      rscan

           movf      stopdisp,W
           subwf      scanpos,W      ; W = scanpos - stopdisp
           btfsc      STATUS,C      ; skip if stopdisp > scanpos
           goto      waitforleft

;-- read EEPROM
           bcf      STATUS,RP0
           movf      row,W
           movwf      EEADR
           bsf      STATUS,RP0
           bsf      EECON1,RD      ;initiate read
           bcf      STATUS,RP0
           movf      EEDATA,W
           movwf      PORTB            ; Display it..
;--
           incf      row,F            ; next row pointer
           goto      rscan




; ***** LEFT SCANNING DISPLAY
; --- blank display and check for direction change from right to left

waitforleft      clrf      PORTB            ; blank display after stop-pos
           btfss      PORTA,0            ; check if left-swing is registered
           goto      waitforleft
endrscan      movf      TMR0,W            ; Direction-change detected
           movwf      scantime      ; new scantime (or rather, the one just finished..)

lscaninit      clrf      TMR0            ; clear timer
           clrf      PORTB            ; Initially clear display
           clrf      nextrtime
           clrf      scanpos

; TEST *****
           bsf      PORTA,2
           bcf      PORTA,3            ;Set / Clear display during this scan


           movf      matrixsize,W
           movwf      row
           decf      row,F            ; initial row-nr backwards

           movf      totsize,W
           movwf      divident
           movf      scantime,W
           movwf      value
           call      divide            ; scantime / totsize
           movf      subcounter,W
           movwf      rowtime            ; find time allowed pr. row
           movwf      nextrtime      ; set initial delay


lscan            movf      nextrtime,W
           subwf      TMR0,W            ; W = TMR0 - nextrtime
           btfsc      STATUS,C      ; skip if nextrtime < TMR0
           goto      lrowdisp
           btfss      PORTA,1            ; check if right-swing is registered (END L-SCAN)
           goto      lscan
           goto      endlscan

lrowdisp      incf      scanpos,F      ; next row abs. position
           movf      rowtime,W
           addwf      nextrtime,F      ; next row time-start in TMR0-steps

           movf      delay,W
           subwf      scanpos,W      ; W = scanpos - delay
           btfss      STATUS,C      ; skip if scanpos > delay
           goto      lscan

           movf      stopdisp,W
           subwf      scanpos,W      ; W = scanpos - stopdisp
           btfsc      STATUS,C      ; skip if stopdisp > scanpos
           goto      waitforright

;-- read EEPROM
           bcf      STATUS,RP0
           movf      row,W
           movwf      EEADR
           bsf      STATUS,RP0
           bsf      EECON1,RD      ;initiate read
           bcf      STATUS,RP0
           movf      EEDATA,W
           movwf      PORTB            ; Display it..
;--
           decf      row,F            ; next row pointer backwards
           goto      lscan








; ********************** SUB ROUTINES ********************************


; --- un-accurate division, answear is within + 1 / - 0 or something
;      of correct answear, all integers if course...

divide            movlw      0x00
           movwf      subcounter      ;clear answear

           movf      divident,W
           btfsc      STATUS,Z      ;check for divide-by-zero
           goto      divideby0

subloop            movf      divident,W
           subwf      value,W            ; W = value - divident
           btfss      STATUS,C      ; did a borrow occur?
           RETURN                  ; yes, value < divident, answear is OK..
           movwf      value
           incf      subcounter,F
           goto      subloop

divideby0      incf      subcounter,F      ; here, div-by-zero equals 1 :-)
           RETURN                  ; dont know why, but it feels good




; --- Time-waist routine

timerwait      movlw      0x00
           movwf      TMR0            ; clear timer

tloop            movf      TMR0,W
           subwf      wait,W            ; W = wait - timer
           btfss      STATUS,Z      ; W = 0 ?
           goto      tloop            ; no,  wait more
           RETURN




           END                     ; directive 'end of program'



k2pek2

I made one too, it's really easy to do with the Arduino. Hope you can get enough resources to build your own, it's a fun project. (mine was slower than a normal POV so I could write in longer exposure photographs, but you can easily change the delay to make it faster/slower as you want). If you want code I can post it

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1242879841

AlphaZeta

Makezine recently just featured one such project (http://blog.makezine.com/archive/2010/05/new_in_the_maker_shed_povard_pov_ki.html) and if you want the kit, you can get from them.

captaincool

LOL i just attempted to make one on a breadboard. All the jumper wires keep jumping out and it's too early for me to do something about i need to go to bed xD.

promocom

#10
May 17, 2010, 01:25 am Last Edit: May 17, 2010, 01:48 am by promocom Reason: 1
The first POV I ever saw was at a science fair many years ago. It was a vertical strip of leds mounted on the wall and when you walked past them you would see a random image out of the corner of your eye and when you turned to look it disappeared. It was amusing to watch  people with puzzled looks turning their heads back and forth.

I'd like to reproduce that effect... I downloaded some POV code but not sure how to use it. The leds flash for a couple seconds and then stop.

Code: [Select]

#include <avr/power.h>
#include <avr/sleep.h>

[color=#CC6600]int[/color] ledpin[] = {12,11,10,9,4,3,8,7,6,5};
[color=#CC6600]int[/color] dotTime = 1;

[color=#CC6600]int[/color] _[] = {0b0000000000,
          0b0000000000,
          0b0000000000,
          0b0000000000,
          0b0000000000};
[color=#CC6600]int[/color] A[] = {0b1111111100,
          0b0000010010,
          0b0000010001,
          0b0000010010,
          0b1111111100};
[color=#CC6600]int[/color] B[] = {0b1111111111,
          0b1000010001,
          0b1000010001,
          0b0100101010,
          0b0011000100};
[color=#CC6600]int[/color] C[] = {0b0011111100,
          0b0100000010,
          0b1000000001,
          0b0100000010,
          0b0011001100};
[color=#CC6600]int[/color] D[] = {0b1111111111,
          0b1000000001,
          0b1000000001,
          0b0100000010,
          0b0011111100};
[color=#CC6600]int[/color] E[] = {0b1111111111,
          0b1000010001,
          0b1000010001,
          0b1000010001,
          0b1000000001};
[color=#CC6600]int[/color] F[] = {0b1111111111,
          0b0000010001,
          0b0000010001,
          0b0000010001,
          0b0000000001};
[color=#CC6600]int[/color] G[] = {0b0011111100,
          0b0100000010,
          0b1001000001,
          0b0101000010,
          0b1111001100};
[color=#CC6600]int[/color] H[] = {0b1111111111,
          0b0000010000,
          0b0000010000,
          0b0000010000,
          0b1111111111};
[color=#CC6600]int[/color] I[] = {0b0000000000,
          0b1000000001,
          0b1111111111,
          0b1000000001,
          0b0000000000};
[color=#CC6600]int[/color] J[] = {0b0011111111,
          0b0100000001,
          0b1000000001,
          0b0100000000,
          0b0011000000};
[color=#CC6600]int[/color] K[] = {0b1111111111,
          0b0000010000,
          0b0000101000,
          0b0001000100,
          0b1110000011};
[color=#CC6600]int[/color] L[] = {0b1111111111,
          0b1000000000,
          0b1000000000,
          0b1000000000,
          0b1000000000};
[color=#CC6600]int[/color] M[] = {0b1111111100,
          0b0000000011,
          0b0000001100,
          0b0000000011,
          0b1111111100};
[color=#CC6600]int[/color] N[] = {0b1111111111,
          0b0000000110,
          0b0000011000,
          0b0001100000,
          0b1111111100};
[color=#CC6600]int[/color] O[] = {0b0011111100,
          0b0100000010,
          0b1000000001,
          0b0100000010,
          0b0011111100};
[color=#CC6600]int[/color] P[] = {0b1111111111,
          0b0000010001,
          0b0000010001,
          0b0000001010,
          0b0000000100};
[color=#CC6600]int[/color] Q[] = {0b0011111100,
          0b0100000010,
          0b1000000001,
          0b0100000010,
          0b1011111100};
[color=#CC6600]int[/color] R[] = {0b1111111111,
          0b0000010001,
          0b0000010001,
          0b0000101010,
          0b1111000100};
[color=#CC6600]int[/color] S[] = {0b0011000100,
          0b0100001010,
          0b1000010001,
          0b0100100010,
          0b0011001100};
[color=#CC6600]int[/color] T[] = {0b0000000001,
          0b0000000001,
          0b1111111111,
          0b0000000001,
          0b0000000001};
[color=#CC6600]int[/color] U[] = {0b0111111111,
          0b1000000000,
          0b1000000000,
          0b1000000000,
          0b0111111111};
[color=#CC6600]int[/color] V[] = {0b0000011111,
          0b0011100000,
          0b1100000000,
          0b0011100000,
          0b0000011111};
[color=#CC6600]int[/color] W[] = {0b0011111111,
          0b1100000000,
          0b0011000000,
          0b1100000000,
          0b0011111111};
[color=#CC6600]int[/color] X[] = {0b1100000011,
          0b0011001100,
          0b0000110000,
          0b0011001100,
          0b1100000011};
[color=#CC6600]int[/color] Y[] = {0b0000000011,
          0b0000001100,
          0b1111110000,
          0b0000001100,
          0b0000000011};
[color=#CC6600]int[/color] Z[] = {0b1100000001,
          0b1011000001,
          0b1000110001,
          0b1000001101,
          0b1000000011};


[color=#CC6600]void[/color] [color=#CC6600][b]setup[/b][/color]() {
 [color=#CC6600][b]Serial[/b][/color].[color=#CC6600]begin[/color](9600);
 [color=#CC6600]for[/color] ([color=#CC6600]int[/color] i = 0; i < 10; i++) {
   [color=#CC6600]pinMode[/color](ledpin[i], [color=#006699]OUTPUT[/color]);
 }
 [color=#CC6600]pinMode[/color](2, [color=#006699]INPUT[/color]);
 [color=#CC6600]digitalWrite[/color](2, 1);
 [color=#CC6600]digitalWrite[/color](13, 1);
}

[color=#CC6600]int[/color] pow([color=#CC6600]int[/color] num, [color=#CC6600]int[/color] power) {
 [color=#CC6600]return[/color] [color=#CC6600]round[/color](pow(([color=#CC6600]double[/color])num, ([color=#CC6600]double[/color])power));
}

[color=#CC6600]void[/color] printLetter([color=#CC6600]int[/color] letter[]) {
 [color=#CC6600]delay[/color](dotTime);
 [color=#CC6600]for[/color] ([color=#CC6600]int[/color] i = 0; i < 5; i++) {
   [color=#CC6600]for[/color] ([color=#CC6600]int[/color] j = 0; j < 10; j++) {
     [color=#CC6600]digitalWrite[/color](ledpin[j], (letter[i] & pow(2, j)) ? [color=#006699]HIGH[/color] : [color=#006699]LOW[/color]);
     [color=#CC6600][b]Serial[/b][/color].[color=#CC6600]print[/color]((letter[i] & pow(2, j)) ? [color=#006699]"O"[/color] : [color=#006699]" "[/color]);
   }
   [color=#CC6600][b]Serial[/b][/color].[color=#CC6600]print[/color]([color=#006699]"|\n"[/color]);
   [color=#CC6600]delay[/color](dotTime);
 }
 [color=#CC6600][b]Serial[/b][/color].[color=#CC6600]print[/color]([color=#006699]"\n"[/color]);
 [color=#CC6600]for[/color] ([color=#CC6600]int[/color] i = 0; i < 10; i++)
   [color=#CC6600]digitalWrite[/color](ledpin[i], 0);
 [color=#CC6600]delay[/color](dotTime);
}

[color=#CC6600]void[/color] wake() {}

[color=#CC6600]void[/color] [color=#CC6600][b]loop[/b][/color]() {
 [color=#CC6600]delay[/color](1);
 printLetter(H);
 printLetter(E);
 printLetter(L);
 printLetter(L);
 printLetter(O);
 printLetter(_);
 
 [color=#CC6600]attachInterrupt[/color](0, wake, [color=#006699]LOW[/color]);
 [color=#CC6600]delay[/color](1);
 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
 sleep_enable();
 sleep_mode();
 sleep_disable();
 [color=#CC6600]detachInterrupt[/color](0);



I think if I can make it repeat it would work.

promocom

Quote
I made one too, it's really easy to do with the Arduino. Hope you can get enough resources to build your own, it's a fun project. (mine was slower than a normal POV so I could write in longer exposure photographs, but you can easily change the delay to make it faster/slower as you want). If you want code I can post it

k2pek2 - Liked your project... I would like to see your code if your willing?

k2pek2

#12
May 17, 2010, 03:22 am Last Edit: May 17, 2010, 03:23 am by k2pek2 Reason: 1
The code is poorly annotated and I don't have time now to go through and annotate it all, but if you take a long look at it you should be able to figure it out. it's pretty basic. If you have any specific questions, I'll be happy to help.

Code: [Select]


 //These are arrays that contain the individual letters that may be written.
int _[] = {
 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,};
int A[] = {
 1,1,1,1,1,1,1,1,0,0,0,0, 0,0,0,0,0,0,1,0,1,1,0,0, 0,0,0,0,0,0,1,0,0,0,1,0, 0,0,0,0,0,0,1,0,0,0,0,1, 0,0,0,0,0,0,1,0,0,0,1,0, 0,0,0,0,0,0,1,0,1,1,0,0, 1,1,1,1,1,1,1,1,0,0,0,0,};
int B[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1,0,0,0,1, 1,0,0,0,0,0,0,1,0,0,0,1, 1,0,0,0,0,0,0,1,0,0,0,1, 1,0,0,0,0,0,1,0,0,0,0,1, 0,1,0,0,1,1,0,1,0,0,1,0, 0,0,1,1,0,0,0,0,1,1,0,0,};
int C[] = {
 0,0,0,1,1,1,1,1,0,0,0,0, 0,1,1,0,0,0,0,0,1,1,0,0, 1,0,0,0,0,0,0,0,0,0,1,0, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 0,1,0,0,0,0,0,0,0,0,1,0, 0,0,1,1,0,0,0,0,1,1,0,0,};
int D[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 0,1,0,0,0,0,0,0,0,0,1,0, 0,0,1,1,0,0,0,0,1,1,0,0, 0,0,0,0,1,1,1,1,0,0,0,0,};
int E[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,1,0,0,0,0,1, 1,0,0,0,0,0,1,0,0,0,0,1, 1,0,0,0,0,0,1,0,0,0,0,1, 1,0,0,0,0,0,1,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1,};
int F[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,1,0,0,0,1, 0,0,0,0,0,0,0,1,0,0,0,1, 0,0,0,0,0,0,0,1,0,0,0,1, 0,0,0,0,0,0,0,1,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1,};
int G[] = {
 0,0,0,0,1,1,1,1,1,0,0,0, 0,0,1,1,0,0,0,0,0,1,1,0, 0,0,1,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,1,0,0,0,0,0,0,1, 0,1,1,0,1,0,0,0,0,0,1,0, 0,0,0,1,1,0,0,0,0,1,0,0,};
int H[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,1,0,0,0,0,0, 0,0,0,0,0,0,1,0,0,0,0,0, 0,0,0,0,0,0,1,0,0,0,0,0, 0,0,0,0,0,0,1,0,0,0,0,0, 0,0,0,0,0,0,1,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1,1,1,};
int I[] = {
 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1,};
int J[] = {
 0,1,1,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 0,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1,};
int K[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,1,1,0,0,0,0,0, 0,0,0,0,1,0,0,1,0,0,0,0, 0,0,0,1,0,0,0,0,1,0,0,0, 0,0,1,0,0,0,0,0,0,1,0,0, 0,1,0,0,0,0,0,0,0,0,1,0, 1,0,0,0,0,0,0,0,0,0,0,1,};
int L[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0,};
int M[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,1,1,0, 0,0,0,0,0,0,0,1,1,0,0,0, 0,0,0,0,0,1,1,0,0,0,0,0, 0,0,0,0,0,0,0,1,1,0,0,0, 0,0,0,0,0,0,0,0,0,1,1,0, 1,1,1,1,1,1,1,1,1,1,1,1,};
int N[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,1,1,0, 0,0,0,0,0,0,0,1,1,0,0,0, 0,0,0,0,0,1,1,0,0,0,0,0, 0,0,0,1,1,0,0,0,0,0,0,0, 0,1,1,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1,1,1,};
int O[] = {
 0,0,0,1,1,1,1,1,1,0,0,0, 0,1,1,0,0,0,0,0,0,1,1,0, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,0,0,1, 0,1,1,0,0,0,0,0,0,1,1,0, 0,0,0,1,1,1,1,1,1,0,0,0,};
int P[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,1,0,0,0,0,1, 0,0,0,0,0,0,1,0,0,0,0,1, 0,0,0,0,0,0,1,0,0,0,0,1, 0,0,0,0,0,0,1,0,0,0,0,1, 0,0,0,0,0,0,0,1,0,0,1,0, 0,0,0,0,0,0,0,0,1,1,0,0,};
int Q[] = {
 0,0,0,1,1,1,1,1,1,0,0,0, 0,1,1,0,0,0,0,0,0,1,1,0, 1,0,0,0,0,0,0,0,0,0,0,1, 1,0,0,0,1,0,0,0,0,0,0,1, 1,0,0,1,0,0,0,0,0,0,0,1, 0,1,1,0,0,0,0,0,0,1,1,0, 1,1,0,1,1,1,1,1,1,0,0,0,};
int R[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,1,1,0,0,0,0,1, 0,0,0,0,1,0,1,0,0,0,0,1, 0,0,0,1,0,0,1,0,0,0,0,1, 0,0,1,0,0,0,1,0,0,0,0,1, 0,1,0,0,0,0,0,1,0,0,1,0, 1,0,0,0,0,0,0,0,1,1,0,0,};
int S[] = {
 0,0,1,1,0,0,0,1,1,1,0,0, 0,1,0,0,0,0,1,0,0,0,1,0, 1,0,0,0,0,0,1,0,0,0,0,1, 1,0,0,0,0,1,1,0,0,0,0,1, 1,0,0,0,0,1,0,0,0,0,0,1, 0,1,0,0,0,1,0,0,0,0,1,0, 0,0,1,1,1,0,0,0,1,1,0,0,};
int T[] = {
 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,0,0,0,1,};
int U[] = {
 0,0,1,1,1,1,1,1,1,1,1,1, 0,1,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0, 0,1,0,0,0,0,0,0,0,0,0,0, 0,0,1,1,1,1,1,1,1,1,1,1,};
int V[] = {
 0,0,0,0,0,0,0,1,1,1,1,1, 0,0,0,0,1,1,1,0,0,0,0,0, 0,0,1,1,0,0,0,0,0,0,0,0, 1,1,0,0,0,0,0,0,0,0,0,0, 0,0,1,1,0,0,0,0,0,0,0,0, 0,0,0,0,1,1,1,0,0,0,0,0, 0,0,0,0,0,0,0,1,1,1,1,1,};
int W[] = {
 1,1,1,1,1,1,1,1,1,1,1,1, 0,1,1,0,0,0,0,0,0,0,0,0, 0,0,0,1,1,0,0,0,0,0,0,0, 0,0,0,0,0,1,1,0,0,0,0,0, 0,0,0,1,1,0,0,0,0,0,0,0, 0,1,1,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1,1,1,};
int X[] = {
 1,1,0,0,0,0,0,0,0,0,1,1, 0,0,1,1,0,0,0,0,1,1,0,0, 0,0,0,0,1,0,0,1,0,0,0,0, 0,0,0,0,0,1,1,0,0,0,0,0, 0,0,0,0,1,0,0,1,0,0,0,0, 0,0,1,1,0,0,0,0,1,1,0,0, 1,1,0,0,0,0,0,0,0,0,1,1,};
int Y[] = {
 0,0,0,0,0,0,0,0,0,0,1,1, 0,0,0,0,0,0,0,0,1,1,0,0, 0,0,0,0,0,0,0,1,0,0,0,0, 1,1,1,1,1,1,1,0,0,0,0,0, 0,0,0,0,0,0,0,1,0,0,0,0, 0,0,0,0,0,0,0,0,1,1,0,0, 0,0,0,0,0,0,0,0,0,0,1,1,};
int Z[] = {
 1,1,1,0,0,0,0,0,0,0,0,1, 1,0,0,1,0,0,0,0,0,0,0,1, 1,0,0,0,1,0,0,0,0,0,0,1, 1,0,0,0,0,1,1,0,0,0,0,1, 1,0,0,0,0,0,0,1,0,0,0,1, 1,0,0,0,0,0,0,0,1,0,0,1, 1,0,0,0,0,0,0,0,0,1,1,1,};
int Dot[] = {
 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 1,1,1,0,0,0,0,0,0,0,0,0, 1,1,1,0,0,0,0,0,0,0,0,0, 1,1,1,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,};
int Ex[] = {
 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0, 1,1,1,0,0,1,1,1,1,1,1,1, 1,1,1,0,0,1,1,1,1,1,1,1, 1,1,1,0,0,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,};
int Qu[] = {
 0,0,0,0,0,0,0,1,1,1,0,0, 0,0,0,0,0,0,0,0,0,0,1,0, 0,0,0,0,0,0,0,0,0,0,0,1, 1,1,0,1,1,0,0,0,0,0,0,1, 0,0,0,0,0,1,0,0,0,0,0,1, 0,0,0,0,0,0,1,0,0,0,1,0, 0,0,0,0,0,0,0,1,1,1,0,0,};
int Heart[] = {
 0,0,0,0,0,0,0,1,1,1,0,0, 0,0,0,0,0,0,1,1,1,1,1,0, 0,0,0,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,0,0,0,0, 0,0,0,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,1,1,1,1,1,0, 0,0,0,0,0,0,0,1,1,1,0,0,};
int letterpause = 30;  //Time between letters
int columntime = 15;  //Time between the parts of the letters
int buttonIn = 1;
int pressed = 0;

void setup()
{
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);  
 pinMode(7, OUTPUT);
 pinMode(8, OUTPUT);
 pinMode(9, OUTPUT);
 pinMode(10, OUTPUT);
 pinMode(11, OUTPUT);
 pinMode(12, OUTPUT);
 pinMode(13, OUTPUT);
}

void writeletter(int letter[])  //Create a function that displays the current letter
{
 int i;
 for (i=0; i<12; i++)  //Go through the individual bits of the letter one at a time to display the first part of the letter
 {
   digitalWrite(i+2, letter[i]);  
 }
 delay(columntime);
 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, letter[i+12]);    //Go through the next part of the letter, and keep going until the letter is complete
 }
 delay(columntime);
 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, letter[i+24]);
 }
 delay(columntime);

 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, letter[i+36]);
 }
 delay(columntime);

 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, letter[i+48]);
 }
 delay(columntime);

 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, letter[i+60]);
 }
 delay(columntime);

 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, letter[i+72]);
 }
 delay(columntime);
 for (i=0; i<12; i++)
 {
   digitalWrite(i+2, 0);
 }
 delay(letterpause);
}

void loop(){
   writeletter(I);    //Go through the letters you want to write
   writeletter(_);
   writeletter(L);
   writeletter(O);
   writeletter(V);
   writeletter(E);
   writeletter(_);
   writeletter(A);
   writeletter(R);
   writeletter(D);
   writeletter(U);
   writeletter(I);
   writeletter(N);
   writeletter(O);
   writeletter(Ex);
   delay(100000);
}

promocom

k2pek2 - I must be doing something wrong (Complete Newb). I can upload your code ok but nothing seems to happen except the first led stays lit.

k2pek2

Okay, can you tell me your current setup? i have it all being controlled from pins 2-13, with an LED and a resistor going from the digital output pin to ground. The LED's are all to be arranged in the same order as the output pins. Pictures or a description of the problem?

Also, try shortening the message. I noticed that longer messages can mess up the code (anyone know why?) and it won't run.

Go Up