Creating and using Arrays
The Proton compiler supports multi part Byte, Word, Dword, SByte, SWord and SDword
variables named arrays (Dword and SDword arrays are only supported with 18F or enhanced
14-bit core devices). An array is a group of variables of the same size (8-bits, 16-bits or 32-bits
wide), sharing a single name, but split into numbered cells, called elements.
An array is defined using the following syntax: -
Dim Name[ length ] as Byte
Dim Name[ length ] as Word
Dim Name[ length ] as Dword
Dim Name[ length ] as SByte
Dim Name[ length ] as SWord
Dim Name[ length ] as SDword
where Name is the variable's given name, and the new argument, [ length ], informs the compiler
how many elements you want the array to contain. For example: -
Dim MyArray[10] as Byte ' Create a 10 element unsigned byte array.
Dim MyArray[10] as Word ' Create a 10 element unsigned word array.
Dim MyArray[10] as Dword ' Create a 10 element unsigned dword array.
Dim sMyArray[10] as SByte ' Create a 10 element signed byte array.
Dim sMyArray[10] as SWord ' Create a 10 element signed word array.
Dim sMyArray[10] as SDword ' Create a 10 element signed dword array.
On 18F or enhanced core devices, arrays may have as many elements as RAM permits, however,
with 12-bit core and standard 14-bit core devices, arrays may contain a maximum of 256
elements, (128 for word arrays when using standard 14-bit core devices). Because of the rather
complex way that some PICmicro's RAM cells are organised (i.e. Banks), there are a few rules
that need to be observed when creating arrays with standard 14-bit core devices.
PICmicro™ Memory Map Complexities.
Some microcontrollers have more RAM available for variable storage, however, accessing the
RAM on the standard 14-bit core devices is not as straightforward as one might expect. The
RAM is organised in Banks, where each Bank is 128 bytes in length. Crossing these Banks requires
bits 5 and 6 of the STATUS register to be manipulated. The larger devices such as the
16F877 have 512 RAM locations, but only 368 of these are available for variable storage, the
rest are known as Special Function Registers (SFRs) and are used to control certain aspects of
the microcontroller i.e. TRIS, IO ports, USART etc. The compiler attempts to make this complex
system of Bank switching as transparent to the user as possible, and succeeds where standard
Bit, Byte, Word, and Dword variables are concerned. However, Array variables will inevitably
need to cross the Banks in order to create arrays larger than 96 bytes, which is the largest section
of RAM within Bank0. Coincidently, this is also the largest array size permissible by most
other compilers at the time of writing this manual.
Large arrays (normally over 96 elements) require that their Starting address be located within
the first 255 bytes of RAM (i.e. within Bank0 and Bank2), the array itself may cross this boundary.
This is easily accomplished by declaring them at, or near the top of the list of variables.
The compiler does not manipulate the variable declarations. If a variable is placed first in the
list, it will be placed in the first available RAM slot within the microcontroller. This way, you, the
programmer maintains finite control of the variable usage. For example, commonly used variables
should be placed near the top of the list of declared variables. An example of declaring
an array is illustrated below: -
Device 16F877 ' Choose a microcontroller with extra RAM
Dim Small_Array[20] as Byte ' Create a small array of 20 elements
Dim Var1 as Byte ' Create a standard Byte variable
Dim Large_Array[256] as Byte ' Create a Byte array of 256 elements
or
Dim Array1[120] as Byte ' Create an array of 120 elements
Dim Array2[100] as Byte ' Create another smaller array of 100 elements
If an array cannot be resolved, then a warning will be issued informing you of the offending line:
Warning Array ‘array name' is declared at address ‘array address'. Which is over the 255
RAM address limit, and crosses Bank3 boundary!
Ignoring this warning will spell certain failure of your program.
The following array declaration will produce a warning when compiled for a 16F877 device: -
Device 16F877 ' Choose a microcontroller with extra RAM
Dim Array1[200] as Byte ' Create an array of 200 elements
Dim Array2[100] as Byte ' Create another smaller array of 100 elements
Examining the assembler code produced, will reveal that Array1 starts at address 32 and finishes
at address 295. This is acceptable and the compiler will not complain. Now look at Array2,
its start address is at 296 which is over the 255 address limit, thus producing a warning
message.
The above warning is easily remedied by re-arranging the variable declaration list: -
Dim Array2[100] as Byte ' Create a small array of 100 elements
Dim Array1[200] as Byte ' Create an array of 200 elements
Again, examining the asm code produced, now reveals that Array2 starts at address 32 and finishes
at address 163. everything OK there then. And Array1 starts at address 164 and finishes
at address 427, again, its starting address was within the 255 limit so everything's OK there as
well, even though the array itself crossed several Banks. A simple re-arrangement of code
meant the difference between a working and not working program.
Of course, the smaller microcontrollers do not have this limitation as they do not have 255 RAM
cells anyway. Therefore, arrays may be located anywhere in the variable declaration list. The
same goes for the 18F devices, as these can address any area of their RAM.
