Martin Riddle
Guest
Sun Jan 08, 2012 4:22 am
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic
All seem to be limited in some fashion. And need the dreaded license
keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Cheers
Rich Webb
Guest
Sun Jan 08, 2012 12:37 pm
On Sat, 7 Jan 2012 22:22:12 -0500, "Martin Riddle"
<martin_rid_at_verizon.net> wrote:
Quote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic
All seem to be limited in some fashion. And need the dreaded license
keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Add Rowley's CrossWorks to the list. It does require a dreaded key but
their policy is to license per developer rather than per machine so
licensing, e.g., your main box, a lab PC, and a traveling laptop is
fine.
It's a good product and the resulting code is unencumbered, as they use
their own non-GPL runtime library. It supports a wide variety of JTAG
dongles, including Segger's J-Link, ST-Link, Olimex, as well as their
own CrossConnect plus a bunch I've never heard of before. Includes an
RTOS as part of the package; it's not required -- I normally go with the
bare metal approach -- but is available.
Worth checking out, at least. It installs with a 30-day free trial so
one gets a reasonable time for evaluation before buying.
http://www.rowley.co.uk
--
Rich Webb Norfolk, VA
Tim Wescott
Guest
Sun Jan 08, 2012 10:10 pm
On Sat, 07 Jan 2012 22:22:12 -0500, Martin Riddle wrote:
Quote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic All seem to be limited in some
fashion. And need the dreaded license keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Cheers
CodeSourcery has a free version.
I use Gnu Arm; once you figure out what compiler flags to use, what
library code to avoid, and what functions you need to stub off yourself
(to help avoid the afore-mentioned library code), it works quite well.
--
My liberal friends think I'm a conservative kook.
My conservative friends think I'm a liberal kook.
Why am I not happy that they have found common ground?
Tim Wescott, Communications, Control, Circuits & Software
http://www.wescottdesign.com
John Devereux
Guest
Mon Jan 09, 2012 12:20 pm
Tim Wescott <tim_at_seemywebsite.com> writes:
Quote:
On Sat, 07 Jan 2012 22:22:12 -0500, Martin Riddle wrote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic All seem to be limited in some
fashion. And need the dreaded license keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Cheers
CodeSourcery has a free version.
I use Gnu Arm; once you figure out what compiler flags to use, what
library code to avoid, and what functions you need to stub off yourself
(to help avoid the afore-mentioned library code), it works quite well.
Yes second the gnu toolchain.
I did some floating point tests on the 120MHz STM32F2 today. Was fully
expecting mediocre performance since gcc has to emulate the operations
in software. But I was amazed at both gcc and the chip:
Double Precision:
0.270us / 32.406 cycles /multiply
0.238us / 28.652 cycles /add
0.234us / 28.152 cycles /divide
Single Precision:
0.181us / 21.723 cycles /multiply
0.134us / 16.101 cycles /add
0.130us / 15.602 cycles / divide
This was based on a 1000x loop with volatile variables and unrolled 10x
within the loop, so 10k iterations overall. Executing from flash. Not
very scientific since same data used each time but I checked and the FP
routines were being called each time. Need to try again with random
data.
Of course you won't see equivalent independent data published for the
commercial compilers since they make that *illegal*.
--
John Devereux
John Devereux
Guest
Mon Jan 09, 2012 12:30 pm
John Devereux <john_at_devereux.me.uk> writes:
Quote:
Tim Wescott <tim_at_seemywebsite.com> writes:
On Sat, 07 Jan 2012 22:22:12 -0500, Martin Riddle wrote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic All seem to be limited in some
fashion. And need the dreaded license keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Cheers
CodeSourcery has a free version.
I use Gnu Arm; once you figure out what compiler flags to use, what
library code to avoid, and what functions you need to stub off yourself
(to help avoid the afore-mentioned library code), it works quite well.
Yes second the gnu toolchain.
I did some floating point tests on the 120MHz STM32F2 today. Was fully
expecting mediocre performance since gcc has to emulate the operations
in software. But I was amazed at both gcc and the chip:
Double Precision:
0.270us / 32.406 cycles /multiply
0.238us / 28.652 cycles /add
0.234us / 28.152 cycles /divide
Single Precision:
0.181us / 21.723 cycles /multiply
0.134us / 16.101 cycles /add
0.130us / 15.602 cycles / divide
This was based on a 1000x loop with volatile variables and unrolled 10x
within the loop, so 10k iterations overall. Executing from flash. Not
very scientific since same data used each time but I checked and the FP
routines were being called each time. Need to try again with random
data.
Of course you won't see equivalent independent data published for the
commercial compilers since they make that *illegal*.
Oops those were bogus, many of the variables would have gone to zero or
NANs during execution, allowing the routines to terminate early. Here is
a better version, still very crude though. Anyone done better?
Double Precision:
0.415us / 49.852 cycles /multiply
0.378us / 45.403 cycles /add
2.414us / 289.702 cycles /divide
Single Precision:
0.194us / 23.350 cycles /multiply
0.250us / 30.052 cycles /add
0.610us / 73.202 cycles / divide
--
John Devereux
Nico Coesel
Guest
Tue Jan 10, 2012 3:05 pm
"Martin Riddle" <martin_rid_at_verizon.net> wrote:
Quote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic
All seem to be limited in some fashion. And need the dreaded license
keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
I use Codesourcery lite (free) and Eclipse CDT.
--
Failure does not prove something is impossible, failure simply
indicates you are not using the right tools...
nico_at_nctdevpuntnl (punt=.)
--------------------------------------------------------------
josephkk
Guest
Sat Jan 14, 2012 5:10 am
On Mon, 09 Jan 2012 11:30:50 +0000, John Devereux <john_at_devereux.me.uk>
wrote:
Quote:
John Devereux <john_at_devereux.me.uk> writes:
Tim Wescott <tim_at_seemywebsite.com> writes:
On Sat, 07 Jan 2012 22:22:12 -0500, Martin Riddle wrote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic All seem to be limited in some
fashion. And need the dreaded license keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Cheers
CodeSourcery has a free version.
I use Gnu Arm; once you figure out what compiler flags to use, what
library code to avoid, and what functions you need to stub off yourself
(to help avoid the afore-mentioned library code), it works quite well.
Yes second the gnu toolchain.
I did some floating point tests on the 120MHz STM32F2 today. Was fully
expecting mediocre performance since gcc has to emulate the operations
in software. But I was amazed at both gcc and the chip:
Double Precision:
0.270us / 32.406 cycles /multiply
0.238us / 28.652 cycles /add
0.234us / 28.152 cycles /divide
Single Precision:
0.181us / 21.723 cycles /multiply
0.134us / 16.101 cycles /add
0.130us / 15.602 cycles / divide
This was based on a 1000x loop with volatile variables and unrolled 10x
within the loop, so 10k iterations overall. Executing from flash. Not
very scientific since same data used each time but I checked and the FP
routines were being called each time. Need to try again with random
data.
Of course you won't see equivalent independent data published for the
commercial compilers since they make that *illegal*.
Oops those were bogus, many of the variables would have gone to zero or
NANs during execution, allowing the routines to terminate early. Here is
a better version, still very crude though. Anyone done better?
Double Precision:
0.415us / 49.852 cycles /multiply
0.378us / 45.403 cycles /add
2.414us / 289.702 cycles /divide
Single Precision:
0.194us / 23.350 cycles /multiply
0.250us / 30.052 cycles /add
0.610us / 73.202 cycles / divide
That is more reasonable. I was really curious about the divides being so
fast.
?-)
John Devereux
Guest
Sat Jan 14, 2012 10:54 am
josephkk <joseph_barrett_at_sbcglobal.net> writes:
Quote:
On Mon, 09 Jan 2012 11:30:50 +0000, John Devereux <john_at_devereux.me.uk
wrote:
John Devereux <john_at_devereux.me.uk> writes:
Tim Wescott <tim_at_seemywebsite.com> writes:
On Sat, 07 Jan 2012 22:22:12 -0500, Martin Riddle wrote:
I have a few Development kits, LPCXpresso, STM32FDiscovery .
Looking at the tool chains, there are at least 3 choices, IAR
Mentor(codesourcery), codeRed and Atollic All seem to be limited in some
fashion. And need the dreaded license keys.
Then there is the GNU ARM.
Any recommendations? I did find CooCox, which looks promising as a open
environment.
Cheers
CodeSourcery has a free version.
I use Gnu Arm; once you figure out what compiler flags to use, what
library code to avoid, and what functions you need to stub off yourself
(to help avoid the afore-mentioned library code), it works quite well.
Yes second the gnu toolchain.
I did some floating point tests on the 120MHz STM32F2 today. Was fully
expecting mediocre performance since gcc has to emulate the operations
in software. But I was amazed at both gcc and the chip:
Double Precision:
0.270us / 32.406 cycles /multiply
0.238us / 28.652 cycles /add
0.234us / 28.152 cycles /divide
Single Precision:
0.181us / 21.723 cycles /multiply
0.134us / 16.101 cycles /add
0.130us / 15.602 cycles / divide
This was based on a 1000x loop with volatile variables and unrolled 10x
within the loop, so 10k iterations overall. Executing from flash. Not
very scientific since same data used each time but I checked and the FP
routines were being called each time. Need to try again with random
data.
Of course you won't see equivalent independent data published for the
commercial compilers since they make that *illegal*.
Oops those were bogus, many of the variables would have gone to zero or
NANs during execution, allowing the routines to terminate early. Here is
a better version, still very crude though. Anyone done better?
Double Precision:
0.415us / 49.852 cycles /multiply
0.378us / 45.403 cycles /add
2.414us / 289.702 cycles /divide
Single Precision:
0.194us / 23.350 cycles /multiply
0.250us / 30.052 cycles /add
0.610us / 73.202 cycles / divide
That is more reasonable. I was really curious about the divides being so
fast.
?-)
Yeah that's what tipped me off too, but only after I read my post in the
newsgroup of course. :)
So avoid double precision divides if really time critical. But it's
still pretty impressive I thought. This is a ~3$ microcontroller.
I have been working on some prototype hardware that does some resistance
and capacitance measurements. It is really nice to be able to just work
directly in Ohms, Amps, Volts, Farads, seconds etc to keep everything
straight. Instead of constant fiddling with various scaling factors so
everthing fits within an int, then worrying about overflows and
underflows all the time.
--
John Devereux
josephkk
Guest
Sun Jan 15, 2012 6:08 pm
On Sat, 14 Jan 2012 09:54:46 +0000, John Devereux <john_at_devereux.me.uk>
wrote:
Quote:
CodeSourcery has a free version.
I use Gnu Arm; once you figure out what compiler flags to use, what
library code to avoid, and what functions you need to stub off yourself
(to help avoid the afore-mentioned library code), it works quite well.
Yes second the gnu toolchain.
I did some floating point tests on the 120MHz STM32F2 today. Was fully
expecting mediocre performance since gcc has to emulate the operations
in software. But I was amazed at both gcc and the chip:
Double Precision:
0.270us / 32.406 cycles /multiply
0.238us / 28.652 cycles /add
0.234us / 28.152 cycles /divide
Single Precision:
0.181us / 21.723 cycles /multiply
0.134us / 16.101 cycles /add
0.130us / 15.602 cycles / divide
This was based on a 1000x loop with volatile variables and unrolled 10x
within the loop, so 10k iterations overall. Executing from flash. Not
very scientific since same data used each time but I checked and the FP
routines were being called each time. Need to try again with random
data.
Of course you won't see equivalent independent data published for the
commercial compilers since they make that *illegal*.
Oops those were bogus, many of the variables would have gone to zero or
NANs during execution, allowing the routines to terminate early. Here is
a better version, still very crude though. Anyone done better?
Double Precision:
0.415us / 49.852 cycles /multiply
0.378us / 45.403 cycles /add
2.414us / 289.702 cycles /divide
Single Precision:
0.194us / 23.350 cycles /multiply
0.250us / 30.052 cycles /add
0.610us / 73.202 cycles / divide
That is more reasonable. I was really curious about the divides being so
fast.
?-)
Yeah that's what tipped me off too, but only after I read my post in the
newsgroup of course. :)
So avoid double precision divides if really time critical. But it's
still pretty impressive I thought. This is a ~3$ microcontroller.
I have been working on some prototype hardware that does some resistance
and capacitance measurements. It is really nice to be able to just work
directly in Ohms, Amps, Volts, Farads, seconds etc to keep everything
straight. Instead of constant fiddling with various scaling factors so
everthing fits within an int, then worrying about overflows and
underflows all the time.
Absolutemente! I did a lot of data analysis software once upon a time and
it was all in base units until it was printout time, whence i converted to
engineering units.
?-)
