Home > ARM, Development boards, Reviews > Review: ChipKIT Uno32

Review: ChipKIT Uno32

Name: ChipKIT Uno32
Distributor: Farnell
Price: £18.94 ~ $30

Evaluation Type: Development Board, PIC32
Application you used the part in: Arduino form-factored development/prototyping
Was everything in the box required?: The box only contains the board itself, nothing else
What were the biggest problems encountered?: Shield compatibility with other Arduino shields (should be 3.3V compatible)

Product Performed to Expectations: 8
Specifications were sufficient to design with: 10
Demo Software was of good quality: 6
Demo was easy to use: 9
Support materials were available: 7
The price to performance ratio was good: 10
TotalScore: 50/60

When the Arduino were developed as a university project some years ago nobody knew that it would become such a big invention. Since then many different companies, including Google and Texas Instruments recently, have tried to cream off some of the profit in this great invention by making their own Arduino form-factored boards but with their processor family.

The ChipKIT Uno32

Another manufacturer who has decided to try that is Digilent. Digilent teamed up with Microchip and designed the Chipkit family which consists of a PIC32 device with a number of different peripherals.
In this review we are going to look at one of the Chipkit boards sold by Farnell, the Chipkit Uno32 which is a look-a-like of the Arduino Uno. We will compare the board to the original Arduino of course but also compare it against some of it other “form-factored” competitors.

Video review
Most of the review is done in video to show you the board and the comparison in real. The written review here is a summation of the video presentation.
So I recommend you to watch the Video review first and then get back to this written review.

The PIC32
In the heart of the ChipKIT Uno32 there is a PIC32MX320F128. This 32-bit PIC processor is running at 80MHz compared to the Arduino Uno 16MHz and with this processor you also get an astonishing amount of 128KB Flash and 16KB RAM. The peripherals are the same though with an improvement in the numbers BUT the PIC32 is running at 3.3V while the Arduino is running on 5V. This might induce problems with some shields not compatible with 3.3V systems.
Please refer to the “Comparison” section for a deeper look on the changes.

One negative aspect of the Uno32 board is the missing USB functionality. Some of the PIC32 devices comes with USB OTG functionality except for the device chosen for the Uno32. Its’ larger brother, the ChipKIT Max32, holds a PIC32 device with USB OTG functionality, so if this is required you have to spend some more money on the larger version of the board.

The board
Seen from the top the board has the exact same form-factor as the Arduino Uno.

Seen from the top

The board contains the same IO connectors at the same spots as the Arduino Uno. When designing the board Digilent decided to route PIC32 pins with specific features to the right pins on the IO connectors making the board an ideal replacement for the Arduino as your shields will be pin-compatible. As mentioned though you have to make sure that the shield can run on 3.3V – but in most cases it can. Here I should remember to mention that all of the IOs of the board is either 5V compliant inside the PIC or made 5V compliant thru a series resistor and the internal clambing diode. So you should not be afraid of connecting the ChipKIT boards to 5V electronics. The only problem that can be is if the 5V electronics doesn’t sense a 3.3V signal as a High.

An IO routing chart with comparison against the Arduino Uno, Arduino Mega and the ChipKIT Uno32 can be found here: ArduinoChipKitPinMappings.pdf

In the video we tested the old Ethernet Shield (without the SPI connector at the bottom) and this worked out of the box with the Ethernet library.
For the newer Ethernet Shields with the SPI connector you have to make a small fix either on the Uno32 or on the Ethernet Shield. The fix cuts the reset trace which is shared both on the SPI connector and on the shield reset pin – unfortunately the SPI connector on the Uno32 doesn’t have the common reset pin but a normal IO instead, so if connected the PIC32 will be resetting itself.

I decided to make a comparison against the Arduino Duemilanove and the iTeadMaple which is another Arduino form-factored board with an ARM Cortex-M3 processor (review can be found here). In the chart below we have tried to compare most of the processor specific features of all three boards.

Comparison: Uno32 vs Arduino Duemilanove vs iTeadMaple

One of the noticable things is the number of PWM outputs. The ChipKIT Uno32 does actually have one less than the Arduino Uno which is very bad indeed.
Though compared to the iTeadMaple the ChipKIT Uno32 hasn’t got far from as many peripherals as that board. So if you are looking for great many peripherals, IOs etc., you should have a look at the Maple boards.

The compiler
The Arduino is well know for its’ easy programming language in C (combined with C++) and the easy IDE. The programming language is exactly the same for the ChipKIT Uno32, and the IDE is looking the same though named MPIDE and you just have to download it from the Digilent homepage.
The common Arduino functions like Delay, digitalWrite, analogRead, Serial etc. have all been ported to the ChipKIT family so you should be able to compile Arduino sketches for the ChipKIT as long as it doesn’t rely on any processor specific register writes etc.
The PIC32 processor is programmed thru a serial Bootloader and like on the Arduino the ChipKIT Uno32 also contains a USB to serial converter chip. The IDE integrates nicely with the board, just like with the Arduino, and with a press of the upload button the board is programmed.

To optimize the GPIO speed it is recommended to use direct port register writes instead of the digitalWrite. For PIC devices the output port setting register is called LATx, where X is the port identifier.
To show how fast the ChipKIT Uno32 really is I decided to port the LCD Library for the iTeadStudio ITDB02 LCD display. This library makes use of the direct port writes which makes a great increase in the display refresh rate.
The download link for the library can be found in the bottom of this post.

Speed testing
So to do a better speed comparison I decided to try measure the generated toggling frequency using the digitalWrite function versus the direct port writing versus direct port toggling registers.

When using digitalWrite High and then Low on the ChipKIT Uno32 it were able to generate a 650KHz signal. This is not much compared to the processor running at 80MHz.
So instead I tried toggling a bit doing LATx writes and this generated a much faster signal. The frequency were now 4MHz so that was a big increase!

In the video I also compare the ChipKIT Uno32 against the iTeadMaple and at toggling of IOs with direct port register writes the iTeadMaple did only generate a signal of 1.3MHz.
But yet again if doing the toggling with digitalWrite the iTeadMaple were actually around 9% faster than the ChipKIT Uno32.

So if you need speed and knows how to do the register port writes you should go for the ChipKIT Uno32. But if you need a decent speed and would like to stick to the built in functions you should go for the Maple family.

Pros and Cons

  • Really inexpensive but powerful Arduino form-factored board
  • Easy replacement for the Arduino
  • Same programming language and IDE layout
  • Well done I/O similarity to Arduino UNO/Duemillanove
  • Fair compatibility with other shields


  • No on board pull-up resistors on the I2C lines
  • Maximum current draw of 18mA pr. IO or 200mA total
  • The Wire library is not working yet (as pr. 26th May 2012)
  • No USB peripheral due to the selection of PIC32

To say it in short the ChipKIT Uno32 board is a great replacement for the Arduino if you need some more power but still would like to stick with the Arduino “environment”.
Even though there are many other Arduino form-factored board the ChipKIT Uno32 stands out by using a PIC microcontroller as the PIC microcontrollers are the counterpart to the AVR family.
The supported hardware libraries are still a bit limited regarding the number of different shields you can get for the Arduino – but hey, it’s a matter of time when they get ported.

For many electronics enthusiasts and hobbyists the price is certainly one of the most important factors. At a price of around $30 the ChipKIT Uno32 costs the same as a new Arduino UNO so there is definitely no reason not to take a closer look on this faster and more powerful variant.

Thank you to Farnell for letting us test this board and hopefully you have got some useful information for your upcoming development board selection.

As demonstrated in the video review we’ve ported the LCD Library for the iTeadStudio ITDB02 LCD display to the ChipKIT Uno32. This library can be downloaded here: ITDB02_Graph.zip

The speed testing code for the ChipKIT Uno32 can be found here, including comments on the measured speed: ChipKIT_Uno32-SpeedTest.pde

To download other materials of the board, including schematics, datasheets and of course the compiler please refer to the Digilent product page: Digilent CHIPKIT-UNO32

Categories: ARM, Development boards, Reviews Tags:
  1. Fabio Utzig
    May 27th, 2012 at 16:42 | #1


    The Microchip PIC32 processor is not an ARM Cortex-M3. It is based on MIPS architecture.

    Fabio Utzig

  2. May 27th, 2012 at 18:01 | #2

    @Fabio Utzig
    I know. When I talk about the ARM Cortex-M3 I refer to the comparison board, the iTeadMaple which contains an STM32 device.
    Regards Thomas

  3. Fabio Utzig
    May 27th, 2012 at 18:44 | #3

    I just mentioned it because you wrote this at the beginning:

    Name: ChipKIT Uno32
    Distributor: Farnell
    Price: £18.94 ~ $30
    Evaluation Type: Development Board, ARM Cortex-M3

    Mentioning Cortex-M3 here might be deceiving.

  4. May 28th, 2012 at 00:34 | #4

    @Fabio Utzig
    Ahh sorry, thank you for the notice that is indeed wrong!

  5. July 23rd, 2012 at 00:15 | #5

    I love your videos, this explain to me some thing I never new, I had issues with speed with arduino uno and got it almost fixed with chipkit uno32 and big noticeable different in speed , but I still need it to be faster for my application, I am using serial input for example
    if(data1[1] != 0x30 && data1[2] != 0x31 ||
    data1[1] != 0x30 && data1[2] != 0x30 ||
    data1[1] != 0x30 && data1[2] != 0x43){
    digitalWrite(led, HIGH);
    digitalWrite(led0, LOW);
    digitalWrite(led8, HIGH);
    what I am trying to do in here I am switching data throw a mini solid state relay to certain incoming data, on the chipkit uno32 doing well but some time skips due fast incoming serial that doesnt catch it, so could you please give me a sample code for the input high to low
    by toggling a bit doing LATx writes without the use of digital right since I dont know about it.

    LATD |= (1 << 8);
    LATD &= ~(1 << 8);
    what would be for pins 1,2,3,4,5,6,7,8 and so on?
    and the other thing is there another faster way to read in a different way then if(data1[1] != 0x30 or ==? what and how would be , could you please let me know since my program depends highly on high speed data.read and digital write.
    thank you so much

  6. July 26th, 2012 at 22:35 | #6

    @Sam Hemdan
    Dear Sam.
    I understand most of your question though you have to elaborate on the part about the use of the serial port.
    The problem you have is that caused by data being lost at the serial port? Or is it caused by the board not being able to process the data fast enough?

    To turn on an output you should use “LATx |= …”
    To turn off an output you should use “LATx &= ~…”

    To find out which LAT register to use you have to find the port and pin identifier where the output is located.
    To do this I recommend you to look at the ArduinoChipKitPinMappings.pdf file.

    For the D3 (pin 3) on the ChipKIT Uno32 you would have to use the following line to turn on the output:

    LATD |= (1 << 0);

    And for D4 it would be:

    LATF |= (1 << 1);

    I guess you can also optimize your if code like this:

    if (data1[1] != 0Ã?30 && data1[2] != 0Ã?31 & data1[2] != 0Ã?30 & data1[2] != 0Ã?43)) {

    But I am actually unsure how much it will help in speed as the compiler should be doing these kind of optimizations when you compile the project.
    And I also don’t understand your If line correctly as it doesn’t make any sense as it will always give 1 except when data1[1] == 0x30 – so it doesn’t care about data1[2]!

    Best Regards
    Thomas Jespersen

  7. GrahamM
    October 2nd, 2012 at 15:16 | #7

    Why not utilise LATxINV y(where x is the port and y is the bitmask) if you want to toggle a pin? If you’re in a tight loop toggling a pin, you should see just shy of 14MHz (Measured 13.97MHz on my Uno32) – that’s a lot faster than the 4MHz you saw.

    Yes, I’m using the MPLABX IDE, because I’m tired of having to heft out trash from Arduino libraries that just adds bloat, screws up IO, and slows things down.

  8. GrahamM
    October 2nd, 2012 at 15:42 | #8

    I’ve also realised that your count of peripherals isn’t correct. There are two SPI and two I2C ports accessible. The second SPI port is on J5-11, J5-09 and J5-07 as well as J8. The first SPI port is on J6-03, J6-01 and J5-10. The I2C ports are on J7-09/J7-11 and on J5-12/J5-14.
    There are also 16 inputs to the ADC, although two of them only appear on the ICSP header.

  9. October 3rd, 2012 at 10:45 | #9

    I was wrong about the I2C and SPI ports. It is correct there is two.
    One I2C at pin A4 and A5 as standard and another one at pin 39 and 40.
    For the SPI there is also two. The standard one at pin 11, 12 and 13 and another one on pin 38, 0 and 1.
    So you are right – thank you for reminding me.

  10. April 16th, 2014 at 05:56 | #10

    Can you share ethernet library created by you

  11. May 23rd, 2014 at 22:19 | #11

    We have not created any Ethernet library.
    The library used in the video demonstration is the one that comes with the MPIDE originally made for the Arduino Duemilanove/Uno and then ported to the Uno32.
    As shown in the video demonstration you should be able to find the examples within your MPIDE already.

    Regards Thomas

  1. No trackbacks yet.