Baxen
Member
I'm looking to be able to use code that would have the same effect as this does in the Arduino:
PORTD |= 0x4
I can't use higher level functions because I am specifically trying to manipulate the output pins on the maple as fast as possible. It seems like I will need to access the GPIO registers, but I can't find which ones to use or the best way to set their values.
StephenFromNYC
Moderator
Hello Baxen,
Are you planning to read/write/toggle? How much speed do you need? Does the increased clock speed of the ARM Cortex M3 vs the ATMega mcu allow you to use the higher level functions?
I forgot which Arduino pins (a total of 8) corrrespond to PORTD, but the corresponding pins on the Maple should be easy to find.
I have not tried to change pins using the low level function described in gpio.h, but the low level API offer read, write and also toggle functions. Check out the file here:
https://github.com/leaflabs/libmaple/blob/master/libmaple/gpio.h
If you #include this file you should be able to access these functions. For more general information about using lower level API functions see tips from a member of the LeafLabs team:
http://forums.leaflabs.com/topic.php?id=724#post-4244
Enjoy!
Stephen from NYC (full disclosure: I am not a member of the LeafLabs staff)
Baxen
Member
Thanks for your response Stephen. I am planning on toggling pins, in particular I was planning on using D0-D2. The purpose of this is to create a 5V pulse which is as narrow as possible on each channel at different times. I'm using the maple in the hope that the time a given port remains at 5V will be about 25 ns (2 clock cycles).
Using your advice, I just managed to get a script to compile using gpio.h, which I hope will create such a pulse on channel 2 with:
(GPIOA_BASE)->ODR |= 0x4;
(GPIOA_BASE)->ODR &= ~0x4;
I have not yet had a chance to see if this will do what I was looking for. (I'll test it on an oscilloscope, but will have to wait until Monday before it isn't in use.)
It seems like I should be using gpio.h's gpio_toggle_pin() but I haven't yet figured out what the arguments should be. Maybe like this:
gpio_toggle_pin(GPIOA_BASE, 2)
But I'm not sure if this set of inputs does correctly correspond to toggling the output at D2.
gbulmer
Moderator
Baxen - I have done direct I/O to Maple pins (last year, so details may be hazy).
IIRC I got 18MHz on multiple pins, using rather weird code. It takes TWO cycles to write to a port location, so toggling takes 4 cycles.
If you only want to change one pin at a time, then there is a nifty trick on ARM and Cortex-M3 (i.e. Maple's STM32F) called bit-band addressing.
Every individual port *bit* is mapped into a unique 32-bit memory location, so writing to the location is the same as writing to the bit. IIRC, this isn't quicker, it still takes two cycles, but it does avoid the need to have fancy bit values stored in registers.
So the code would look like:
volatile const uint32* pin_D0_address = 0x...; // need to look this up in the RM0008 manual at the ST.com web site.
*in_D0_address = 0;
*in_D0_address = 1;
*in_D0_address = 0;or
#define pin_D0_address (volatile ((const uint32*) 0x....))
*in_D0_address = 0;
*in_D0_address = 1;
*in_D0_address = 0;(WARNING: I haven't compiled or checked that code properly, and I may have swapped volatile and const, or worse)
Also, remember Maple runs at 3.3 volts, so you'll need something to drive that 5V. At that speed, it is not trivial.
HTH
(full disclosure: I am not a member of the LeafLabs staff)
gbulmer
Moderator
I've had a bit more think. What does the output need to look like? What determines the 'at different times' requirement?
Do you want to trigger a single narrow pulse, or do you want a continuous sequence of narrow pulses, or do you want to detect some event (or calculate something) and trigger a narrow pulse, or something else?
My thought is to set up timers to generate pulses that last one or two clock cycles.
The only options would be a single pulse, or a continous train until software can stop it, which would be several cycles.
The only way I have thought of so far would have a cycle or more of latency before anything happened.
A further constraint would be several cycles of latency between each output pin having a pulse.
My gut feeling is the speed you mention of 25ns is very hard to achieve unless all the constraints are 'just right'. I might be tempted to build something using discrete logic (or a CPLD or FPGA) and manage it with Maple.
(full disclosure: I am not a member of the LeafLabs staff)
gbulmer
Moderator
If you want to go as fast as possible, either use bitbanding (as I describe above) to change one bit, or use the "Port bit set/reset register (GPIOx_BSRR)" (defined on page 159 of RM0008) to change more than one bit in a port at a time.
The basic idea is that a port is 16 bits wide, and each port has a BSRR register.
The BSRR register is "wired up" to either set or clear (reset) any combination of the 16 bits in its port.
so using your example of changing one bit
(GPIOA_BASE)->BSRR = 0x00040000; // clears bit 2, and ignores the other bits in the port
(GPIOA_BASE)->BSRR = 0x00000004; // sets bit 2, and ignores the other bits in the port
(GPIOA_BASE)->BSRR = 0x00040000; // clears bit 2, and ignores the other bits in the portmight turn out much quicker than
(GPIOA_BASE)->ODR |= 0x4;
(GPIOA_BASE)->ODR &= ~0x4;which should read ODR, 'logical or' in the 0x04 value, then write back to the ODR, which might take more than twice as long as just writing to BSRR.
(One of the (GPIOA_BASE)->BSRR = 0x00040000; // clears bit 2 is irrelevant if the bit is already low.)
The only advantage of this over bit banding is multiple bits can be changed simultaneously.
A better explanation of bit banding is given in the STM32F manual "PM0056 Programming manual. STM32F10xxx/20xxx/21xxx/L1xxxx Cortex-M3 programming manual"
http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/PROGRAMMING_MANUAL/CD00228163.pdf
The only manuals which seem to give instruction timings come from ARM themselves:
http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337e/DDI0337E_cortex_m3_r1p1_trm.pdf
In Chapter 18 "Instruction Timing", Table 18-1,page 18-3 it says that load and store instructions take 2 cycles.
(full disclosure: I am not a member of the LeafLabs staff)
gbulmer
Moderator
After more pondering, and something to eat, I realise you could reduce the width of the pulse, and decrease the time spent creating the pulse by using a "Monostable Multivibrator". It will convert a single edge (transition), to a pulse.
So it will only take one instruction to create the pulse, not two.
The width of the pulse is controlled by component selection (i.e an external resistor and capacitor)
"The Art of Electronics" by Horowitz and Hill strongly recommends using an off-the-shelf chip.
raypm
Member
In case you were wondering, the mapping between Maple pins and GPIOx is listed here...
http://leaflabs.com/docs/hardware/maple.html#gpio-information
I also was needing this information. Pxxx is the STM pin, and Dx is the maple header pin. Cheers.
tlgosser
Member
/*
Blink - substitution for digitalWrite using BSRR and array table.
Works for all io pins on the Leaf Maple. Approx 3x faster than digitalWrite.
You must manually specify GPIOA,GPIOB,or GPIOC (listed as 0,1,or 2 in last column for convenience).
*/
#include <gpio.h>
const int digtalWriteFast[44][3] = {
{0b00000000000010000000000000000000,0b0000000000001000,0},
{0b00000000000001000000000000000000,0b0000000000000100,0},
{0b00000000000000010000000000000000,0b0000000000000001,0},
{0b00000000000000100000000000000000,0b0000000000000010,0},
{0b00000000001000000000000000000000,0b0000000000100000,1},
{0b00000000010000000000000000000000,0b0000000001000000,1},
{0b00000001000000000000000000000000,0b0000000100000000,0},
{0b00000010000000000000000000000000,0b0000001000000000,0},
{0b00000100000000000000000000000000,0b0000010000000000,0},
{0b00000000100000000000000000000000,0b0000000010000000,1},
{0b00000000000100000000000000000000,0b0000000000010000,0},
{0b00000000100000000000000000000000,0b0000000010000000,0},
{0b00000000010000000000000000000000,0b0000000001000000,0},
{0b00000000001000000000000000000000,0b0000000000100000,0},
{0b00000001000000000000000000000000,0b0000000100000000,1},
{0b00000000000000010000000000000000,0b0000000000000001,2},
{0b00000000000000100000000000000000,0b0000000000000010,2},
{0b00000000000001000000000000000000,0b0000000000000100,2},
{0b00000000000010000000000000000000,0b0000000000001000,2},
{0b00000000000100000000000000000000,0b0000000000010000,2},
{0b00000000001000000000000000000000,0b0000000000100000,2},
{0b00100000000000000000000000000000,0b0010000000000000,2},
{0b01000000000000000000000000000000,0b0100000000000000,2},
{0b10000000000000000000000000000000,0b1000000000000000,2},
{-1,-1,-1},
{-1,-1,-1},
{0b00000100000000000000000000000000,0b0000010000000000,2},
{0b00000000000000010000000000000000,0b0000000000000001,1},
{0b00000000000000100000000000000000,0b0000000000000010,1},
{0b00000100000000000000000000000000,0b0000010000000000,1},
{0b00001000000000000000000000000000,0b0000100000000000,1},
{0b00010000000000000000000000000000,0b0001000000000000,1},
{0b00100000000000000000000000000000,0b0010000000000000,1},
{0b01000000000000000000000000000000,0b0100000000000000,1},
{0b10000000000000000000000000000000,0b1000000000000000,1},
{0b00000000010000000000000000000000,0b0000000001000000,2},
{0b00000000100000000000000000000000,0b0000000010000000,2},
{0b00000001000000000000000000000000,0b0000000100000000,2},
{0b00000010000000000000000000000000,0b0000001000000000,2},
{-1,-1,-1},
{0b01000000000000000000000000000000,0b0100000000000000,0},
{0b10000000000000000000000000000000,0b1000000000000000,0},
{0b00000000000010000000000000000000,0b0000000000001000,1},
{0b00000000000100000000000000000000,0b0000000000010000,1}
};
void setup() {
// Set up the built-in LED pin as an output:
pinMode(13, OUTPUT);
}
void loop() {
(GPIOA_BASE)->BSRR = digtalWriteFast[13][1]; // sets pin 13, and ignores the other bits in the port
delay(1000); // Wait for 1 second (1000 milliseconds)
(GPIOA_BASE)->BSRR = digtalWriteFast[13][0]; // clears pin 13, and ignores the other bits in the port
delay(1000); // Wait for 1 second (1000 milliseconds)
}
@tlgosser
what would your code look like for the maple mini?
and/or how did you come up with this array so that i might be able to alter it for the mini.
thx.
gbulmer
Moderator
stephanschulz - I can try to answer those questions.
"what would your code look like for the maple mini?"
The code would be similar, the data in the digtalWriteFast[][] array might need to change to match the Maple Mini pins.
"and/or how did you come up with this array so that i might be able to alter it for the mini."
The General Purpose I/O (GPIO) ports on STM32 are quite a bit more sophisticated than, e.g. Arduino's AVR.
Each I/O pin is connected to a single, specific port. Ports are 16bits wide, so upto 16 pins can be read or written simultaneously (with a single machine instruction). Hence you need to discover which port and bit within the port a pin corresponds with.
As raypm wrote, for Maple there is a table at http://leaflabs.com/docs/hardware/maple.html#gpio-information
For Maple Mini, the table is at http://leaflabs.com/docs/hardware/maple-mini.html#gpio-port-pin-map
PC14: D13 means Maple Mini pin D13 is connected to Port C, bit 14.
If a program writes a 16bit value to a ports output data register (ODR), the value effects all of the output pins in that port.
This is often NOT what you want. It is common that a program must only change specific bits within a port.
The special case, where a program only wants to change one pin within a port is supported directly by the hardware using "bit-band addressing" (which we wrote about in a few threads). Essentially, every individual bit of every hardware peripheral has a special, alias memory address; writing to the appropriate address effects only that bit, and hence may change a single pin. That is the fastest way to change a single pin; theoretically a pin can be changed at 36MHz, but practically it is slower.
However, there is also a special register in every GPIO port, which can effect more than one bit (pin), while also leaving other bits (pins) unchanged. That register is called the "Port bit set/reset register" (Section 9.2.5 of RM0008), or BSRR, and is 32bits long (an int on Maple). Bits containing the value 1 in each of the top 16 bits set the corresponding output pin high (1); bits set to 1 in the bottom 16 bits set the corresponding pin low (0). Bits set to 0 in the top and bottom 16 bits don't effect the pin.
So the values in digtalWriteFast are values designed for the BSRR register, and set to 1, or clear to 0 one pin.
There is a downside to the technique used in that code; it needs to know which port the pin is in, so that code is actually incomplete for the general case of changing any pin. It is straightforward to fix, but worth noting. The fix would make it run slower
FYI, a quicker, and more compact approach would be to use a table of pointers to the bit-band address of each GPIO bit, indexed by the pin number, and assign the value directly. That would be less code, less storage, and run quicker. (Exercise for the reader :-)
gbulmer it seems you really take the time so answer people's posts.
unfortunately some of it is still beyond my abilities.
for maple newbies it would be great if you could provide code snippets. it would make it easier for people like me that are trying to migrate from arduino to maple.
so how would such a gpio array look like?
much appreciated.
gbulmer
Moderator
stephanschulz - I haven't much spare time, so I'll try to write some code but
WARNING I haven't tested it (Edit: I have compiled it on my Mac).
The basic approach is quite neat.
Some of this is in the bitband.h header, but I'll expand it here to make it self contained.
typedef unsigned int uint32_t;
// base address of each GPIO peripheral port
#define GPIOA_BASE ((uint32_t*) 0x40010800)
#define GPIOB_BASE ((uint32_t*) 0x40010C00)
#define GPIOC_BASE ((uint32_t*) 0x40011000)
#define GPIOD_BASE ((uint32_t*) 0x40011400)
#define GPIOE_BASE ((uint32_t*) 0x40011800)
#define ODR (0x0C) // offset of output register within port
// Address of output data register for each GPIO peripheral
#define GPIOA_ODR ((uint32_t*) GPIOA_BASE+ODR)
#define GPIOB_ODR ((uint32_t*) GPIOB_BASE+ODR)
#define GPIOC_ODR ((uint32_t*) GPIOC_BASE+ODR)
#define GPIOD_ODR ((uint32_t*) GPIOD_BASE+ODR)
#define GPIOE_ODR ((uint32_t*) GPIOE_BASE+ODR)
// Formula converts peripheral address to bit band peripheral address
// See ARMs Cortex™-M3 Technical Reference Manual for details
// Must all be calculated at compile time
#define BB_PERIPHERAL(peripheral_address, bit) ((volatile uint32_t*) (0x42000000 \
+ ((uint32_t)peripheral_address - 0x40000000) * 32 + bit * 4))
// uses http://leaflabs.com/docs/hardware/maple-mini.html#gpio-port-pin-map
// to map Maple mini pins back to STM32F103CB
// Each entry is the bit-band address of one GPIO output pin
volatile uint32_t* const bb_port_ODR_bit_address[] = {
BB_PERIPHERAL(GPIOD_ODR, 11), // D0
BB_PERIPHERAL(GPIOD_ODR, 10), // D1
BB_PERIPHERAL(GPIOB_ODR, 2), // D2
BB_PERIPHERAL(GPIOB_ODR, 0), // D3
BB_PERIPHERAL(GPIOA_ODR, 7), // D4
// ... etc
};
#define fast_digitalWrite(pin, value) (*bb_port_ODR_bit_address[pin] = value)
void setup() {
// Set up the built-in LED pin as an output:
pinMode(13, OUTPUT);
}
void loop() {
fast_digitalWrite(13, HIGH);
delay(1000); // Wait for 1 second (1000 milliseconds)
fast_digitalWrite(13, LOW);
delay(1000); // Wait for 1 second (1000 milliseconds)
}NB This has no error checking, so if the wrong pin number is used, then it will break.
However that is the same behaviour as the code by tlgosser.
gbulmer
Moderator
manitou - "so can we also do a digitalreadFast with val = *bb_port_ODR_bit_address[pin]"
Yes. I'd call it bb_port_IDR_bit_address[pin]. I think this is a reasonable draft version.
It compiles (on my Mac with a magic header), but I haven't tested it.
// base address of each GPIO peripheral port
#define GPIOA_BASE ((uint32_t*) 0x40010800)
#define GPIOB_BASE ((uint32_t*) 0x40010C00)
#define GPIOC_BASE ((uint32_t*) 0x40011000)
#define GPIOD_BASE ((uint32_t*) 0x40011400)
#define GPIOE_BASE ((uint32_t*) 0x40011800)
#define IDR (0x08) // offset of output register within port
// Address of output data register for each GPIO peripheral
#define GPIOA_IDR ((uint32_t*) GPIOA_BASE+IDR)
#define GPIOB_IDR ((uint32_t*) GPIOB_BASE+IDR)
#define GPIOC_IDR ((uint32_t*) GPIOC_BASE+IDR)
#define GPIOD_IDR ((uint32_t*) GPIOD_BASE+IDR)
#define GPIOE_IDR ((uint32_t*) GPIOE_BASE+IDR)
// Formula converts peripheral address to bit band peripheral address
// See ARMs Cortex™-M3 Technical Reference Manual fpr details
// Must all be calculated at compile time
#define BB_PERIPHERAL(peripheral_address, bit) ((volatile uint32_t*)(0x42000000 \
+ ((uint32_t)peripheral_address - 0x40000000) * 32 + bit * 4))
// uses http://leaflabs.com/docs/hardware/maple-mini.html#gpio-port-pin-map
// to map Maple mini pins back to STM32F103CB
// Each entry is the bit-band address of one GPIO output pin
volatile uint32_t* const bb_port_IDR_bit_address[] = {
BB_PERIPHERAL(GPIOD_IDR, 11), // D0
BB_PERIPHERAL(GPIOD_IDR, 10), // D1
BB_PERIPHERAL(GPIOB_IDR, 2), // D2
BB_PERIPHERAL(GPIOB_IDR, 0), // D3
BB_PERIPHERAL(GPIOA_IDR, 7), // D4
// ... etc
};
#define fast_digitalRead(pin) (*bb_port_IDR_bit_address[pin])
void setup() {
// Set up the built-in LED pin as an output:
pinMode(13, OUTPUT);
pinMode(9, INPUT);
}
void loop() {
int val = fast_digitalRead(9);
digitalWrite(13, val);
delay(1000); // Wait for 1 second (1000 milliseconds)
digitalWrite(13, val);
delay(1000); // Wait for 1 second (1000 milliseconds)
}You must log in to post.