basic stamp vs rabbit

Hi,
I am looking for a microcontroller with a 32bit architechture. That is I want to be able to do Z = X*X where X's are 16 bits and Z is 32
bits. The basic stamp doesn't do this... the rabbit doesn't seem to either (i could be wrong)... does anyone know of a 32bit microcontroller?
Thanks! juliabean
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

Hi juliabean,
I don’t think you need a microcontroller with 32 bit architecture but rather a language that supports a 32 bit variable.
I use ATMEL microcontrollers, and there are many languages available. You could use ‘C’, ‘C++’, Basic, Pascal or Forth. All of these support 32 bit variables.
You could probably find all these languages available for the PIC.
Jay -------------------------------------------------------------------- "I'm pullin' for you; we're all in this together", Red Green --------------------------------------------------------------------
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
Absolutely correct. I use PIC micros with the CCS C compiler that supports 32-bit integers and 32-bit floating point numbers.
+brw

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
In comp.robotics.misc, Bennet Williams <> wrote:

I use a clever programming trick known as "multiprecision arithmetic" in which I can code 16X16 bit multiplies with 32 bit results on an 8-bit processor with no multiply instruction at all, using only adds, shifts and branching instructions, and it runs in a millisecond or so. If you want it a lot faster than that, you probably need a processor with a built-in multiplier and/or a wider bus.
Well, maybe it's not that clever, but it's a standard technique, almost certainly used since the first digital computer. Multiprecision arithmetic can be expanded to whatever number of bits you like, limited by the amount of memory available.

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
On Wed, 14 Apr 2004 21:23:30 -0400, the renowned Ben Bradley

Sounds awfully slow to me. A midrange 20MHz PIC (200ns instructions) would take around 55usec (~270 instructions) for a 16 x 16 -> 32 signed multiply (no hardware multiplier, no microcoded "8051 style" multiply instruction).
An MSP430 with 16 x 16 hardware multiplier will do it in one clock cycle (125nsec).
Best regards, Spehro Pefhany
--
"it's the network..." "The Journey is the reward"
snipped-for-privacy@interlog.com Info for manufacturers: http://www.trexon.com
  Click to see the full signature.
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
TI MSP430.... That's pretty slow too, you know the TI DSP 32 bit processors just smoke all the other ones. Let's see at 300 mhz it can do 2 multiplies in one clock cycle or thereabouts. What's that maybe 1.5ns for a 16x162? My math isn't working good at those speeds. Heck we haven't even got to the evil 1ghz DSP chip yet either, I always start droolling when I see that one. http://focus.ti.com/docs/prod/folders/print/tms320c6713.html#features Operating at 225 MHz, the TMS320C6713C6713B delivers up to 1350 million floating-point operations per second (MFLOPS), 1800 million instructions per second (MIPS), and with dual fixed-/floating-point multipliers up to 450 million multiply-accumulate operations per second (MMACS). Operating at 300 MHz, the TMS320C6713B delivers up to 1800 million floating-point operations per second (MFLOPS), 2400 million instructions per second (MIPS), and with dual fixed-/floating-point multipliers up to 600 million multiply-accumulate operations per second (MMACS).
Info for manufacturers: http://www.trexon.com

http://www.speff.com
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
Anyone who is using a Basic Stamp isn't concerned about speed...
--
Guy Macon, Electronics Engineer & Project Manager. http://www.guymacon.com/


Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
Guy Macon <http://www.guymacon.com wrote in message

So if you write a program for a BS that reads a few switches (push to make button type) and updates an LCD display in response you don't care if the button presses are missed or the response is awful.
Regards Sergio Masci
http://www.xcprod.com/titan/XCSB - optimising structured PIC BASIC compiler
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
In comp.robotics.misc, Spehro Pefhany

I was thinking of a 1 MHz 6502 on which I first did this sort of thing. It sure seemed fast in 1977.

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
On Thu, 15 Apr 2004 14:11:25 -0400, the renowned Ben Bradley

Ha. Nice processor for multiple-byte math. I wrote my first floating-point math package for that thing back in the eighties. Variable precision. I think it was more like 1 MIPS than 1MHz (6502 was /4 clock wasn't it?)
Best regards, Spehro Pefhany
--
"it's the network..." "The Journey is the reward"
snipped-for-privacy@interlog.com Info for manufacturers: http://www.trexon.com
  Click to see the full signature.
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
On Wed, 14 Apr 2004, Ben Bradley wrote:

Where can I find a description of this technique?
---kjl
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

In an elemtary school mathematics book. Notice how two three-digit decimal numbers can be multiplied using only multiplication tables through 9*9, and techniques of adding carries:
123 456 --- 738 615 492 ----- 56088
To multiply two 16 bit numbers with an 8-bit multiply function, let's say the high eight bits of the first number is AH and the low eight bits is AL, and likewise the other 16-bit number is BH and BL:
P1 = AL * BL where P1 is a 16-bit value P2 = AH * BL likewise for P2, P3 and P4 P3 = AL * BH P4 = AH * BH
THe final product, a 32-bit number, is: PRODUCT = P1 + (P2 * 256) + (P3 * 256) + (P4 * 65536)
or using C's << operator for shifting bits,
PRODUCT = P1 + (P2 << 8) + (P3 << 8) + (P4 << 16)
Moving things around algebraically for efficiency, you can add P2 and P3, then shift the sum:
PRODUCT = P1 + ((P2 + P3) << 8) + (P4 << 16)
There's a C program on my website that generates a five-million digit number (one million factorial) using a similar technique:
http://mindspring.com/~benbradley/number_theory.html
I understand this can be done significantly faster using FFT multiplies, but I'll leave that as an exercise for the reader.

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
Ha! Yes... sometimes I use words that I don't know the meaning of: architecture. I don't know that I need 32bit architecture... but I would like to be able to perform 32bit calculations with ease, and a C compiler if possible.
Basically I want to be able to do Z = X*Y where X,Y are 16bit and Z is 32bit. I don't care about how the hardware does it, I just want to be able to use Z as one variable and not separate it into high-16 and low-16.
Is there a place I can buy these AMTEL controllers in a nice package like the basic stamp?
Thanks! julia
wrote:

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
Hi Julia
The rabbits do 32 bit integer math without any problem. They get you easy going. Personally I think that there are not many so trouble free kits out there. I was up and running after 15 minutes.
Markus
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

Hi Julia,
For Info on AVR check out; http://www.avrfreaks.net/ There are links to free Basic and ‘C’ compilers, programming software and much more.
Olimex makes simple programmers and development boards. http://www.olimex.com/dev /
And here’s the Atmel AVR site. http://www.atmel.com/dyn/products/devices.asp?family_id `7
For more Info, do a Google search for "AVR microcontroller". I got nearly 8,000 matches.
--
Jay
--------------------------------------------------------------------
  Click to see the full signature.
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

Not ATMEL, but this might interest you. See our NMI TiniARM(TM). Here is a more modern solution which has a 32-bit architecture and a 60 MHz operating speed, based on the ARM 7 processor, with a free GCC compiler. So you can have native 32 x 32 multiplies giving 64 results. 64K of RAM 128K Flash. It's just a bit larger than a Stamp, but with many times more features, about the same cost. If you want native 16 x 16 multiples for 32, we have that in a similar package great for robotics and motor control in the TiniPod(TM), but only a Small C compiler for it (plus other non-C languages). Follow the link in my sig for more info.
--
Randy M. Dumse
www.newmicros.com
  Click to see the full signature.
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
Julia Goolia wrote:

ther sure is: http://www.dontronics.com/staver.html
Cheers Don...
--
Don McKenzie
E-Mail Contact Page: http://www.e-dotcom.com/ecp.php?un=Dontronics
  Click to see the full signature.
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
On 14 Apr 2004 15:00:56 -0700, snipped-for-privacy@hotmail.com (Julia Goolia) wrote:

The TI MSP430 family has members with a hardware multiply of two 16-bit arguments and a 32-bit result.
http://focus.ti.com/docs/apps/catalog/resources/appnoteabstract.jhtml?abstractName=slau049d
or touch the search on the TI site for slau049d.pdf.
--
Rich Webb Norfolk, VA

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload
32bit processor? Then you really want a ARM based chip. Or a Hitachi/Renasas 32 bit processor. A Motorola 68832 would probably work too.
A number of C compilers have floating point libraries for doing this with other 8 and 16 bit MCU's so it really isn't a issue. Unless your wanting to do it in assembler?

Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

You are confusing microcontroller-based products such as the Basic Stamp with microcontrollers.
Any microcontroller can multiply two 16 bit values and get a 32 bit result. That's what the carry bit is for. The calculator in your purse runs on a 4-bit microcontroller.
BTW, you should also look at the BasicX line of products. See http://www.basicx.com
--
Guy Macon, Electronics Engineer & Project Manager for hire.
Remember Doc Brown from the _Back to the Future_ movies? Do you
  Click to see the full signature.
Add pictures here
βœ–
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

Polytechforum.com is a website by engineers for engineers. It is not affiliated with any of manufacturers or vendors discussed here. All logos and trade names are the property of their respective owners.