- 80 MHz
- 512K FLASH
- 128K RAM
- 16 Channel 10bit A/D
- USB 2.0 OTG
- 6 UART
- 4 SPI
- 5 I2C
- 2 CAN
- 10/100 Base T
The Max32 board also includes a USB to serial converter, 3 and 5 volt supplies, and 5 LEDs: 1 for power, 2 for USB send/receive and 2 connected to PIC digital I/O pins. Power can be provided through the OTG USB connector, through the PICkit connector (not populated) or through a coaxial power connector. Power provided through the connector can be regulated 5 volt or unregulated 9-15 volts.
83 PIC I/O pins are brought out to connectors on the board.
The Max32 connects to the PC via an OTG USB cable. This has a standard Type A USB connector on the PC side, and a mini-USB on the Max32 side. The mini-USB looks annoying similar to the ubiquitous micro-USB commonly used for cell phone chargers. It is more or less standard for OTG USB, however, and is the cable used for the Beagle Board and PICkit, among others.
Basic I/O Shield
|Basic I/O Shield|
|LED connected to OC1|
Programming with MPIDE
The environment is a clone of the Arduino environment, and most Arduino sketches run without modification. MPIDE also includes a serial monitor, so serial data may be sent from the PIC and observed within MPIDE.
There are libraries for the various Basic I/O Shield peripherals in addition to the standard Arduino libraries, so using the temperature sensor, EEPROM or OLED display is a simple matter of making the appropriate library calls. Of course, the switches, buttons, LEDs and potentiometer use the standard read/write digital or analog calls.
The compiler is quite slow, apparently because libraries are compiled on the fly. Programming over the serial connection to the bootloader is also relatively slow, so development is relatively slow business. In addition, there is no in-circuit debugging capability, although the readily available serial connection relieves this somewhat.
Although the environment uses normal Arduino calls, standard PIC references are available as well. Of course, this would mean that the sketch would not be compatible with an Arduino. But instead of
digitalWrite( PIN_LED1, HIGH);
one could say
_LATC1 = 1;
This doesn't seem like much of a difference either way, but consider setting several pins of a port to outputs:
pinMode( 17, OUTPUT );
pinMode( 38, OUTPUT );
pinMode( 58, OUTPUT );
pinMode( 59, OUTPUT );
TRISA &= 0xfff0;
(the Arduino commands reference pin numbers on the board, rather than anything related to the port).
Programming with MPLAB-X
|PICkit 3 and Max32|
This is considerably faster and allows for debugging. If the developer wishes to return to using MPIDE, the bootloader must be reprogrammed using the PICkit, a rather simple process. When using the PICkit, there is not enough clearance to use either the OTG USB port or the coaxial power connector, so the circuit must be powered by the PICkit.
It isn't clear to this writer that programming with MPIDE is any easier than with MPLAB, however, the small size and lack of features of MPIDE make the process less intimidating. This is emphasized by the small size of the boards and the simplicity of simply having the board connected to the PC with no power cables, no programmers, no external additions.
In MPIDE, the user provides two functions, setup() and loop(). The main() function is provided by the frameworks. While this fits the overwhelming majority of applications, it is somewhat limiting in some situations. Nonetheless, it does provide some structure for the new developer.
Although the documentation claims that the environment uses C, there are some C++ features. Some libraries, for example, are provided as classes so the user must instantiate the class in order to use the library. Most of the standard functions, tho, are C functions, so attempts to use other C++ features could result in unnecessary complication.
The IDE places the user projects, or "sketches", in a "sketchbook". The sketches are easily available from the menu, making it quite convenient when small number of projects are available. Many examples are also available from the menu, so it is easy to find examples when the programmer doesn't remember how some function is used.
The shields connect together through standard, wire wrap 0.1" spacing sockets. However, the power connector is offset slightly from the other connectors, making it inconvenient to use standard 0.1" protoboards. There are shield protoboards available, but that adds significantly to the cost of experimentation.
The PIC32 is a 3.3 volt device. Most Arduinos are 5 volts. All of the PIC32 pins are 5 volt tolerant, but the outputs probably won't provide sufficient voltage for most Arduino peripherals.
The Max32 is a very nice development platform. The PIC32MX795F512L is an amazingly competent part with stunning speed and huge memory. Programming is virtually identical to the dsPIC/PIC24 families. The Basic I/O shield provides a range of peripherals that allow for significant experimentation, and the FETs allow for connection to motors, relays or other high energy devices.
However, the 3.3 volt format limits access to many devices, especially most Arduino shields. The graphics OLED is a very nice (if tiny) display to play with, but in a purpose-built circuit the experimenter will almost certainly prefer an LCD, and there is no facility to learn this peripheral. The particular display chosen does not seem to be widely available so that option is probably closed to the developer as well.
The cost, however, is attractive. Including the OTG USB cable both boards plus cable come in at under $90 at the current time. Most of the benefit could probably be gotten with the Uno32, saving about $20. The Uno has considerably less memory and fewer I/O pins (42 vs. 83). The Uc32 provides an intermediate step, combining the smaller size and fewer I/O pins of the Uno with the large memory of the Max, for an intermediate price.
All in all, a fun development environment, and not a bad way to break into microcrocontrollers, providing the user recognizes the limitations.