pyrohaz
Member
Hi,
I'm designing a project using either two maples or a maple and an arduino. I'm looking at having a "memory pool" which is accessible by both processors asynchronously. Is there some form of memory chip that can be written to and read from simultaneously?
Cheers, Harris
gbulmer
Moderator
pyrohaz - would you give us a bit more context?
There are memory chips which do have multiple interfaces.
However, Arduino, Maple mini, and Maple do not have an external memory interface.
So you're going to either have to construct that interface with some other peripheral interface + software, or use other MCU's.
Some of the STM32F chips have external memory interfaces, but AFAIK, they are all designed to be 'private & synchronous'. Maybe someone else knows enough to help
The sort of things that determine feasibility are the peak bandwidth, maximum latency, size of memory, ... needed. So if you can give us information around those sort of numbers, someone might be able to help.
If bandwidth between CPUs is an issue, I'd suggest something that is 'way over the top', like an Odroid.
If it really didn't need that sort of 'oomph', maybe something like the NXP LPC4300 which has a Cortex-M4 and Cortex-M0 on the same chip, with shared memory access, and synchronisation mechanisms.
http://www.nxp.com/products/microcontrollers/cortex_m4/series/LPC4300.html
I am not sure if this is 'real' enough for non-corporate developers; I don't think I've seen a development board for it, so it is either hard to get or expensive.
gbulmer
Moderator
pyrohaz, mlundinse - sorry for not finishing off my comment "So you're giong to either have to construct that interface with some other peripheral interface + software, or ...". Let me try to finish it.
I was thinking of mentioning I2C memory. That does have the advantage of bus-like protocol definition.
Then I thought, if one of the devices is an Arduino, then the throughput is sufficiently low that it might be easier to use the Maple as the memory. I.e. don't use an I2C memory chip. Instead, have the Maple act as the I2C memory. This might be a handy 'soft' approach, and might be relevant, depending on the hardware debugging tools available.
Then I thought, why bother with emulating I2C?
It would be even easier to emulate an SPI memory, and that's adequate if only two boards are sharing the 'pool'.
One board is the SPI master, and the other the SPI-slave and has the pool of memory.
The same idea (of one emulating shared memory) could be implemented using a UART. In fact anything that is convenient and quick enough.
Using one board as an I2C/SPI/UART/... memory emulator could be straightforward to debug.
All those use serial comms in some form, so, alternatively, if throughput is important, one could use GPIO pins to give a wider bus, and trigger transfer of any width that is convenient using DMA. This might 'swamp' an Arduino, but a couple of Maples could be connected this way.
Of course these are asymmetric.
IMHO, if that matters, then we need to know more about the constraints.
pyrohaz
Member
Hey, cheers for the replies, I don't think I explained enough.
What i'm looking to do is have an arduino place data in some memory every x milliseconds over and over again and have the maple able to access that data even while the arduino is writing, hopefully this explains what I meant by asynchronously, kind of like the maple's normal memory just accessible by an arduino too. A really simple piece of pseudocode would be like this:
void loop(){
MemInc++;
WriteToMemory(MemInc, Data);
if(MemInc>MemMax){
MemInc = 0;
}
//Gather data
Data = X;
}Where MemInc is the address of the memory, and data is the data to be written to that point.
On the maple, it would sequentially access the memory and fill an array with this data. the maple wouldn't need to write to the memory.
void loop(){
ArrayInc++;
Array[ArrayInc] = ReadMemory(ArrayInc);
if(ArrayInc>MemMax){
ArrayInc = 0;
}
}I hope that this clears it up a bit, I could just do the whole task synchronously but obviously this would be synchronizing the arduino data writes and the maple data reads which as i'm sure you can imagine is more work. If there aren't any ram chips that can be simultaneously read and written, this might be my only option!
gbulmer
Moderator
pyrohaz - You still haven't mentioned how fast this must go.
It looks like a serial buffer, and not random access. A serial stream of data is much easier than random access.
So, assuming it isn't too fast, and if that description covers the major requirements, then IMHO it isn't worth the complexity of a separate memory chip.
IMHO it would be easier to build and debug using have the Arduino as an SPI master, and a Maple SPI port be a slave.
It sounds straightforward; push data from the Arduino to the Maple. The Maple buffers the data in memory, and later consumes the data from the buffer.
It sounds like there is no need for a "memory address". It sounds like a stream of data.
How big is each item of data?
Access would be asynchronous in the sense that the Maple would 'catch' data from SPI as it arrives using an interrupt or DMA, which would put it into an in-memory buffer on the Maple,
The main program loop on the Maple would retrieve data from the in-memory buffer.
So, as long as the Maple isn't running more slowly than the data is received, then it is SPI to SPI comms.
Exactly the same thing could be done using a UART.
IMHO I2C is more complex than needed, and is an order of magnitude slower.
So the Arduino side would be:
void loop(){
Send(Data);
//Gather data
Data = X;
}The Maple side would be:
SPI-interrupt() {
read Data from SPI buffer
if buffer is full {
set a flag for the main oop
do the right thing with Data
} else {
put Data into buffer,
update buffer so loop can detect that data is available.
}
}loop would use a function which gets the next Data item from the buffer.
The details of how to do it very much depends on what you want to do if data arrives too fast, and what you want to do if there is no data ready to be processed.
There is some code in libmaple to handle circular buffers, but it isn't too hard to write. There are probably many implementations on the interwibble.
A circular buffer keeps track of both the start of the saved Data, and the end. This would allow the interrupt routine to detect if the buffer is full, and the main loop to detect if it is empty.
Trying to use a shared memory chip will need a mechanism to communicate where the start and end of data are too, so your pseudo-code is glossing over a potentially hard problem to solve.
pyrohaz
Member
Hi gbulmer, cheers for the fast reply. Currently, i'll need to send 52 bytes per transfer. I'm looking at transfer rates of every roughly every 20us. With constant transfers, I think this would require a bit clock of about 4MHz. DMA into a circular buffer sounds like a perfect idea. The Arduino supports SPI at 8MHz max. In slave mode, does the maple care about the clock frequency aslong as its not too high?
Since I want to send 52 bytes at once, as long as the circular buffer is 52 entries long, every time data is written, surely it will just update and write over it?
gbulmer
Moderator
pyrohaz - 52bytes, every 20us? That is 2.6MByte/s, which would require, at least 20.8MHz.
An Arduino's clock is only 16MHz.
A single read or write instruction is 2 cycles, and, I think, a jump or branch is 2 cycles, so 6 cycles to read and write one byte in a loop. 16MHz / 6cycles/byte = 2.67MB/s at best (if you could solve getting the data out of the Arduino)
I think the requirement is teetering on the wrong side of the brink of impossible :-(
You must log in to post.
