mercoledì 13 giugno 2012

How to setup a PIC development environment in FreeBSD

Abstract

Setting up a Microchip's PIC microcontroller development environment in FreeBSD is very easy because most of the packages we need are already in the ports. In this post I'll show you which packages you should install in order to develop, compile and write your code into your microcontroller. Then I'll show you how to configure your IDE (Piklab) to compile applications and flash your PIC.
This isn't a C tutorial, if you are looking for a guide to learn how to program in C you may search on Google.

Warning

First of all, the use of pk2cmd in FreeBSD is "very experimental" (as you can read on ReadmeMakefile.txt file). Some features, such as multi-programmers support or firmware updates, are not supported or require a different OS . So please use it carefully.

Packages

The packeges required for setting up the environment are:
  • sdcc, a small c compiler for microcontrollers, is available in the ports
  • pk2cmd, the official Microchip programmer, can be downloaded here
  • Piklab, an IDE written in QT, is also present in the ports tree
In addition, there are some "hardware" requirements:
  • a PIC programmer, I used the Microchip's Pickit II
  • a development board or an ICSP circuit 
  • a PIC microcontroller (go figure!), in my case I used a PIC16F877A

Installation

The install phase requires root privileges in order to write files in system folders. By typing:
# cd /usr/ports/lang/sdcc && make install clean 
the port will install the SDCC compiler.
So, to fetch and install the Piklab type:
# cd /usr/ports/devel/piklab && make install clean 
pk2cmd isn't in the ports tree, so I had install it from a tarball. In the download directory, run:
tar xvf pk2cmdv1.20LinuxMacSource.tar.gz 
The next step will show you how to compile the source:
cd pk2cmdv1.20LinuxMacSource/ && gmake freebsd 
and to install, it run (root privileges required):
# gmake install

Configure

Now let's see how to configure the environment ,so that a non-root user can easily access to the PIC programmer. First of all, we had to configure devfs for read and write permissions in the USB devices.
As root, add the user to the operator group, typing:
# pw groupmod operator -m $USERNAME 
Edit the /etc/devfs.rules file (create it if it doesn't exist) and add these lines:
[system=10]
add path 'usb/*' mode 0660 group operator
To load the rules at the startup, add this line at /etc/rc.conf file
devfs_system_roleset = "system" 
Then restart devfs by running
# /etc/rc.d/devfs restart

Piklab is a complete IDE for microcontroller developing, but out-of-the-box it doesn't support Pickit II. Next step I'll show how to configure a custom programmer to use pk2cmd.
Run piklab and open Setting -> Configure Programmer, select  Custom Programmer and add these lines:
read pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -GF %O
erase pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -E
program pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -F %O -M
verify pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -F %O -Y
blank check pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -C
run pk2cmd -PPIC%DEVICE -B/sr/share/pk2/ -T
stop pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -R
save by clicking OK.
Create a new project (Project->New Project) as you can see in Fig.1
Fig.1 - New Project form
Now clicking on the project Piklab will open the project setting window, then select "Toolchain" tab. In "Compiler" add a new include folder writing:
/usr/local/share/sdcc/non-free/include/ 
in "Include directories", then click "Add" (Fig. 2)
Fig.2 - Compiler Tab
Select "Linker" tab and in "Custom options" write:
-L/usr/local/share/sdcc/non-free/lib/pic14 
Pay attention to the last folder's name, it is the PIC16F877A's folder. With other PICs it may be different.
Then save by pressing OK.
Fig.3 - Linker Tab

And that's all falks! Now Piklab is able to compile and store your programs on the microcontroller.

Conclusions

In this post I showed you how to set up a complete PIC development environment in FreeBSD. Piklab has some features that simplify your work. For example its "Config generator", available in "Tools" menu, generate the code to configure your PIC.

giovedì 7 giugno 2012

Programmare microcontrollori PIC su FreeBSD

Introduzione

In questo post vedremo come programmare microcontrollori PIC in ambiente FreeBSD. In particolare come configurare l'IDE Piklab per aiutarci a scrivere i programmi e flashare il PIC. Non mi soffermerò sulla parte di programmazione, quindi se cercate un buon corso di programmazione per PIC vi consiglio quello di settorezero. Se invece siete alla ricerca di una guida per le distro di Linux vi rimando al blog di Salvatore Salzano punti di (s)vista.

Premesse 

Prima di incominciare mi preme ricordare che l'uso di PK2CMD su FreeBSD, come potete leggere nel file ReadmeMakefile.txt, è "very experimental"; questo significa che non è stabile e alcune operazioni, come l'aggiornamento del firmware del pickit2 e l'utilizzo di più programmatori contemporaneamente, non sono supportate e/o vanno effettuate su altri OS.

Cosa ci serve

Per cominciare a programmare il nostro microcontrollore abbiamo bisogno di:
  1. un microcontrollore (of course), io ho provato con un PIC16F877A
  2. Pickit2: il programmatore originale Microchip, reperibile facilmente in Rete dai siti specializzati. Il prezzo si aggira intorno ai 30/40 euro
  3. sdcc : un compilatore C per microcontrollori, che potete trovare nei ports
  4. pk2cmd: programma per flashare il pic, scaricabile qui.
  5. Piklab: un IDE per la programmazione dei microcontrollori, anch'esso presente nei ports
Abbiamo inoltre bisogno di un circuito elettronico per collegare il Pickit2 al microcontrollore e quest'ultimo ai vari componenti. Io personalmente ho collegato il tutto con una breadboard seguendo lo schema fornito nella lezione 2 del corso di settorezero; comunque esistono anche schede di sviluppo facilmente reperibili in Rete (anche se dal costo abbastanza elevato).

Installazione

Procediamo con l'installazione dei programmi necessari. Per quanto riguarda sdcc non ci dovrebbero essere problemi, basta installarlo dai ports, da root lanciamo:
# cd /usr/ports/lang/sdcc && make install clean
Anche Piklab è presente nell'albero dei ports, per installarlo digitare:
# cd /usr/ports/devel/piklab && make install clean
Adesso installiamo pk2cmd, prima di tutto spostiamoci nella cartella dove lo abbiamo scaricato ed eseguiamo
tar xvf pk2cmdv1.20LinuxMacSource.tar.gz
Una volta scompattato il file compiliamolo con il comando:
cd pk2cmdv1.20LinuxMacSource/ && gmake freebsd
Se vogliamo installarlo dobbiamo ottenere i diritti di root e digitare
# gmake install
altrimenti possiamo utilizzare i binari dove si trovano. Ricordatevi che non essendo un port non può essere manipolato con gli strumenti messi a disposizione dal sistema operativo.

Configurazione dell'ambiente

Per poter utilizzare pk2cmd anche da utente non amministratore dobbiamo configurare devfs in modo opportuno. Prima di tutto aggiungiamo il nostro utente al gruppo operator
# pw groupmod operator -m $USERNAME
dove al posto di $USERNAME mettiamo il nome del nostro utente. Aggiungiamo al file /etc/devfs.rules (bisogna crearlo se non esiste) le seguenti linee
[system=10]
add path 'usb/*' mode 0660 group operator

poi editiamo /etc/rc.conf e aggiungiamo questa linea
devfs_system_roleset = "system"
ora ricarichiamo devfs con la nuova configurazione eseguendo
# /etc/rc.d/devfs restart
Ora passiamo alla configurazione vera e propria di Piklab, così da permetterci di sviluppare, compilare e flashare il dispositivo senza (quasi) l'uso della riga di comando. Inoltre permette di configurare i registri del dispositivo senza scrivere tonnellate di codice a mano.
Qui di seguito vado a riassumere quanto già scritto sulla guida di punti di (s)vista a proposito di Piklab, dopo di che spiegherò come configurare il compilatore e il linker per compilare i sorgenti del progetto.
Avviamo Piklab e spostiamoci su Settings-> Configure Programmer, selezioniamo Custom Programmer e inseriamo i seguenti comandi:
read pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -GF %O
erase pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -E
program pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -F %O -M
verify pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -F %O -Y
blank check pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -C
run pk2cmd -PPIC%DEVICE -B/sr/share/pk2/ -T
stop pk2cmd -PPIC%DEVICE -B/usr/share/pk2/ -R

e salviamo premendo OK.
Adesso creiamo un nuovo progetto da Project->New Project riempiamo la form che ci viene proposta come in Fig 1
Fig 1 - configurazione nuovo progetto
una volta creato il nuovo progetto, clicchiamo sull'icona del titolo ci apparirà una finestra con le opzioni del progetto, selezioniamo il tab "Toolchain". Nel tab "Compiler" aggiungiamo una nuova cartella degli include aggiungendo in "Include directories" la cartella
/usr/local/share/sdcc/non-free/include/
come riportato in Fig. 2
Fig. 2 - Aggiunta della nuova cartella di include
Ora spostiamoci su "Linker" e alla riga "Custom options" aggiungiamo:
-L/usr/local/share/sdcc/non-free/lib/pic14
se state utilizzando un pic diverso dal PIC16F877A, l'ultima cartella potrebbe cambiare, nel caso aggiungere la cartella esatta.
Fig. 3 - configurazione Linker
Ora non vi resta che scrivere il programma in C; per compilare il sorgente e flashare il microcontrollore basterà premere sugli appositi pulsanti messi a disposizione da Piklab.

Conclusioni

In questa guida abbiamo installato i programmi necessari alla programmazione dei microcontrollori PIC, poi abbiamo installato e configurato l'ambiente di sviluppo Piklab. Vi segnalo che sempre sulla guida di punti di (s)vista è presente un capitolo per automatizzare la configurazione dei registri del PIC utilizzando le funzionalità di Piklab.