Monthly Archives: January 2014

Version 0.8.3a brings options and manuals!

optionsWith the release of version 0.8.3a we now have a facility for providing board-level compilation options.  These are options which can be defined at either the board, core or compiler level (or any combination of the three) and allow the enabling and disabling of various compiler flags.

That could be as simple as turning on/off compiler warnings, or as complex as changing the entire way the core compiles.

It’s great for such things as optionally enabling USB support for a board, or dynamically compiling for different clock speeds, etc.  Anywhere where you have multiple versions of the same board which differ from just a few compiler options (such as -D macros) you can now combine the boards into a single board and use options to configure it as you like when you like.

The option system is detailed in the wiki at http://uecide.org/wiki/index.php/Options

Another great addition is the ability to include a manual PDF file in with a board.  The board directive “manual=…” can point to a file (typically PDF, but doesn’t need to be) stored within the board definition folder somewhere, which is then linked to by an entry in the Help menu: “Manual for <board name>”.  I was basically fed up of googling the manual for a specific board every time I wanted to check a pin arrangement, etc, so I thought this would be a much better way to have the manuals at my fingertips without needing to download them every time or try and remember where I saved them before.

The menu entry changes as you select a different board, and if there is no manual for that board in the definition then the manual menu entry will be hidden.


Two new officially supported boards

Two new boards are now officially supported.  Thanks to the generosity of the guys at Microchip we now have a MAX32 and a WF32 board for testing and compatibility checking.

Image

The WF32 board is a rather interesting one.  It’s a pretty well packed board.  The most prominent feature of course is the MRF24WG0MA 802.11g WiFi module.  Will full support for all the common authentication technologies (WPA2, etc) it’s a pretty nice module.

More subtle, though, is the triple USB connections.  Not only is there the traditional FT232 USB UART connection for programming, but the on-chip USB peripheral is also provided with a choice of both host (USB A) and device (Micro USB) connectors to choose from.

And top that off with a micro SD card slot as well and you’ve got yourself a fully featured WiFi connected system.

Getting everything to work right though was a bit tricky.  Some changes to the way UECIDE works were needed for the Digilent WiFi libraries to compile properly.  It turns out that they rely on different libraries being included in a specific order for some files to override others.  A neat trick, if a bit fragile…  Still, a few tweaks to the core of UECIDE’s compilation system and it works nicely.

My only gripe really with this board is that the SD card is connected to some plain GPIO pins rather than one of the 4 SPI peripherals available on the chip.  This means you can only use software SPI to communicate with it, which means things like RetroBSD won’t work on it without adding another SD card slot.

chipKIT-Max32-obl-500The MAX32 board is the chipKIT equivalent to the Arduino Mega, or I suppose more closely now matched by the Due.  IT has the same chip as the WF32 board, but lacks any of the bells and whistles that the WF32 has.  Instead it just has lots and lots and lots of IO pins in almost the same arrangement as the Mega and Due boards.  It has the same FT232 interface as the WF32 and Uno32 boards, and the same auto-switching power circuitry of the Uno32 (something the WF32 lacks – it’s a purely manual power source selection on that board), so it’s essentially an Uno32 with more pins, more flash, and more RAM.  It also has the more advanced peripherals available, such as an Ethernet controller (which is required for the chipKIT Ethernet shield) and a USB On-The-Go peripheral, but there are no connectors linked to it like the WF32 has.

It’s still a decent board though, and adding an SD card (maybe the one on the Ethernet shield, for example) allows it to run RetroBSD.

Both these boards are now fully supported by UECIDE, and you even get an extra bonus thrown into the mix:  Where MPIDE just gives you the default FT232 connection for serial, UECIDE also has the option to enable the USB peripheral as a CDC device as well, in the same way as the Fubarino boards.  Yes, MPIDE can be bent to give you USB serial if you know how, or you could fight with the Digilent USB device libraries, but why bother when it’s already all there for you?


Version 0.8.2a released

A new version of UECIDE – version 0.8.2a – is now available for download.

The major change in this update is the addition of what I am calling “SAR” files. These are “Sketch ARchives”, which are basically a JAR file (which itself is just a special ZIP file) which contains information about a sketch, the sketch folder itself, and any contributed libraries the sketch uses.

You can now export your sketch as a SAR file, email it to someone, post it on a forum, whatever, and someone else can then import that SAR file, and it should just compile straight off for them. No hunting around for the right libraries, etc – just one file with it all in.

You can also use it for archiving sketches. Because it bundles all the required libraries in with the sketch you won’t have the problem of hunting the internet for the right libraries when you dust off that old project you started two years ago.

And because it’s basically a ZIP file you can even unzip it manually to get at the data in it, so you’re not really restricted to using it with UECIDE. It’s just easier if you do.


Welcome

Welcome to the new UECIDE blog.

I felt it was about time I made a blog to help keep people up to date with what we have planned for the future of UECIDE – what is in the works, what we’d like to add in the future, etc.  And so, here it is.

So without further ado, what is happening in the UECIDE-o-sphere?

New systems

We are in the process of adding new families of hardware targets.  Most notable of these is the PIC16 target, mainly for the CHIPINO family of boards, but can also be used with any PIC16 based board.  We’re experimenting with using the open source SDCC (Small Device C Compiler) compiler, which if we get it working right for all platforms will also open the door to many other 8-bit chips, such as the Z80 and the 8051 amongst others.

Also in the works is support for the Teensy boards.  Unfortunately we don’t actually have a teensy board to try our code out on, so all we can do at the moment is hope that it’s working until we can find someone to test it out for us (or who can donate some hardware to us).

New Preprocessor

Experiments are underway to create a new source code preprocessor to replace the rather simplistic regex based preprocessor that is a hangover from the Arduino code.  We are looking into the possibility of using the compiler (when it has such facilities) to do proper preprocessing of the code.  This will allow proper use of #define macros to selectively compile code which, until now, have been causing untold problems with the automatic insertion of function prototypes.

Theme System

Big changes to the theme system are on the horizon.  What we really want is a nice clean way for the end user to be able to edit the theme, or install third party theme archives, through a nice simple user interface.  No more fiddling with theme.txt files.  Integrating it with the plugin distribution system would also be one of the main goals – maybe massively expanding the whole plugin manager system in the process.  Watch this space.

New Name

While the name UECIDE is perfectly adequate and describes exactly what UECIDE is, it’s not really a catchy name.  Other IDEs have great names – Eclipse; Anjuta, Netbeans, to name but a few.  UECIDE just doesn’t trip off the tongue.  So we’re in the market for a new name.  We’ve had a few suggestions already, from ranging from the ambiguous Chameleon to the rather tasteless Suecide, but none of them have yet really jiffled our tipples.  It needs to be something that encapsulates the whole idea of the universal IDE; the IDE to rule all IDEs (and no, Ring IDE or Nasgul IDE aren’t really in the running I’m afraid).  So get your thinking caps on. Suggestions on a postcard please.