Instructions and download here: http://www.electricrock.co.nz/blog/microchip-c30/.

Latest version of the script can be found here: http://www.electricrock.co.nz/blog/microchip-c30/

The most notable update is that my previous C30 building tutorials are now deprecated in favor of a new bash script that does it automagically. Check out the page for more details.

I bought a DLP-RFID1 USB RFID tag reader/writer from Digikey (Cat # 813-1013-ND). However, I was unable to locate sufficient libraries to develop software that uses it under Linux. So I have written a C++ library to do this. Read on for more information and to download it.

The DLP-RFID1 comprises an FTDI USB-Serial IC connected to a microcontroller. Therefore the library I have developed is based on libftdi. Currently, it is very basic and supports only polling for tags (not reading and writing tags). As I currently have no need for reading and writing tags I don’t plan to add this functionality unless someone asks for it.

The library can be downloaded from http://www.electricrock.co.nz/files/rfid1/librfid1-0.1.0.tar.bz2. Documentation is provided in the package.

This is my first time making a library package for Linux, so if you find any problems or have any suggestions please leave a comment and let me know.

This an update to my previous tutorial for building Microchip’s C Compiler for PIC24 MCUs and dsPIC DSCs (herein referred to as C30). This update covers building v3.20 of the compiler (as opposed to v3.12) under Ubuntu 9.10.  Again, this is mostly gleaned from  http://embeddedfreak.wordpress.com/2008/10/10/compiling-mplab-c30-v311b-under-linux, but adapted for the latest version of C30.

These instructions also work for v3.22 and are reported to work with v3.23.

Installation

Install prerequisite software

• Install packages from the Ubuntu repositories:

  sudo aptitude install build-essential bison flex tofrodos

• Install wine (instructions available from the Wine website: http://www.winehq.org/download/deb). I used the following steps to install the latest version (you can just install the one in the Ubuntu repositories if you aren’t worried about being bleeding edge):

  sudo add-apt-repository ppa:ubuntu-wine/ppa
  sudo aptitude install wine

Setup paths

The exports below can be varied depending on where you prefer things to be put. At the risk of stating the obvious I’ll outline what each of the exports is for:

• C30BUILD is the temporary directory where the C30 tool suite is built.
• C30INSTALL is  where it will be installed to.
• DOWNLOADDIR is where you save files to when downloading.
• WINEPREFIX is where you want to install the proprietary tool suite.

export C30BUILD=$HOME/c30-build
export C30INSTALL=$HOME/Apps/pic30
export DOWNLOADDIR=$HOME/Downloads
export WINEPREFIX=$HOME/Apps/pic30-wine

Download sources, etc.

• From Microchip’s website download the sources for the compiler and binutils.  They can be found on this page: http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en023073. You will need to login to download.  You want to get:
  • GCC Code for MPLAB ASM30 for dsPIC/PIC24 v3.20
  • MPLAB C30 v3.20 GCC Source
• Download the academic or evaluation version of the proprietary compiler from the C30 website (http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010065)
• Download the patches. I have adapted these from those provided by John Steele Scott (see my previous post) to work with v3.20.
  • Binutils: http://www.electricrock.co.nz/c30/pic30-binutils-3.20.tar.bz2
  • GCC: http://www.electricrock.co.nz/c30/pic30-gcc-3.20.tar.bz2

Building Binutils

• Unzip the sources.

  mkdir -p $C30BUILD/binutils
  cd $C30BUILD/binutils
  tar -zxvf $DOWNLOADDIR/mplabalc30v3_20.tar.gz
  tar -jxvf $DOWNLOADDIR/pic30-binutils-3.20.tar.bz2
  

• The microchip sources have been edited on windows, so we need to convert files to unix line endings so that they can be patched.

  find . -type f -exec dos2unix '{}' ';'

• Apply the patches.  So far as I can tell, these fix a few compile issues with the microchip compiler and make it play nicer under Linux.

  for i in pic30-binutils-3.20/patches/*.diff; do echo "Applying patch $i..."; patch -p0 < $i; done

• Build it, the version number in DMHCP_VERSION needs to match the version of the non-free compiler you install.

   cd acme/
  CFLAGS=-DMCHP_VERSION="v3.20-Debian" ./configure --prefix=$C30INSTALL --target=pic30-coff
  

• Before we can make it we need to touch some files otherwise it doesn’t get built properly.

  find . -name "*.y" -o -name "*.l" -exec touch '{}' ';'

• Make it.

  make

• Install, if you install to a location that you don’t have write permission to (e.g. /usr/local) you will need to use sudo.

   make install 

Building GCC

• Similar process to binutils above for building GCC.

  mkdir -p $C30BUILD/gcc
  cd $C30BUILD/gcc
  tar -zxvf $DOWNLOADDIR/mplabc30v3_20.tar.gz
  tar -jxvf $DOWNLOADDIR/pic30-gcc-3.20.tar.bz2
  find . -type f -exec dos2unix '{}' ';'
  for i in pic30-gcc-3.20/patches/*.diff; do echo "Applying patch $i..."; patch -p0 < $i; done

• We take a slight deviation from binutils here as we create a separate directory for GCC to build in, apparently it likes it that way.

  mkdir build
  cd build
  CFLAGS=-DMCHP_VERSION="v3.20-Debian" ../gcc-4.0.2/gcc-4.0.2/configure --prefix=$C30INSTALL --target=pic30-coff --enable-languages=c

• Then we have to touch c-parse.y cause (according to embeddedfreak) it doesn’t get generated correctly, so we need it to be recreated. I just followed the instructions and it worked.

  touch ../gcc-4.0.2/gcc-4.0.2/gcc/c-parse.y

• Build it and install it (again, use sudo for make install if you have to).

  make
  make install

• Link the binutils into GCC’s tool path so it can find them, and create a link to GCC itself so we don’t have to type the version number every time:

  ln -s $C30INSTALL/bin/pic30-coff-as $C30INSTALL/libexec/gcc/pic30-coff/4.0.3/pic30-coff-as
  ln -s $C30INSTALL/bin/pic30-coff-ld $C30INSTALL/libexec/gcc/pic30-coff/4.0.3/pic30-coff-ld
  ln -s $C30INSTALL/bin/pic30-coff-gcc-4.0.3 $C30INSTALL/bin/pic30-coff-gcc

Next Steps

The rest of the steps are just the same as for building v3.12.  I won’t repeat myself here, just check out my previous tutorial and follow the steps from Setup the non-free part onward.

I have previously written about how I built an RS-232 adaptor for the Control 16, but this alone did not allow me to communicate with the Control 16 as I did not know its communication protocol. As I did not have the PCI card to act as a master and provide something for the C16 to communicate with, I was not able to sniff the communications and reverse engineer them. My solution instead was to replace the firmware running on the C16’s microcontroller with one that I custom wrote, and which used my own communication protocol.

Control 16 Architecture

The Control 16 is based around an Atmel AT89C52 microcontoller.  I replaced this with an AT89S52 for development as I could then use its in-circuit serial programming feature.  Using a multimeter I traced some of the connections between the microcontroller and other ICs on the board, and inferred the rest.  The result was that I was able to map out a block diagram of the mainboard, as shown below.

Control 16 Architecture Block Diagram

I’m not going to go into a lengthy explanation of the architecture unless there is someone out there who it’s useful to, so if that is you then post a comment and let me know.

Firmware Replacement

I developed the firmware replacement using the SDCC toolchain.  I have released the code under the GPL v3 license in case it may be of use to anyone. It can be downloaded here: C16Firmware. Please not that there is a bug in the current version of the firmware code. I will update it at some point, if you need it sooner let me know.

This firmware detects events from the sliders, buttons, jog wheel, and rotary encoders (though these have issues) and transmits their values via the serial port. It is also allows the values of the LEDs to be set via commands received on the serial port. So all-in-all it is almost fully functional.  The communication protocol is a fairly simple text-based protocol.

Now that the firmware is completed, the next stage in my C16 project is to develop software that runs on the host PC and converts between the simple text based protocol of the C16, and some other midi control protocol that can be used by DAW software.

Control 16 Regulator/IO Board

The pinout of the RJ-45 connector is as follows (pin 1 is on the left when looking into the connector, therefore on the right in the photo above):

While the above pinout may appear a little random at first glance, when using standard CAT5 cable it means that the pairs are RS422 in; RS422 out; +5v and GND; and +12v and GND.

Here is a schematic for a RS422 to RS232 converter, similar to what I am using myself (though I have been providing power from a lab power supply at this stage.)

Control 16 - Proprietary interface to RS232 adaptor

Please note that while I have successfully connected power and data to my control 16 without blowing it up, this information is only provided as a guide and I recommend double checking it against your actual hardware before connecting anything to your control 16.

Setup

1. Add yourself to the lp group so that you can access the parallel port without needing to be superuser (you will need to log out and back in again after this command):
   sudo usermod -a -G lp <username>
   
2. Install uisp:
   sudo aptitude install uisp
3. Connect the JTAG cable to your target device as follows:
   

   JTAG	Target
   Vcc	Vcc
   GND	GND
   TDI	MOSI
   TDO	MISO
   TCK	SCK
   TMS	RST

Some useful UISP commands

These are given for AT89S52, but for other AVR series it should work if you just drop the -d89 flag and use the appropriate part number. The main thing to note here is that the dprog flag is set to xil to indicate we are using a DLC5 for programming.

If you have issues try adding -v=3 or -v=4 for more verbose output from UISP.

Configuring the Toolchain

NB: The following assumes <C30-base> is the directory where C30 was installed (if you followed my previous tutorial this will be whatever you set for the C30INSTALL environment variable).

• Open up Piklab and go to Settings->Configure Toolchains…
• In the Configure Toolchains window select PIC30 Toolchain from the sidebar.
• Fill out the fields as follows:
  • Executable directory – <C30-base>/bin
  • Header directory – <C30-base>/pic30-nonfree/support/dsPIC30F/h/ (assuming you are using C30 to compile for dsPIC30F series–I haven’t tried any other series, so YMMV).
  • Linker script directory – <C30-base>/pic30-nonfree/support/dsPIC30F/gld/
  • Library directory – <C30-base>/pic30-nonfree/lib/
    
• The other fields can be left as the default.

Configuring the Project

For each project you will also have to do some configuration. After creating a new project, bring up the Project Options window (Project->Project Options…), and fill in as follows:

• Toolchain tab
  • Make sure PIC30 Toolchain is the active toolchain.
• Compiler tab
  • In the Custom options field enter: -mresource=<C30-base>/info/c30_device.info
• Linker tab
  • In the Custom libraries field enter: -lpic30

That should be enough to build coff files in Piklab.  I have successfully programming the dsPIC30F4013 from Piklab using the above toolchain to build the firmware and an Microchip ICD2 to download it to the PIC.  If you have any issues, if this doesn’t work for you, or if you have had some luck using a different family of PICs with C30, then please leave a comment.