Hi,
If you ONLY want to load explicit values into a DS3231 then using the # prefix to the digits is probably as good as anything. But, although I dislike (excessively) "long" variable names, it could be wise to use symbols such as
secsBCD as a "reminder" that you can't manipulate them as "normal" numbers (and not even print them out directly). Similarly a fully Symbolised expression could be
BCDTOASCII secsBCD , secsX10ascii , secsascii so that the corresponding "Printing" instruction would be
SERTXD ( secsX10ascii , secsascii ) instead of the normal
SERTXD ( #secs ) where secs is a pure binary number.
Therefore, if I were planning to do ANY numerical processing (or even just printing out the values) I would normally store and keep the numbers in "pure" (binary) format. Converting Binary numbers to Binary Coded Decimal is really quite easy
(provided that the Binary number is no greater than 99) : For example you can separate the two digits (nibbles) from the byte, multiply the High (tens) digit by 16 and add the two values together again, but (because PICaxe Basic doesn't permit brackets) this needs two stages, i.e.
units = secs AND 15 : secsBCD = secs / 10 * 16 + units (or ideally avoid the "Magic Numbers" 15 and 16 by using the constants
mskLoNibble and
mskHiNibble as from post #6 ).
However, we can take advantage of the fact that for each unit (or step) in the High Nibble, the "BCD" number is 6 units larger than the Binary number. Therefore we can simply convert from Binary to BCD with the expression
secsBCD = secs / 10 * 6 + secs (e.g. working left to right in sequence:
45 / 10 * 6 + 45 becomes 4 * 6 + 45 = 24 + 45 =
69 ). Note that even though the variable
secs is used twice, the expression will still work correctly if the result is self-assigned to secs, i.e.
secs = secs / 10 * 6 + secs is perfectly acceptable, provided that you (or the program) "remembers" which format is currently being used.
The reverse operation from BCD to Binary is also quite easy, but there is the complication that PICaxe doesn't "officially" support negative numbers, whilst for a "one-liner" expression the number that needs to be subtracted is calculated first. A trick is to define a Symbol such as minus6, i.e.
SYMBOL minus6 = 250 . It's possible to set a variable to
0 - 6 , which will be reported as 250 (or 65530 for a Word variable), but the compiler generally won't allow a Constant to be symbolised as "0 - 6". However, the following expression will still work correctly :
secs = secsBCD / 16 * minus6 + secsBCD (e.g.
secs = 69 / 16 * (0-6) + 69 becomes 4 * (0-6) + 69 = (0-24) + 69 =
45 ) .
Of course you will probably also need a conversion for
mins and maybe many other BCD variables. You could Copy / Edit / Paste for each variable name, or create a Subroutine, or a Macro (#Define). But I prefer to use the system's "Byte Pointer" (@bptr) either over a range of the existing Registers (b0 - b27), or alternatively the "Indirect RAM", if running out of variable space. Thus the following Program should convert all the bytes within the selected range to (and from) BCD in a single process:
Code:
#picaxe 08M2 ; Or any other
Symbol SecsPtr = 10 ; Can be outside normal "named variables" space
Symbol Secs = b10 ; Optional (not used in this example)
Symbol Mins = b11
; ..... etc..
Symbol Century = b17 ; Optional
Symbol CentPtr = 17
Symbol minus6 = 250 ; Or 65530 for Word calculations
POKE SecsPtr , 45,17,15,04,23,04,25,20 ; Store some Test data
Do
AllBinToBCD: ; Routine to convert group of Binary-Coded bytes to BCD
FOR bptr = SecsPtr TO CentPtr
@bptr = @bptr / 10 * 6 + @bptr
NEXT bptr
Wait 5
AllBCDToBin: ; Routine to convert group of BCD to Binary-Coded bytes
FOR bptr = SecsPtr TO CentPtr
@bptr = @bptr / 16 * minus6 + @bptr
NEXT bptr
Wait 5
Loop
Cheers, Alan.
