How can i rotating the values of an an array

[The Puma]

This is the array

How can i move the array values one position down

Here is how the array is build
There are 10 dot matrix displays
Each dot matrix has 5 bytes

as example: dot matrix 10 =
message[0] --> 1. column of the dot matrix (left side of display)
message[1] --> 2. column
message[2] --> 3. column
message[3] --> 4. column
message[4] --> 5. column (right side of display)

[luckyluke]

[tsupuntu]

for (i=0;i<50;i++){
if(i==0) temp=message[i];
if(i<49) message[i]=message[i+1];
if(i==49) message[i]=temp;
} ///// this method save ram because not array temp

[Ttelmah]

Realistically though, don't...
Look at how circular buffers work. It is far more efficient to move your access 'point', than to move the whole array.

Best Wishes

[The Puma]

The array must move this way.

message[4] moves to message[3] / dot matrix 10
message[3] moves to message[2]
message[2] moves to message[1]
message[1] moves to message[0]
message[0] moves to message[9]

message[9] moves to message[8] / dot matrix 9
message[8] moves to message[7]
message[7] moves to message[6]
message[6] moves to message[5]
message[5] moves to message[14]

......
and so until dot matrix 1 is reached

[Ttelmah]

Why????

The point is, that if you implement a circular buffer, the data will address as if it moves, but no physical movement need take place. This is how serial I/O buffers are implemented, and is hundreds of times more efficient in terms of processor work. It is like the difference between using a wheel, and trying to move stuff on bit of board. Once the wheel is invented, nobody would bother to use the board if they don't have to...

#define read_byte(x,y) message[(x+y) % sizeof(message))]

Then just have a variable 'offset'. Start with this as '0', and
'read_byte(0,offset)', will return message[0]. Increment it to '1', and 'read_byte(0,offset), will return message[1], and so on. The message never has to move, but your access to it shifts, as if it has moved.

Best Wishes

[The Puma]

I did't understand it

but this is the display code.

It shows first the left most column (=C1) of each dot matrix display
and then the next column, until of five colums are proceded

[Ttelmah]

Use the 'read_byte' define I posted, where you currently read from the array. Have a variable containing the 'offset' you want in the array. Then if you want to move forward by one column, increment this. If you want to move forward by five columns, add 5 to it.

Imagine the array is like this (a smaller version to save my typing...):

M[0] = 0
M[1] = 1
M[2] = 2
M[3] = 3
M[4] = 4
M[5] = 5
M[6] = 6
M[7] = 7
M[8] = 8
M[9] = 9

and the array is just ten elements long as shown (hence 'sizeof(M]', will return ten).

Now if you have a counter, and access the array, from element 0 to 9, you retrieve 0,1,2.......9

If though you now use the code I show (but modified since I couldn't be bothered to type 'message' ten times!), as:

#define read_byte(x,y) M[(x+y) % sizeof(M))]

and retrieve the values with:

read_byte(counter,offset),

Then if offset=0, the behaviour will be exactly 'normal'. However now add 1 to 'offset'. Read_byte(0,offset), now retrieves element 1 (since 1+0=1). However the key is that when you use read_byte(9,offset), you get element 0!. What happens, is that 9+1=10. The array is ten elements long, and the '%' operator, gives the remainder when you divide by this. 10/10, has a remainder of 0, so you access element 0.
So calling read_byte(counter,offset), with offset = 1, gives :
1,2,3,4,5,6,7,8,9,0

Just as if the array had moved by one address.

If you change offset to 3 (say), you get:

3,4,5,6,7,8,9,0,1,2

Just as if the array had moved by 3.

Effectively, 'offset' gives where in the array you will start reading. So if you move offset forward by the amount you want to move through the array, you will access the array, as if it's start 'point', is offset by this amount. The data never has to move, you just change where you start looking at i!.

Best Wishes

[tsupuntu]