Saturday, January 14, 2017

Really ancient history

A long, long time ago, roughly around the time of the invention of the wheel, I did a series of lessons on 8-bit PICs. These lessons were very well received, downloaded thousands of times, and although aimed at hobbyists, many professionals also used them as an introduction to microcontrollers.

Craig Johnson made an experimenter's board to help with these lessons, which was originally kitted by the American QRP Club and later by Kanga U.S. Over the years this board underwent a couple of revisions, and is still available from Craig directly.

I have continued to get questions about these lessons, even though it is over a decade, and the target micro, the PIC16F84A, pretty long in the tooth.   Most of the more recent questions have to do with the development environment, which has changed pretty dramatically since MPLAB 6.

I finally broke down and decided to update a couple of the lessons, those that go into great detail about manipulating MPLAB.
Of course, I based them on MPLAB-X, rather than MPLAB 8.  MPLAB-X was pretty rough during the beta testing, but has evolved into quite a nice IDE. Reviewing these old MPLAB documents reminded me of just how much the environment has improved. I also updated the screenshots and some of the prose for Windows 10.  I don't use Windows much myself, but these days most people do, so it seemed to make sense.

The lessons are both available on gitlab in pdf; Lesson 3 which does some initial exploration of MPLAB-X which is available here, and Lesson 4 which explores the MPLAB-X simulator in some detail here.

 The only other lesson that is tempting is Lesson 11.  It goes into a lot of detail about manipulating a program called FPP, which is no longer available. The replacement, tho, hardly seems worth it.  On MPLAB-X with the PIC-EL III it reduces to "click this button".

So perhaps that will reduce the emails in the future.  In any event, it should make things easier for those who are finally getting around to doing Elmer 160.






Wednesday, December 7, 2016

Serial Graphics Terminal

It has been a while since I last posted here, and there have been a number of fun projects under the bridge.

One of the more fun, with more work still planned, is the development of a serial graphics terminal.

Most PIC projects use an LCD for a display. It is cheap and easy, but it has pretty limited real estate, and it uses a bunch of pins.  For quick little test projects, you often spend more time hooking up the LCD than you do on the rest of the project. Serial LCDs are expensive, and don't solve the problem.

More recently there have been some relatively inexpensive TFTs available. Fairly small 320x480 displays have tended to be among the least expensive, but they take even more pins than the LCDs, and quite a bit more code.

Suppose we could connect one of those things up to the serial interface.  That would allow a competent display with only one or two pins.  If we put a lot of smarts into the terminal, the performance might be decent, and we might even end up with a small software footprint on the host project.

Unfortunately, there are relatively few PICs available in 40 pin DIP, and those that are tend to be pretty slow or have limited memory.  I wanted a fast PIC with gobs of memory in a DIP package that I could prototype easily.

By using the MCP23S17 I/O expander, I could get enough I/O to handle a TFT, and selected the PIC32MX250F128B.  Turns out that the PIC32MX150F128B is the same for this purpose, and cheaper, but at the time I could get the 250 quicker.

So I breadboarded up the thing, mounted on my breadboard dsPIC-EL as a test host, and the thing worked.



I developed first text terminal code, then graphics terminal code, and decided that a custom PCB would be worthwhile.


The serial performance, even though limited by the I/O expanders, is quite good.  I developed a graphics library for the PIC32 that the terminal code builds on. The board is capable of the things you would hope such a terminal would do.


One of the things that is a real pain is drawing decent graphs.  All the piddling around in getting the axes and legends straight is a major hassle, so I decided to put a graphing feature into the PIC32 so that a small host application could draw decent graphs.




The TFT library makes it tempting to do projects directly on the TFT board. Unfortunately, there are only a few pins left (which are brought out to a connector), but a simple logic analyzer was irresistible:




Although the performance is quite good, and for most things, even with a serial connection, speed is not an issue, there is one place where the performance falls down, and it is a common one: drawing a continuously varying graph like a strip chart recorder.

A strange thing about this particular TFT controller is that it takes as many commands (and as much time) to fill a rectangle as it does to draw a pixel. When drawing lines at odd angles, like a graph, each pixel must be drawn individually. In this case, the MCP23S17, even though SPI is running at 10 MHz, simply can't keep up.

A large buffer in the PIC32 mitigates this problem for finite lines, if you want to continuously monitor a variable at some point you overflow the buffer.  Even with a huge buffer, at some point it fills.  I have done some experimenting with XON/XOFF, but this requires more complex code in the host.


The next step will be to prototype something with the PIC32MZ1024EFH100 (the 100 pin part is necessary to get all the pins in a single register). If the prototype can substantially improve performance, then I will look at a PCB for that part.

Again, I have no plans in marketing this, but everything needed is in GitLab. PCBs can be cheaply made and all parts, except the TFT, are available from DigiKey. The TFT is a SainSmart 20-011-918.

Project Components (all gitlab projects except document):

The following is a little video to give an idea of the performance of the serial terminal:




Saturday, March 19, 2016

Getting started with MPLAB-X

 A long, long time ago I switched to MPLAB-X from MPLAB 8.  Since at the time MPLAB-X was in beta, the transition was not all that smooth.  Since then, MPLAB-X has gotten more stable, I've gotten accustomed to it, and the feature set has expanded.  Now it is way better than the old MPLAB ever hoped to be.

An even longer time ago I wrote a series of lessons on programming the PIC16F in assembler language using MPLAB 6 (yeah, that long ago).  Craig Johnson, AA0ZZ, produced a board to go with the lessons, and that board, and its descendants, continue to live on through a Yahoo group.

I never updated the course for the newer PICs or the newer IDE, but occasionally questions come up on that group which prompted me to make a series of screenshots using MPLAB-X.  I considered (for about a millisecond) updating the lesson on MPLAB but got over it.

But here I will provide a little prose for those wanting to get off the ground in MPLAB-X.  I should mention that this assumes you want to do 8-bit assembly programming, not because I think that is a good thing in this day and age, but more because I think that is the audience.  These days I am much more of a fan of the 16 and 32 bit parts in C.  The 8-bit C compilers (and they are legion) are all pretty weak  (see my SDCC post), and I am a fan of C.  But for the 8-bit parts, I still think assembler is the way to go.

When launching MPLAB-X, the opening screen is kind of busy.

Start page, first time

This shows the 'Start Page', a tab (lots of tabs in MPLAB-X) showing some Microchip marketing stuff (actually, some of it quite useful), but most importantly, your recent projects.  If you are launching MPLAB-X for the first time, of course there are no recent projects.

Recent Projects List

In the screen shot this is the first time MPLAB-X is opened, so there are no previous projects.

Clicking the new project icon (the yellow-ish folder icon on the left) launches the new project wizard.

New Project Wizard

The first panel of the wizard is a little confusing at first. What you want is 'Microchip Embedded' on the left and 'Standalone Project' on the right.  The other choices are useful, but not at first.

Clicking Next leads you to a panel to select the processor.


Processor Selection

You may choose a family and then a processor from the drop down menus, but there are a lot of PICs in each family.  it is easier to simply highlight the Device field and type in the name, or part of the name to narrow the search.

The next panel allows you to specify your programmer.


Programming Tool Selection

That is pretty simple business.  The next panel lets you select the toolchain.


Toolchain Selection

The default installation provides the Hi-Tech compiler and MPASM.  To do 16 or 32 bit work you will need to install additional compilers.  They will then show up here.  When you update compilers, previous versions will continue to be shown until you uninstall the older version.

Finally, you get to name your project.


Project Name

The first time, Microchip defaults to an MPLABXProjects folder.  This is a perfectly good place, but if you would prefer your projects somewhere else, click Browse and navigate to your favorite place.  The directory defaults to the last location you used, so there is no penalty for disagreeing with Microchip.

When you click Finish, your project will be created, however it will have no source files.

Creating new file

Right-clicking Source files on the left will bring up a context menu that allows you to specify whether you want to create a new file or add a file you have previously created.  Rolling over New will launch a sub-menu allowing you to specify the type of file you wish to create.

Additional File types

Should you choose Other, you get a dialog giving you additional choices.


New File Name

Clicking Next will allow you to finally give the new file a name.  MPLAB-X will provide the extension appropriate to the file.

If you are following the Elmer 160 lessons, the early lessons use absolute code, but MPASM defaults to relocatable code.  To specify absolute:

Project Properties Button
first click the Project Properties button alongside the Dashboard.  Then highlight mpasm (Global Options) and tick the Build in absolute mode check box.  Click Apply then OK.

mpasmx Options Selection

Double-clicking the file name in the left pane will open the file in the right pane.  You may now edit the file.  If the file has not been saved, its name in the tab will be bold.  For most files, the source code will be highlighted in color.  


Editing the code

When you think you are ready to build, clicking on the Build Main Project button (the hammer) will assemble and link your project.

Build Main Project Button

You will see all sorts of messages fly by in the lower right pane.  What is important is that at the end of those messages,  you see BUILD SUCCESSFUL in green.

Build Success

During the build there may be a lot of messages produced.  If you see the green BUILD SUCCESSFUL you can ignore them.  But if there was an error, you will get a red BUILD FAILED message.  In this case you need to scroll that window up and find the first message that isn't black.  Sometimes this can be quite a way up, but when something fails it can often cause other things to fail.  It is important to find the first message, because if you try to fix the later messages first, you may end up breaking more things.  Be sure to find the first message and fix that.  Then review the later messages and see whether they still make sense.

Build error

Once you have a successful build, you can program your target project by clicking the Make and Program Device button (with the green downward pointing arrow).

Make and Program Device Button

Normally this will go fairly quickly, but depending on what you have done (or not done) previously, it can take a while.  The first time you program a particular family, MPLAB has to download code into the programmer.  This can be pretty slow.  If you haven't changed device families, it will go quite quickly when you program the same device again.  Programming some PIC32 devices with a PICkit can also be quite slow.  If you are working with these devices you might consider an ICD instead which is significantly faster.  Ditto with very large programs.

Programming Success

Once again, a number of messages will go flashing by in the lower right pane.  When you see Programming/Verify complete your project will be ready to test on the target hardware.  And again, if you see red, there is a problem.

Programming Failure

I have an old YouTube showing this process.  In spite of all the steps it can be quite quick.  The video is for a dsPIC on a much older version of MPLAB, but the steps are all the same, even if the screens look a little different.

WARNING: There are lots and lots of tabs in MPLAB-X, and almost every tab can be dragged almost anywhere within the window.  If you happen to drag a tab off the window it will become un-docked and separate from the main window.  You can re-dock it from a menu on the small window.  Should it land on the window border, it will be hidden and marked with a tiny icon on that border.  It can be opened from that icon.

Right-click is your friend.

There are a lot of features in MPLAB-X.  Later posts will explain some of these features.


Friday, March 18, 2016

MPLAB Xpress

Recently Microchip introduced MPLAB Xpress.  This is basically MPLAB-X in your web browser.  It looks for all the world like MPLAB-X except you don't need to install anything on your PC.  Just point your browser to the IDE and have at it.

MPLAB Xpress in Internet Explorer

At the current time it looks as if it only supports 8-bit PICs.  Kind of a pity because, IMO, the 8 bit C compiler is trash.  The 16 and 32 bit compilers are ports of gcc, the benchmark for C compilers.  But still, if you like the 8-bit stuff, it is pretty neat.  You can do MPASM in MPLAB Xpress although getting started isn't real obvious.

If you want to use your PICkit online, you do need to install a bit of software.  There is a USB bridge to connect your PICkit to the online IDE.

If you don't have your PICkit connected, the hex file can be downloaded.   Otherwise, you can keep your entire project "in the cloud".  Actually, kinda handy if you want to do development on a tablet or across a number of devices.

To push this model, Microchip offered a free evaluation board.  It is supposed to be available on MicrochipDirect soon, but I couldn't find it today.  The target price was supposed to be quite low, too.


MPLAB Xpress Evaluation Board

This is a way cool little board.  It has a microUSB connector, and when you connect it to your PC it presents itself as a USB drive.  To program the PIC, simply drag the hex file to the USB drive.

The board has a PIC16F18855, a pot, a button, and a few LEDs.  All the pins are brought out to the edge of the board although not all the connectors are populated.  There are a number of demo programs available on the Xpress IDE.

The PIC16F18855 is a pretty impressive little part, even more impressive when you check the Digikey price.

The part includes:
  • 8K words of program memory
  • 1K bytes of SRAM (pretty fat for a 16F)
  • 256 bytes EEPROM
  • 24 channel A/D
  • A DAC
  • A CRC generator
  • 3 waveform generators
  • A numerically controlled oscillator
  • 4 configurable logic cells
  • A data signal modulator
  • Peripheral Pin Select (a huge win, IMO)
  • And of course timers, comparators, PWM, I2C, SPI all the normal stuff
The evaluation board contains the 28 pin PIC in a tiny (4x4mm) UQFN package.  Curiously, the PIC18LF25K50 used for programming is in a larger QFN (6x6mm) package.  The PIC is available in a 28 pin SPDIP and its bigger brother in a 40 pin PDIP if you want to move your development to a more hobbyist-friendly environment.

Digikey currently shows the SPDIP version for under two bucks, and the 40 pin PIC16F18875 for $2.04.  Pretty impressive for all those peripherals.

All in all, a pretty cool way for someone to get started in PIC development without installing anything.


Monday, March 7, 2016

More on the dsPIC-EL

OK, so a few months down the road we can give a progress report on the dsPIC-EL and the high school club.

Solderless Breadboard
First of all, the members of the high school Electronics and Wireless Communications Club are wicked smart.  These kids are just unbelievable.  Before building the dsPIC-EL boards we gave them a handful of parts, a solderless breadboard, a schematic, and asked them to make the LED blink.  Your standard first PIC project, but the guidance they got was very limited.  All of the students had little problem accomplishing the task (for that one we used the PIC24FV16KM202 because at the time we didn't have enough of an inventory of dsPICs for all the club members.)

We felt it was useful to start with a "from scratch" sort of build so the club members understood that they don't need to buy an Arduino or some prepared kit to do something interesting.  They are prefectly capable of doing whatever they want.

After they had the LED blinking we gave them a few more LEDs and resistors and told them to play.  Interesting results, and I think it is useful for them to go off with little guidance and explore on their own.
dsPIC-EL-GM

They then built the dsPIC-EL.  The provided dsPIC33EV32GM002 contained an acceptance test so they could see right away that they were successful. (Refer to the construction instructions link on the previous post.) A provided library for the LCD allowed the club members to experiment with the buttons and LEDs and display what they were doing.
Shield with DS1821 annotated

Next up was to add sensing. The ultimate goal is to do a high altitude balloon launch in the spring.  This balloon is to carry a payload containing sensors for those measurements of interest to the club members.  A shield was built for the dsPIC-EL containing a DS1821 digital thermostat.  Again, a library was provided to ease the handling of the Dallas One Wire protocol.

LDR voltage divider
For sensing, analog input will be a must, so next the students added a light dependent resistor to their shield and learned how to read voltage.

The final, sort of "directed" experiment was to add a serial EEPROM to the shield.  In the spring launch, this will be needed to store the measurements for analysis after the payload is recovered.
24FC128 SEEPROM

The club members then split into small teams of two or three members.  One team was responsible for the control processor, one for the storage processor, and the remainder for each sensor module.  The plan is for each sensor to take commands from the control processor, report the measurement, and then have the storage processor store the result.  K8VFO guided the teams in preparing functional specifications and then designs for each of the modules.  Students did Internet research to select sensors and are currently working on firmware for each module.

Initial testing and development is being done on the dsPIC-EL, but the launch payload will use a dsPIC-EL for the control processor, and purpose-built shields for the measurement modules.

K8VFO is also walking the club members through the process of converting their schematics to a PCB layout, sending the design out to manufacture, and testing the resulting board.

Of course, some of our stronger club members will be graduating about the time we do the launch.  We hope the remaining members will return in the fall when we plan to build on this year's progress and address telemetry from the balloon to an earth station.

As I said, these kids are wicked smart.

Tuesday, October 20, 2015

A working dsPIC-EL

After deciding a long time ago that I wouldn't do a dsPIC-EL, nor an Elmer 166, I decided to do a dsPIC-EL, but the Elmer 166 is only kind of.

When I broke down and did the club thermometer project (http://elmer166.blogspot.com/2015/08/club-project-thermometer.html) I realized how straightforward a PCB can be.  OK, I am clumsy at it and it takes a few cycles, but the result is very satisfying.

The PIC24FV16KM202 used in the thermometer, and it's sister the PIC24FV32KA302 were something of a revalation.  The peripheral complement is absolutely breathtaking, and the peripheral pin select allows for a lot more flexibility than the dsPIC30F family.

I ran into to project where I wanted a little more speed, and tripped across the dsPIC33EV256GM102.  Astonishing!  70 MIPS, gobs of memory, PPS like the 24FV, and the family of dsPIC33EVxxGMyzz lets you select memory size, pin count, and network from a family of otherwise identical parts.

I started working on a dsPIC-EL board based on this part, and realized that the pinout was virtually identical to the PIC24FV series.  I could choose between dsPIC33EVxxGMx02, PIC24FV16KM202, and PIC24FVxxKAy02 parts by the simple addition of a jumper.



dsPIC-EL

From the work on the dsPIC30F board I recognized that Arduino-style header connectors were a worthwhile addition.  With the thermometer project I had also recognized that I could get proto boards custom made for less money and higher quality than I could buy already made. It was a short step to realizing that if I bought the long pin headers used by Arduino shields in quantity, I could have shields for under three bucks.

dsPIC-EL with proto shield fitted


Somewhere around this time I got roped into working with the high school electronics club.  The students early on expressed a strong interest in building stuff they could program.  This, of course, pushed me into moving along much quicker on the dsPIC-EL, and I can pretty much call it soup now.

Of course, I want to share this development, so all the work is on GitLab, but I have no interest in kitting the thing.  The good news is that the boards can be had quite cheaply, and there are really no hard parts (although some parts are a lot cheaper in quantity).  If all the parts were purchased in quantity one, I suspect it could be had for around the cost of a PIC-EL.  Buying things like connectors in quantity cuts the cost to less than half.  The main disadvantage to some of the large quantity parts is lead time.

The dsPIC33EV256GM102 is kind of pricey, but the 32K version without the CAN (which is unlikely to be needed) can be had for less than the price of a PIC24FV, which itself makes 16F and 18F parts look expensive.

So, the main features:
  • PIC with pins brought out to Arduino connectors for easy prototyping
  • Extra connector to allow ordinary perfboard to be used as a shield
  • LCD and buttons on the base board.  You always want these, and they have the annoying feature of needing to be on the "top" shield which really limits flexibility if they are on a shield.
  • All used pins jumpered so they can be used for prototyping without interference from on-board parts
  • A few LEDs thrown in for good measure
  • Power from a cell phone charger with an XH connector for batteries or some other external supply
  • PICkit connector for programming
  • Jumper to allow PIC24FV to be used

Schematic


I don't plan to do another Elmer 160 type class, but I will be guiding the high school club's members through learning the dsPIC, and I will be putting my materials on GitLab, so they will be available to anyone who is interested.  Rather than PDF prose, most will be PowerPoint (well, actually LibreOffice).  Of course, high school kids pick up things a lot quicker than us old hams, so the material will be quite a bit different.

The key repositories are:

The PCB including Gerbers.  The README for this repository includes the schematic and a red/blue image of the board.  The BOM in this repository also contains information on sources.
https://gitlab.com/33E-simple/dsPIC-EL-GM

The ProtoShield gerbers
https://gitlab.com/33E-simple/ProtoShield

An LCD library
https://gitlab.com/33EV-GM1/LCD.X

An I2C library
https://gitlab.com/33EV-GM1/I2C.X

Presentations (under development)
https://gitlab.com/33EV-GM1/dsPIC-presentations

Construction instructions (under development)
https://gitlab.com/E-WCC/dsPIC-EL_Build_Instructions

If you want to get boards made, simply upload the zip file containing the Gerbers to
http://makerstudio.cc/index.php?main_page=product_info&cPath=8&products_id=14
The price is around $16 for 10 boards including shipping.  Shipping seems to vary a bit, I assume based on exchange rates.  It takes about three weeks for the boards to reach the U.S.  I have also used Accutrace in cases where I want boards a little sooner (8 days).  Their price of $40 for 10 is quite a bit higher than MakerStudio, but not crazy, and their customer service is tops.  Their boards are a little higher quality than the Chinese boards, but you need to look really close to tell the difference.

Saturday, August 8, 2015

Club Project - Thermometer

Recently the local radio club needed something to spice things up, and the idea of a construction project based on a PIC seemed to be well received.  I came up with the idea of a PIC based thermometer, a little off the beaten path perhaps, but easily done.




An awful lot of PIC projects involve nothing more than an LCD and a sensor of some type.  Everyone has done some sort of test instrument; counters, capacitance meters, dip meters, signal generators, and on and on.  But a lot of the club members don't do a lot of building, and while a counter is kind of cool, it only appeals to the more technical members.

A thermometer, on the other hand, is something that everyone can get behind.  Perhaps you won't play with it for very long, but you will play with it.  You will hold the temperature sensor and watch it warm up, you might put it in the freezer, perhaps it will find a permanent home in the greenhouse.  But it is something everyone can at least play with, if only briefly.

I also wanted to try to inspire folks to pick up a soldering iron and perhaps grok a little code long after the build session.  A thermometer based on the Maxxim/Dallas DS1821 is dead simple, and as a totally digital solution requires no calibration, and the adventuresome could easily stick the sensor on the end of a long wire to put it in the garage, or in the garden, or wherever.

For similar reasons I chose the PIC24FV16KM202.  It has a lot of left over pins to tempt people to try other stuff, it has an amazing complement of peripherals to play with, and it is dirt cheap.

We milked the project for several months. First, I did a presentation on PICs in general, went on about how easy they are to use, how cheap, and how flexible they can be.  The next month another ham did a presentation on microprocessors in general, and the differences between microprocessors and microcontrollers.  Then I did presentations on the hardware and software for our build project.  Finally, on a Saturday, we all got together and melted solder.

We also did the project at the local high school radio club.  That was a lot shorter.  Kids of that age are like sponges when it comes to knowledge, and they were no virgins to electronics, so the whole process was a lot quicker!

We did a total of around 30 of these thermometers, only one didn't work when first powered up, and that was a cold solder joint dealt with in just a few minutes.  Not bad for a group that mostly had never held a soldering iron before.  I credit part of that to the very detailed construction instructions (see link below).

We have had some success with folks going out playing on their own.  Not as much as I would like to see, but something is better than nothing.

I had the boards made at Maker Studio.  They will make boards up to 10x10cm for a fixed price.  I filled the unused part of the board with prototyping area in an attempt to get people to try things.

The Circuit


 



Basically, the circuit is nothing more than a PIC, an LCD, and the temperature sensor.  In order to make it simple to get going in the build session, the project was powered by 3 AA batteries.  Because of this, the LCD backlight was not used, although the board provided a jumper to enable it, and a micro-USB connector to enable powering the project from a cell phone charger.  An LED was also provided to indicate the program was working, but also to provide experimenters with something else to play with.


In addition to the PIC, LCD and temperature sensor, the LCD requires a contrast pot, the LED a current limiting resistor, and the DS1821 a pull up resistor.  A reset button was added, along with a few caps.  The PIC24FV16KM202 requires a 10u cap because it is basically a 3 volt PIC running at 5 volts, and it is always good to sprinkle a bypass cap here and there.

The odd values on the resistors are simply because I had bought thousands of those values cheap, and they are in places where the actual value is horribly non-critical.

The PCB

The initial plan was to build the project on perfboard.  That way folks could get the idea that they could simply build whatever they wanted.  But eventually it was decided to do a printed circuit board.  Perfboards are pretty expensive, and if you are willing to wait a few weeks, a PCB can be real cheap.  Plus, it makes it harder for new builders to make errors, especially if the PCB is heavily silk screened.  Later I actually had custom perfboards made,  Turns out that one can get very high quality glass-epoxy boards exactly to your own specifications cheaper than crummy phenolic boards locally.



Of course, the PCB had to include a programming connector (left edge).  As mentioned before, a connector for a cell charger (right) and a simple, two-pin connector for the batteries which are mounted on the back.  The PIC's internal oscillator was used for the project, but pads for a crystal and the associated caps were provided in case the experimenter felt a need for crystal control.  The remainder of the board is filled with prototyping space.

The Software

The PIC is run at a low speed to maximize battery life, and mostly sleeps.  The watchdog timer wakes the PIC about once a minute to take a sample and then go back to sleep.  The PIC only draws microamps when sleeping, although much of that advantage is swamped by the LCD which draws significant current even without the backlight.

The LCD and DS1821 code was buried in libraries to make it easier to talk about the overall logic without getting buried in the details of the specific devices.



The Links

Other clubs might find this a useful project.  All of the source code, schematics, PCB layouts, Gerbers, presentations and the construction manual are all available on GitLab.

The presentations are in OpenOffice Impress format, although the repositories also contain a PDF version.  The construction manual was developed using Publican, but the final result is PDF.  The schematics and PCB were developed using the gEDA tools gschem and pcb.  The source is all MPLAB-X/xc16 code.