Setting Memory
Once you go beyond programming the default TEXT file ( Label "A" ), anything else you want to do (FILE, DOT or STRINGS) requires the setting of memory for the file. This means the TEXT FILE lengths and DOT FILE sizes must be calculated and the memory set for each one. I do this everytime I send to the sign and seemed like a pain in the ass at first but I came up with a good solution.
The memory sizes are calculated for each TEXT file and DOT file, the memory is set and then I send the TEXT and DOT files.
In order to set the memory for TEXT files you need to count the characters (including control CODES), add a small amount to it and convert it to HEX.
The memory setting for a DOT file is the height and width values converted to hex. These values are then added to a other
[[ First 2 bytes = # pixel rows ][ Last two bytes = # pixel columns]] = mem setting.
To SET MEM for a DOT file:(BETABRITE being a filehandle to serial port)
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x24" . "$DOT_LABEL" . "DU" . "$DOT_SIZE" . "4000" . "$EOT";
The breakdown:
$WRITE_SPEC = Write SPECIAL FUNCTIONS file
"\x24" = 24H - Set Memory Configuration
A = TEXT file (41H)
B = STRING file (42H)
D = DOT PICTURE FILE (42H)
U = 55H - Unlocked. Means that the file can be accessed via an IR keyboard.
L = 4CH - Locked. Means that the file can not be accessed via an IR keyboard.
$DOT_SIZE = The first two bytes = # pixel rows and the last two bytes = the # of pixel columns in the picture (in HEX).
4000 = 8-color Color Status (ALWAYS STAYS THE SAME FOR BETABRITE)
So say we have a 11x7 DOT file we want to program into DOT LABEL "J". Converting the rows and cols values to HEX and joining them together we would get "070E". Without the variables our string would actually look more like:
JDU070B4000
To compete the example above:
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x24" . "JDU070B4000" . "$EOT";
In reality you would have more than just the "JDU07B4000". You'd have all your memory settings in the same frame.
Once ALL your memory settings are sent you would send the actual DOT FILE itself:
print BETABRITE "$INIT" . "$WRITE_DOT" . "J" . "070B" . "00000080000\r00000088000\r08888888800\r08888888880\r08888888800\r00000088000\r00000080000\r" . "$EOT";
To SET MEM for a TEXT file:
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x24" . "$TEXT_LABEL" . "AU" . "$TEXT_SIZE" . "$RUNTIME" . "$EOT";
Well set TEXT file "H" in this example:
Explanation:
$TEXT_LABEL = H - Label of the text file :)
A = TEXT FILE
B = STRING file (42H)
D = DOT PICTURE FILE (42H)
U = 55H - Unlocked. Means that the file can be accessed via an IR keyboard.
L = 4CH - Locked. Means that the file can not be accessed via an IR keyboard.
$TEXT_SIZE - This needs some explaning. It's the HEX value for the length of the message.
It gets a little more complicated for TEXT files. In the message we have to count the characters, but also count the MODE stuff too.
For the example our message is:
$message="<$ROTATE><$RED> Hello there, how is everybody doing?";
What I do is read the text message from a file. The variables are surrounded by < and > just like html code. I copy the string into a variable I can work on with without changing the original.
Here's some code from my scripts to do it:
#===============================
# copy - $message remains the $message sent to the sign, $message2 is or working copy
$message2=$message;
#make the spaces something
$message2 =~ s/ /X/g;
# Convert the stuff between < and > back into variables an kill the < and >
# When the varaibles are read from a file they aren't really variables. This converts them.
$message2 =~ s/\<\$(\w+)\>/${$1}/g;
# Throw all the characters in a array
@string = split / */, $message2;
# reset the counter
$char_count=0;
# Count the characters in the array
foreach $character ( @string ) {
$char_count++;
}
# Add characters for before message ( Remember $DPOS ? )
$char_count=$char_count+4;
# convert count to hex
$hex_char_count = sprintf("%02x",$char_count);
# make the letters uppercase
$hex_char_count =~ tr/[a-z]/[A-Z/;
# set the values in the hash
$text{$label}{textsize}=$hex_char_count;
$text{$label}{char_count}=$char_count;
#==============================================
I then have the number of characters in both Dec and HEX. We use the HEX value for the memsize.
44 characters = 2C HEX
$TEXT_SIZE="002C"
RUNTIME: 4 characters to set Start and END times - not to be confused with RUN SEQUENCE
For a TEXT file, the first two characters represent the files Start Time and the last two characters represent the Stop Time. ( See protocol section 4.2 )
[FF = AlwaysFE = Never]
$RUNTIME="FFFE"
Once we have everything ready to go, we can send it to the sign
Setting MEM for LABEL H....
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x24" . "HAU002CFFEE" . "$EOT";
...and then send the message
print BETABRITE "$INIT" . "$WRITE" . "H" . "$DPOS" . "$message" . "$EOT";
Now the news. All the memory settings (FILE, DOT and STRINGS )have to be set in the same frame. This means having them in a hash is the easy way to go. You can just step through the hash and set them all at once.
Just group them together and then send the $EOT
When your are setting more than one, your frame might look like
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x24" . "HDU07374000" . "IDU07294000" . "JDU07324000" . "KDU07474000" . "$EOT";
Setting the Run Sequence
Once you have SET MEM for ALL your TEXT, DOT and STRING files you can then send your TEXT, DOT and STRINGS. You then need to send a RUN SEQUENCE
This tells the sign what you want to show and in what order. This list can up to 130 ASCII characters long and is needed in order for the sign to display anything.
Everytime I write a TEXT file to the sign I throw the LABEL into the end of an array called @text_runlist like so:
push (@text_runlist,$LABEL);
When I'm done sending all of the TEXT files I can then copy all the stuff into a varaible called $text_runlist
$text_runlist="@text_runlist";
Then all I have to do is remove the spaces and I can create the string to send to the sign
# remove the spaces
$text_runlist =~ s/ //g;
To SET RUN SEQUENCE:
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x2e" . "S" . "U" . "$SEQ" . "$EOT";
\x2e = Set Run Sequence
One ASCII character that represents the type of Run Sequence order:
T 54H = All subsequent TEXT File Labels in the Run Sequence will run according to their associated times (default).
S ( 53H ) = All subsequent TEXT File Labels in the Run Sequence will run in order regardless of each file s run time.
D 44H = All subsequent TEXT file labels in the Run Sequence will run according to their associated times. Then when the file reaches an off time , the file will be deleted.
One ASCII character that represents the keyboard protection status:
U ( 55H )= Unlocked. This allows the Run Sequence to be changed from a hand-held IR keyboard (default).
L 4CH = Locked. This makes the Run Sequence inaccessible from a hand-held IR keyboard.
Well say we want to add A B C D and E as an example:
And send it to the sign in the order then were sent (alphabeticaly)
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x2e" "SU" . "ABCDE" . "$EOT";
or
print BETABRITE "$INIT" . "$WRITE_SPEC" . "\x2eSUABCDE" . "$EOT";
Pretty simple
(See section 3.3.2 for more info)
![[ Font 1 example]](betabrite-font1.gif)
![[ Font 2 example ]](betabrite-font2.gif)
![[ Font 3 example ]](betabrite-font3.gif)
The other fonts listed in the protocol appear as listed
