So, how exactly this works?

Zeeduino-XC is, in essence, a cleaned up, organized and layered Wiring/Arduino code.

Entire code is divided into 3 distinct parts:

  • Zeeduino implementation of Wiring/Arduino functions and core classes
  • Controller specific code
  • An abstraction layer (Board API and mappers) which connects those two

The whole thing goes like this:

  1. First you pick the best controller in the world. Ever. Period.
  2. Then you implement Board API functions and mapper structures.
  3. Compile and run Arduino/Wiring code on your controller (and on whatever board it is soldered to)
  4. Use hundreds of Arduino/Wiring libraries in your projects

Step 4 is optional. You can write all those libraries yourself if you hate helping yourself with other people's work they offer you for free.

I wrote all those libraries from scratch just because I can. You shouldn't do that. I love when people help me with their work, and I love doing the same for others. Thus, Zeeduino-XC.

Here is a simple diagram to show a basic concept of Zeeduino-XC:

 

Standard Wiring/Arduino source code

 

Zeeduino-XC concept

 

Ok, where's the catch?

I dunno. Take a look at this a bit more detailed list of steps you need to do to port Wiring/Arduino to your controller, and to then take the advantage of all those libraries:

  • First you pick the best controller in the world. Ever. Period.
  • Then you make sure you know how to program in C for that controller.
  • Also make sure you have development tools used for development on that controller.
  • It helps, a lot!, if there's a some sort of support code library for the controller.
  • Now you sit down and start typing really fast and precise on your keyboard.
  • With this fast typing, you aim to implement Board API functions so they work on your controller.
  • You then adapt mapper structures to support your controller's pins and pin features, and the board the controller is on (you've got the board, right?)
  • compile and run your first Wiring/Arduino program on your controller (and the board)

Oh, right, there's the catch! 😋

Now, that may seem like a bit more work than I promised, but it is not. Compared to what you have to do if you start porting from scratch, this is a piece of cake. It is even faster and easier if you have an example of how it's been done already, which you can use as a reference point.

You can download (or clone the git repo) Zeeduino-XC source and Zeeduino-XC for lpc13xx port. And you should. Then take a look at how lpc13xx port is implemented and repeat the same thing. It's not that hard. Honestly.

Go on and get it.

It's Zeeduino-XC.

It's a wider and bigger playground.