Archive for the ‘Open Source’ Category

March 30th, 2013
Wishing you an open-source Easter!

github egg

Enough said: let this Easter be a time of openness, freedom and sharing. Of course we’re meaning your family and close ones, but why not apply it to source code as well?

As an Easter present, we bumped the version of Migrant while introducing deserialization with generated methods as well as created a new C# library for manipulating CPIO images, cpiosharp, which has yet to get a fancy github page or README — still, it should be pretty straightforward to use if you just can’t wait.

(the egg is open source, of course, courtesy of colouringbook.org)

Happy Easter, rest well!

March 13th, 2013
Preview of Android for the Enclustra ZX3 Zynq module

It’s been some time since we last wrote about the Zynq, which is not to say that we have stopped to deal with this great technology. It’s interesting to see the process of its adoption and how it brings people from two neighbouring worlds – embedded software and FPGA – together.

Just to whep up your appetite on what we are doing now, a video of Android running on the Enclustra Mars ZX3 module.

The Zynq module running our port of Android was presented at or joint stand with Enclustra at Embedded World 2013 in Nurnberg, and gathered a lot of positive feedback, since the dual-core ARM Processing System of Zynq is more than capable of running the system smoothly, and the Programmable Logic gives a lot of additional possibilities.

Alongside the physical hardware, we also demoed our virtual platform solution, Emul8, running the same Android binary on a PC. We were positively surprised with the interesting conversations and leads this sparked up!

A full account of Embedded World, with all the developments in the industry that might be of interest as well as our impression on where the market is going will follow soon.

As for the Android port, soon we will be publishing it while continuing our work on our GitHub, courtesy of Enclustra.

January 28th, 2013
Booting Mars ZX3 eCos binary from RedBoot over TFTP

tftboot

We’re continuing our series of posts on using eCos and RedBoot on Enclustra’s ZX3 Zynq module – this time with a practical scenario which you might find useful.

It’s a typical case — you’d like to load binaries of eCos apps with RedBoot via TFTP; how to get going on that?

We assume that you have RedBoot running on the board and have an eCos binary ready to roll. If not, see the instructions on our github on how to compile those and use them with the board.

First you have to do is to set up a TFTP server so that you are sure your binary is available from the module. On a Debian Wheezy installation (and probably any other Linux distro) you might use the instructions from Timesys.

With one exception: if you do not have a ‘tftp’ file in ‘/etc/xinetd.d’ siply create one and paste the content from the site into it.

Now you should boot up RedBoot to the prompt. Of course by then it’s nice to have a console window (for example, minicom) with a connection to the board open.

If you had the Ethernet cable attached during boot you’ll probably get IP address via DHCP (if RedBoot is configured to use that, which it is by default) — this was the case in the example from the attached screenshot, where the board received an IP address of 192.168.1.27. You should be able to see the IP information as one of the first messages RedBoot prints to the console.

If a network connection wasn’t configured automatically during startup you should configure it manually with:

1
ip_address -l <xxx.xxx.xxx.xxx> (where xxx.xxx.xxx.xxx is IP address)

for a static IP, or

1
ip_address -d

to get an IP over DHCP (for example, it you forgot to plug in a cable before bootup).

The next step is to set a default server IP address (= where the eCos binary will be downloaded from) with:

1
ip_address -h <xxx.xxx.xxx.xxx>

(where xxx.xxx.xxx.xxx is the server IP address — in our case, 192.168.1.70)

You could use ping to check if the connection is configured properly. To do that use:

1
ping -h <xxx.xxx.xxx.xxx>

(where xxx.xxx.xxx.xxx is the host IP just like above)

Note that in RedBoot the ping program is not what you would normally expect in Linux or Windows — for example it does not show any progress or state messages. You have to wait until it exits, and if you interrupt it, you will see information about how many ICMP packets were received out of the 10 to be sent.

If the connection works properly, you can now download a test application from the TFTP server with:

1
load <name_of_application_binary>

(in our case, this was clock0, a standard eCos clock test).

With the default setting the board should use the TFTP protocol and the server IP set earlier, but if you want to change some parameter see the relevant section of the eCos documentation.

You should now see som information about entry point address ranges of the loaded binary.

To run the app you just loaded simply type:

1
go

And you’re ready! See the attached screen for the result.

January 17th, 2013
eCos port for Enclustra’s ZX3 Zynq module ready

Mars ZX3

Last year we announced the beginning of the work to port eCos to Enclustra’s Mars ZX3 Zynq module.

While most of the work was complete after the summer, the tedious task of cleaning it up, writing appropriate documentation, and testing, testing, testing is always longer than you think.

Zynq is still a very exciting platform which we believe will gain more attention as time goes on, and an RTOS to run on the Processing System will be a good addition to the OSs it can run.

On the attached image you can see the RedBoot bootloader, which is a significant side-effect of the porting effort, loading an eCos test binary over TFTP. We’re excited to see other applications run on the Zynq with time.

tftboot

The port is still undergoing review from Enclustra, but we agreed to open-source it now so that we can benefit from feedback from the community. Already after the port was first announced, we’ve had some very valuable comments, especially as to the usage scenarios, planned projects, hopes and fears associated with the Zynq.

Internally we have been testing and using the port successfully for quite a while, and it is definitely ready for evaluation purposes. It would also be quite interesting to see some benchmarking.

The code is available on our github – head there to check it out, use it in your new application and give us feedback, especially on the documentation and use scenarios.

October 26th, 2012
750K is OK for a crowdsourced parallel platform, but why not a million bucks?

This is a great day for the open source, open hardware and open funding community – it seems that the Parallella project by Adapteva that we wrote about earlier this month will reach its $750K mark, which was not so sure just several days ago.

I just bought myself this $99 massively multicore parallel computing platform as – by sheer coincidence – it’s my birthday tomorrow, which is when the campaign ends.

And I thought – OK, this is exciting, but would it not be better if they managed to raise a million dollars instead? I am certain Andreas and his team will do a wonderful job irrespective of how much exactly they manage to raise, but imagine the news! “A crowdsourced parallel computing platform gets $1M” – that would make my (birth)day.

Several weeks ago, at Embedded Conference Scandinavia which brought so many interesting developments for us that we did not even have the time to blog about it, I just happened to miss Andreas’ presentation about Epiphany, their impressive CPU. When I learned about this, I was quite furious – a collaboratively funded CPU was just what we at Ant Micro had been discussing several days earlier, an inspiring idea that someone would come up with sooner or later. Turns out it was even sooner than we had thought!

Well, I might have missed out on a cool presentation then, but let’s not miss out on this wonderful opportunity. Parallella is not just some crowdsourced project, it is an attempt to get several thousand parallel development kits out to people. Adapteva are doing a wonderful thing – telling the community that it’s their job to find the parallel computing paradigms of tomorrow.

So, without further ado – see the pitch, buy the boards – they’re worth it. Especially that the Epiphany computing clusters fit into Zynq-based devboards, and Zynq is another cool technology we’re also working with:

October 16th, 2012
OpenRISC Conference Stockholm 2012

The great thing about open source communities is that hundreds of people around the globe can collaborate on fascinating software and hardware projects without ever meeting one another.

An even better thing about such communities is that they can also meet up and discuss their shared fascinations!

Last weekend a part of the openRISC community (including us) did just that, at a fantastic meetup hosted by our main partner – Realtime Embedded – in their office at Sveavägen in central Stockholm. The three of us attended as relative newcomers to the openRISC bunch, some of whom have been out and about for many years now, but I think we managed to arouse much interest with our presentation of eCos as a new addition to the openRISC ecosystem. We were pleased to hear a number of insightful remarks and requests; as one of the never-too-many actively supported OS’s for the openRISC our eCos port got also quite a few mentions during the other presentations.

We have already started putting the suggested changes into life as time permits us – check Peter’s description how to compile a program in eCos in an (insanely) easy way! (Makefile included.) In the nearest future, watch out for new eCos for openRISC notes.

Unfortunately, as Murphy’s Law would have it, our presentation was not recorded due to a technical glitch – damn you, AAA batteries! – but you will soon find the slides on the project meeting website.

As for the other presentations, all of them were very interesting to listen to but one of them, a status report on the (now functional) dynamic linking support for openRISC LLVM by Stefan Kristiansson – was absolutely brilliant. The best moment was when the boring slides ended, and… check out what came later at the extremely cool demo. (The other videos are easily found in the attached playlist.)

Don’t trust Stefan when he says “I don’t know about this stuff for real” :)

The meetup was also a very good forum to talk about our priorities, open source processes in general and other related interesting developments – including Parallella from Adapteva, which we are very excited about. For those of you who don’t know the project, it’s an attempt to raise $750000 (or more) by giving away development platforms (called Parallella) for an already complete 16-64 core (called Epiphany) to as many people as possible for as little as $99. We love the idea, since the guys at Adapteva have from the beginning been very open about their history, process and willingness to actually get people to find the proper applications for the hardware, not the other way around!

See the short pitch I prompted for Parallella at the openRISC meeting, by Jeremy Bennett from Embecosm:

And buy one yourself to get parallel computing out into the open!

July 20th, 2012
Running RedBoot on Enclustra’s ZX3 Zynq module

For the past few weeks we have been busy porting eCos to Encustra’s Zynq module, with a partial sponsorship from the Swiss company. The initial version of the port is ready, eCos passes most tests and it is possible to run RedBoot – the eCos bootloader – on the board.

With the ability to directly download and boot ELF files, RedBoot is definitely an interesting alternative to U-Boot, typically used to boot Linux for the Zynq. RedBoot is also a handy tool when it comes to debugging the application code. RedBoot can be loaded automatically by Xilinx’s first stage bootloader, using the boot header mechanism.
RedBoot on the ZX3 Zynq module
Currently, our version of RedBoot has limited functionality, but it will evolve as we go on to provide a complete set of drivers and some interesting functionalities that we will show in upcoming posts.

ITR GmbH has donated some of the basic platform code for Zynq, which was valuable help.

June 20th, 2012
Ant Micro porting eCos to Enclustra’s Zynq module – Mars ZX3

The connection between the two worlds of embedded and FPGA is becoming more and more apparent – all the more so with solutions such as Xilinx Zynq, which combines a general-purpose dual-core ARM with programmable logic allowing for dedicated processing in a single chip.

As a company active in both fields, we were quite eager to lay our hands on Zynq chips, to get the feel of the module and how it works in practice.

Following our visit to X-Fest in Oslo we were talking with Enclustra, the Swiss FPGA company and producer of FPGA modules to give us an early sample so that we can be one of the first few companies able to work with physical Zynq chips. They agreed to partially sponsor the port of the eCos real-time operating system for the module, and so, here it is:

The module is excellent, just as well made as the previous board we got from Enclustra, coming in the popular (and small!) SO-DIMM format. It allows you to integrate Zynq into your design quickly, with much less effort than to design from scratch.

The port is scheduled for release early Q4 2012. Go to Enclustra’s website for updates, other operating systems as well as to subscribe for the Beta program and get the boards for yourself. If you already decided to use Zynq or are leaning towards it, we can help you with integrating it into your own designs and products.

Follow our blog if you want to learn of our progress and let us know if you want to use eCos on the Zynq. A note on running RedBoot on the ZX3 module as an alternative to U-Boot will follow soon, so as always – stay tuned (and enjoy the summer)!

June 14th, 2012
U-Boot for Colibri Tegra 2 pushed to github

In our post from over a year ago we published some patches to U-Boot which allowed us to use it with the Colibri Tegra 2 module from Toradex, the first widely available embedded SoM featuring an Nvidia CPU.

A long time has passed since then, and – as you can probably see if you follow the blog – we have been busy with lots of other things in the meantime. But as we have noticed that the the code lives on and has been put to good use, we thought it a good idea to include it on our github for more convenience and a clearer picture – the original manner of publishing of the code was the result of the haste which always accompanies work with hot technologies.

Our github fork of U-Boot shows how the necessary patches are applied in the proper order and might be helpful for people exploring how bootloaders are ported between different ARM modules and boards.

It is worth noting that those changes were performed before we got any CPU datasheets from Nvidia, using virtual platform tools that we are developing. This was a great example of a scenario where the appropriate tools really made a difference!

If you are interested in open source and new embedded technologies, follow us throughout the summer (the easiest way to do is through our twitter) – there will be a lot going on. One of the more interesting technologies we are already working with is Xilinx Zynq, be sure to come back soon for updates about that and other really interesting topics.

June 11th, 2012
Migrant – open source serialization library

It happens to everyone: you start using a library, find it lacking some features, start fixing it, committing opatches, and then end up rewriting it because the whole premise it based on does not suit your needs.

So it happened with us and serialization in C#, for which we originally used protobuf-net which employs the protocol buffer serialization format by Google.

Serialization is a tricky problem, especially when performance matters for your application. If you go for feature completeness, you compromise speed, but too much focus on speed makes you unable to serialize more complex objects.

We did, however, see room for improvement in both, so we set out to wirte our own library; thus Migrant was born. For now, it is hosted on our github account, but will get a dedicated page when time permits.

A few notes about the library: though it originally used reflection, we decided to abandon it in favour of a more efficient method (though we provide the option to switch between the two). Serializing with the new method is now complete, while deserializing still needs some work.

As far as speed is concerned, preliminary benchmarks are very promising. Care is taken to test the framework thoroughly (also across the two (de)serialization methods) so that things don’t get messed up as the library develops.

A recent feature is the possibility to serialize C# delegates. We will be aiming to increase the performance of this feature, but it works well as is.

Another feature we think quite interesting that we are aiming to get soon is what we call version-tolerant serialization. It often happens that in developing frameworks and programs classes are changed as time passes, and objects serialized by one version cannot be restored by another due to this incompatibility. There are many scenarions, however, when this should be perfectly possible, e.g. when the number of fields is reduced or the new fields have perfectly acceptable default values. In those situations Migrant will allow you to deserialize such a legacy object, perhaps issuing some warnings that this was done.

 

Copyright © 2009 - 2013 ant micro. All rights reserved. | Design: Duind.com