Posts Tagged ‘debugging’

Embedded Systems Conference 2016 Schedule – April 13-14

January 29th, 2016 No comments

The Embedded Systems Conference 2016 will take place in Boston on April 13-14, and the organizers have now released the schedule, minus some keynotes, which features four main tracks: Embedded Hardware, Embedded Software, Connected Devices and the Internet of Things (IoT), and the ESC Engineering Theatre.


As usual, I’ve gone through the list of talks and composed my own little virtual schedule which ended up with sessions focusing on power management, IoT, and security, as well some optimization and drivers development talks among others, such as patents, and the origin of Gerber files.

Wednesday 13

  • 8:00 – 9:00 – Power Management in Embedded Systems by Colin Walls, Embedded Software Technologist, Mentor Graphics

The importance of power management in today’s embedded designs has been steadily growing as an increasing number of battery powered devices are developed. In this session, we will discuss design considerations that should be made when starting a new power sensitive embedded design, which include:

  • Choosing the hardware with desired capabilities
  • Defining a hardware architecture that will allow software to dynamically control power consumption
  • Defining appropriate power usage profiles
  • Making the appropriate choice of an operating system and drivers
  • Choosing measurable power goals and providing these goals to the software development team to track throughout the development process.
  • 9:00 – 9:45 – Creating an IoT Device in Only 45 Minutes by Jacob Beningo,  Consultant, Beningo Engineering

Developing an IoT system seems extremely complex. Security, remote updating, sensor interfacing and battery life are just a few issues facing developers of connected systems. This session will reorient the embedded system engineer and expose them to an IoT platform known as the Electric Imp. We’ll walk through the design and implementation of an IoT device in 45 minutes. Attendees will gain a paradigm shift in thinking about how to design systems and be introduced to how embedded systems will be designed in the coming decade.

  • 10:00 – 10:45 – Embedded Software Optimization: Architecture, Design, & Implementation by Rob Oshana, Director of SW, Freescale

This session discusses a set of techniques used in practice to optimize embedded applications for performance, memory, and power. A set of performance optimization techniques will be examined, starting with the proper mapping of software algorithm to hardware architecture, along with algorithmic transformation, C-level optimization techniques such partial summation and multi-sampling, loop unrolling and software pipelining. Practical memory optimization techniques such as data structure use and alignment, as well as power optimization techniques such as dynamic voltage frequency scaling, cache optimization and a “top ten” list of other techniques, will be discussed. This session will also cover common “optimization blockers” and how to eliminate them.

  • 11:00 – 11:45 – Considerations for Security in Embedded Systems by Ahmed Refaey Hussein, Sr. Systems Architect, Mircom Group of Companies, and Khaled Loukhaoukha, Sr. Research Officer, Centre de Recherche Développement, Bouchaoui

Security has become a crucial consideration and is one of the most important design goals for an embedded system. In this session, we will introduce security in embedded systems, and provide two current approaches to security countermeasure for memory corruption and attacks. The two techniques are dynamic information flow tracking (DIFT) and same technique with secure page allocation (PIFT).

  • 14:00 – 14:45 – Code Analysis Made Easy by Rafael Taubinger,  Senior Field Applications Engineer, IAR Systems

The widely used C/C++ languages are known for their flexibility and proximity to hardware. However, these languages also feature a huge number of undefined behaviors and their flexibility lets you write code that may not work the way you intended; your code could be syntactically correct but nuances of the language may force the code to operate in unexpected ways. In the best case, these mistakes are detected during the development cycle, but they could easily escape into the field and necessitate a product recall. Fortunately, static- and runtime-code analysis can be integrated seamlessly into your workflow. This session will demonstrate how they can be used to detect potential errors in your application so errors can be eliminated as early and cheaply as possible.

  • 15:00 – 15:45 – Real-Time Software Using Micro Python by Jacob Beningo, Consultant, Beningo Engineering

Python has become a very popular scripting language and has been deployed on many production systems in addition across multiple application domains. Micro Python is a lean and efficient Python 3 port designed to run on an ARM Cortex-M microcontroller. This session will explore real-time embedded software concepts as they relate to Micro Python.

Attendees can expect to learn key concepts in areas, such as: Python, Python vs C, Real-time Programming, Object Oriented Design, Rapid Prototyping, Controlling MCU Peripherals from Micro Python, Exception and Error Handling, and Real-Time Scheduler Concepts and Design.

  • 16:00 – 16:45 – Marketing Malarkey and the Truth About Ultra-Low Power Design by Jack Ganssle,  Consultant, TGG

Vendors are waging battles about their low-power microprocessors that can run on a coin cell for years. Some of what they claim is somewhat disingenuous; other claims are irrelevant. This session covers real-world data on what sort of battery life can be expected (based on millions of data points the author has gathered experimentally), what mitigation strategies are appropriate, what low sleep currents really mean, and other sources of leakages that will drain the cells long before the MCU does. The session specifically focuses on coin cell applications.

Thursday 14

  • 8:00 – 8:45 – All About Patents by Bob Zeidman, President, Zeidman Technologies

This course explains all about patents including how they are written, what they protect, why you need them, and how to utilize them. It begins with a description of different kinds of intellectual property. It then explains how hardware and software companies, startup companies, and individuals can use patents to their advantage to protect their intellectual property. Finally, the course relates actual legal cases where patents have been asserted or defended, including personal experiences of the instructor as an expert witness on some of the largest cases of the last and current millennium.

  • 9:00 – 9:45 – Understanding the IoT Platform Wars: Technical Trade Offs by Michael Anderson, Chief Scientist, The PTR Group, Inc.

As the Internet of Things (IoT) starts to gather momentum, a number of competing IoT platforms are jockeying for dominance. Offerings from the Thread Group (Google/Nest), Allseen Alliance (Qualcomm), Apple’s Homekit, the Open Interconnect Consortium (Intel) and many others are joining the fray. But, in this confusing array of platforms, what are the main features of each and why should you care? This session will provide an overview of these platforms, their capabilities, and barriers to entry as the industry prepares for a fight to determine the future of the 50 billion devices planned for the IoT.

  • 10:00 – 10:45 – HAL Design for MCUs by Jacob Beningo, Consultant, Beningo Engineering

The speed at which a developer is expected to write software often results in device drivers that are difficult to understand, hard to maintain, and difficult to port. This session describes methods and techniques that can be used to develop a re-usable hardware abstraction layer (HAL) that is easy to maintain and use across multiple projects and platforms. It will also examine key properties of a HAL and provide examples for common MCU peripherals.

  • 11:00 – 11:45 – Cryptography Basics for Embedded Developers by Eystein Stenberg, Product Manager,

Many vulnerabilities and breaches happen due to incorrect use of cryptographic mechanisms like encryption. This session will cover the basic mechanisms of cryptography, like encryption, signatures, and key storage, looking at how these are used to create important security properties like authentication, confidentiality, and integrity.

Performance is particularly important for embedded development, and this session will cover which cryptographic operations are computationally expensive and why. It will highlight implementations of cryptographic mechanisms that help meet the performance needs of embedded devices, including Elliptic Curve Cryptography. Common pitfalls, libraries, and tools relevant for secure use of cryptography for embedded devices will also be addressed.

  • 14:00 – 14:45 – The Incredible Story Behind the Gerber PCB File Format by David Gerber,  Writer & Editor, Independent

The story behind the “Gerber PCB File Format” begins with H. Joseph Gerber, after whom the format was named. Gerber was a refugee who would receive the U.S. National Medal of Technology, in 1994, for his “technical leadership in the invention, development, and commercialization of manufacturing automation systems for a wide variety of industries.”

Born Heinz Joseph Gerber in Vienna, Austria, he used his inventiveness as a boy to help his family survive Nazi rule. Arriving penniless in America in 1940 with his mother, he completed a high school curriculum in just two years and college in another two, graduating with a Bachelor of Science degree in aeronautical engineering. After turning his pajamas into his first product — a “revolutionary” engineering device (now in the Smithsonian National Museum of American History) — he began his career by driving around the country to visit customer sites, selling his products by day and inventing new ones by night. Finding problems that customers did not realized they had, as opposed to simply improving existing processes, his method was to invent completely new systems of design and manufacture.

Gerber and his company refined this method in industry after industry, not only inventing new products, but also creating the supporting industrial infrastructure, often from scratch, without existing standards, compatibilities, and modularization. It is this dynamic, growing from the state of technology, the requirements of industry transformation, and the method of a remarkable inventor, that underlies the evolution of the so-called “Gerber language” in the fabrication of circuit boards.

  • 15:00 – 15:45 – Applying Lessons Learned in Space FPGA Development Here on the Earth by Adam Taylor, Eur Ing, E2V

Taking the hard learned lessons from space FPGA and VHDL development and demonstrating how these can be used on the terrestrial applications to obtain a better resultant and quality for your system. This session looks at the engineering life cycle, architectures, coding structures, pitfalls around clocks and reset and mitigation techniques. While focusing upon the FPGA and VHDL structures there is also information presented on the impacts of the environment, training and development and the entire supporting facility needed for the developing a great FPGA solution on time, quality and cost.

There are two types of pass to attend the event: the conference pass and the expo pass. The latter includes access to all expo floors, four of them, and vendor sponsored training sessions, while the former adds tutorials, conference sessions, and lunch.

(Ends Tuesday, December 22, 2015)
$799 FREE
(Ends Friday, February 5, 2016)
$949 FREE
(Ends Friday, April 8, 2016)
$1,149 FREE

The expo pass is free as long as you book in advance, and the conference pass costs between $949 to $1,299 depending on how early you book your pass. Students, teachers and government officials save up to 25%, and if your company sends several people, the price drops up to 30%.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

DragonBoard 410c Development Board Quick Start Guide and Android Benchmarks

November 21st, 2015 3 comments

Linaro’s 96Boards initiative was announced in February with the introduction of Hikey board, and while progress has been rather slow, there are now two boards available for sale: Lemaker Hikey and Qualcomm Dragonboard 410c. The main advantage of these board is that 96Boards is not only an hardware specification, but also a software specifications that mandate most code to be open source, with recent versions of Linux and U-boot, and in the case of Dragonboard 410c work is being done with Freedreno open source GPU drivers.

Now that I’ve got a board I’ll explain my experience with the purchasing process, take a few pictures, and show how to get started with Android, and install the latest version, before running a few benchmarks.

Ordering DragonBoard 410c Development Board

I normally don’t like purchasing from North American and European distributors, because of the potential documentation involved to comply with silly laws, high shipping fees, which are themselves compounded by import taxes at home and the courier’s handling fees, meaning a $75 board could easily ending costing $150… So I did not intend to buy the board at first, and just went to the Arrow’s Dragonboard 410c page to find out how much shipping would be…

The board ships from the United Stated, but to my surprise shipping was free via Fedex Economy.

DragonBoard_410c_ShippingSo I just went ahead, the checkout process was rather straightforward, and paid by Paypal on Wednesday, November 12, with an estimated delivery date of November 18. Not too bad.

Two days later, I received an email asked me to complete an FCC Purchaser’s Certification form, because while the board had passed the company’s internal EMC tests, it had not passed FCC certification yet, so I could only use it as an evaluation platform. EMC certifications is expected by the end of the month. So I filled it up and simply sent it back by email.

The following Wednesday my order was confirmed, and I received the board yesterday (November 20). So it took about a week between my order and shipping, so I’m pretty satisfied how it all went considering the board is sent for free.

I did not pay any import duties, but Fedex did request for 7% VAT, amounting to about $6.

DragonBoard 410c Pictures

I got the board in a box warning about static electricity.

Dragonboard_410c_PackageI’ve seen pictures of the board before with Green and Red PCB, but mine ended up being Cyan, although the overall design did not really change since the first prototypes.

Click to Enlarge

Click to Enlarge

Click to Enlarge

Click to Enlarge


The main difference with the previous photos is that they added shields on top of the power circuitry, as well as on Qualcomm Snapdragon 410c and memory chips.

Click to Enlarge

Click to Enlarge

I’ve also take a picture with a few “friends” including Raspberry Pi 2, Orange Pi 2 mini, and Roseapple Pi boards. with DragonBoard 410c being slightly smaller.

Getting Started with DragonBoard 410c Development Board (in Android)

Linaro released the first Reference Software Platform for 96Boards a couple of weeks ago, and while Hikey supported both Android and Debian 8.2, ony the latter was released for DragonBoard 410c, so I was expecting the board to come pre-loaded with Debian Linux distribution, but instead it came with Android 5.1. That’s why I’m going to focus on Android in this first post, before checking out Linux in more details.

Since the board comes pre-loaded with an operating systems it should be easy to start with the platform, right? Sort of, but there are still some mini challenges to overcome.

First, the board takes 6.5 to 18V power supply as per 96Boards specifications, and the power barrel has a 1.7mm diameter instead of the more usual 2.1mm. That means all these 5V power supply I’ve accumulated can’t be used, so I had to find a 12V power supply, as well as some adapters to be able to connect it to the board. Luckily, I have a few 12V/1A power adapter from some TV boxes, and I have a 28 power jack adapters set to handle this case. If you don’t have any of those, you could also check out 96Boards power supply page with some recommendations.

12V/1A Power Adapter, and 2.1 to 1.7mm Adapter (Click to Enlarge)

12V/1A Power Adapter, and 2.1 to 1.7mm Adapter (Click to Enlarge)

Once I got this sorted out, I also connected a USB keyboard, and RF dongle for my air mouse, an HDMI cable to my TV, and an Ethernet… wait.. There’s no Ethernet port on 96Boards, so that’s it. As I connected the power, and LED quickly blink once, and then nothing for several (long) seconds, until I saw the Qualcomm boot animation, and later the lock screen.

Click for Original Size

Click for Original Size

These are the few apps pre-installed in the Android image.

Click for Original Size

Click for Original Size

And a look at “About phone” section shows MSM8916 for arm64 is running Android 5.1.1 on top of Linux 3.10.49. So I don’t think that image fully complies with 96Boards software specifications, and hopefully the Android release part of the Reference Software Platform will fix that.

Click for Original Size

Click for Original Size

I could connect to WiFi with issues, and transfer the screenshots via Bluetooth, since Android would not recognize my USB flash drive. Later on I found out micro SD cards work fine.

If you intend to modify the bootloader or kernel, you’ll most probably want to connect a USB to TLL board to the development platform. Unfortunately, while most development boards on the market are perfectly happy with a 3.3V or 5V power debug board, DragonBoard 410c board requires a 1.8V USB to TTL board which needs to inconveniently be connected to pins 1, 11 and 13 on the 40-pin low speed (LS) header.  I could remember that Hardkernel USB-UART board supports both 1.8 and 3.3V, and I got one thanks to the several ODROID board I was given to play with.

Click to Enlarge

Click to Enlarge

I fired up minicom in my Ubuntu computer, made sure it was set to 115200 8N1, but whatever I did I could not get any debug message on the serial console, even after switching Tx and Rx a few times… I tried to download Snapdragon 410 GPIO Pin Assignment from the Wiki, but the file in question had a “redirect loop”… So I gave up on that part for now.

Installing the latest Android Image

Eventually Linaro is going to update the firmware images and release the source regularly, so you’ll probably want to install the latest the latest build of the Android image, and I followed the instructions on 96Boards github wiki in an Ubuntu computer, which uses fastboot, and there’s also another method using a micro SD card.

Fastboot update

You’ll need fastboot utility to flash the firmware over USB. This command and all other below are typed from your Linux computer (Ubuntu/Debian):

Now download and extract the latest bootloader

Dragonboard_410c_fastboot_switchNow make sure S6 switch on the board is set to 0-0-0-0 as shown in the right photo, and that there’s no micro SD card inserted in the board.

Now keep pressing S4 button (Volume -), while inserting the power jack into the board, and after a few releas the button. You should be in fastboot mode. Let’s check it:

All good. Now flash all files with a single command

The output will start with:

It should take a few seconds to complete. If you forget to add sudo, the following message will show forever:

Now you’ll want to download the latest Android firmware files in your computer:

Once this is done, unzip and flash the files to the board:

Now unplug the power, and the micro USB cable, and put the power jack back into the board. Android should boot, but in my case it did not, and my power meter was stuck at 1 to 1.5 Watts instead of 2.0 to 3.0 Watts during a normal boot.

SD Card Update

So I fell back to the second update method, using a micro SD card. I’ve used a terminal windows in Ubuntu in the instructions below, but you could also use a Windows computer, and Win32DiskImager utility to perform the same tasks over a graphical user interface.

First download and extract the SD card image:

Now insert your SD card into your computer, and check your device with lsblk:

In my case, the micro SD card is 32GB, so my device is sdb. You need to replace <sd_device> with your own device in the command to dump the data to the SD card.

DragonBoard_410c_SD_Card_BootYou can now remove the micro SD card from your computer and insert it into the board.

Set the S6 switch to 0110 (boot from SD-card ,USB Host mode) as shown on the right.

Now power on the board, LED 1 will blink regularly, and after a while NOOBS should show up on your monitor or TV, asking you to choose the operating system to install.

DragonBoard_410c_NOOBS_AndroidAbout_Phone_Android_Qualcomm_Snapdragon_410Click install, and complete the process. Once it asks your to remove the SD card. Disconnect the power, remove the micro SD card, set S6 back to 0000, re-connect the power, and be very patient for the first boot. I propose you make some tea and coffee, drink it, go to relieve yourself, and come back later where Android will have hopefully booted.

My Linux kernel is now a little newer, but still dated in August. So they have not released any Android firmware for a few months. This should change for the December Software Reference Platform release.

If you want to go further with Android on the board, I recommend you read the Android User Guide (PDF),  and visit DragonBoard 410C documentation page on

DragonBoard 410c Android Benchmarks

I’ve also side-loaded a few benchmarks to find out more about the board performance. But first let’s see what CPU-Z reports.

Click to Enlarge

Click to Enlarge

Qualcomm Snapdragon 400/410 is properly recognized with a quad core Cortex A53 processor clocked between 200 and 1.21 GHz and an Adreno 306 GPU @ up to 400 MHz. The governor is set to interactive, so it may slightly negatively impact the benchmarks below. The system has indeed 1GB RAM, with 4.84GB internal storage available to the user out of the 8GB eMMC flash.

Click to Enlarge

Click to Enlarge

After installing Antutu 5.7.1, it asked me whether I wanted to update to the 64-bit version for better performance. It’s the first time it happened in all my testing despite reviewing and benchmarking other 64-bit ARM systems before. The board scores 18,211 points in Antutu, quite lower as I expected compared to Amlogic S905 (quad core @ 2.0 Ghz -> ~28,000 points) and Rockchip RK3368 (octa-core @ 1.2 GHz -> ~34,000 points) processors also Cortex A53 cores.

Several smartphones have launched with Snapdragon 410 processors, so in theory it should be easy to find benchmark for comparison, but most of these phones come with a lower resolution 1280×720 display, and run Android 4.4. I still found Elephone Trunk with Snaprdragon 410, Android 5.1, and a 1280×780 scoring 21,500 points, so the score in DragonBoard 410c  appears more or less as expected.

Qualcomm_Snapdragon_410_VellamoVellamo 3.x should not run with Firefox at all, and only partially with Webview, so ignore the Browser scores. The board got 1,114 points in the multicore benchmark, or 786 points in the metal benchmark, which compares to respectively 1,572 and 763 with Amlogic S905 benchmark results.


Qualcomm DragonBoard 410c achieved 2,304 points in 3DMark Ice Storm Extreme compared to around 4,200 to 4,300 points in both Rockchip RK3368 and Amlogic S905 devices at the same 1920×1080 resolution.


As you can see from this initial review, 96Boards project is still very much work in progress on the software side, and I had wished some more common decision were made with regards to the specs (e.g. power supply, serial voltage, Ethernet…),  but at least the DragonBoard 410c platform should be interesting over time for people who want recent versions of U-boot, Linux and Android / Debian firmware, and source code, as well as an open source GPU drivers (Freedreno).

The next step should be to run Debian 8.2, but since the firmware is at the alpha stage with some issues like no HDMI audio, I may decide to take my time, and wait for the December release.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

How to Use an ESP8266 Board as a WiFi to Serial Debug Board

October 21st, 2015 7 comments

Telnet and SSH are great to access a Linux device, machine and computer remotely when they are already running, but when you are working on the bootloader and/or kernel themselves, you’ll have to use a serial port to access the terminal / serial console. Boards used to get an RS232 port which you connected to your computer with a NULL modem cable, but these days, most boards and devices expose TTL signals and require a USB to TTL debug board to access the console via a USB cable. If you only have one device close to you computer that’s fine, but if your testbed is a little further. or you need to access the serial console on multiple boards you could consider using ESP8266 module to export the terminal over WiFi.

ESP8266_Wifi_to_Serial_Debug_BoardThis is exactly what Zoobab did above with a GL.inet router running OpenWRT and NodeMCU board with ESP-12(E) module based on Espressif ESP8266 WiSoC. The wireless module is powered by a mico USB cable, and its GND, TX, and RX pins are connected to the corresponding router’s pins. Both works at 3.3V so no voltage conversion is needed, but with some other hardware it may be necessary to convert 5V to 3.3V.

The next step is to flash NodeMCU with ESP-LINK firmware, which connects an attached MCU to the Internet using an ESP8266 Wifi module. Now you can access the router terminal via ESP8266 board web interface.

Click to Enlarge

Click to Enlarge

That’s great with a little, or maybe not so little, caveat: it’s read-only. So if you want to input text in the serial console, you’ll currently have to telnet to your ESP8266 board to access the router’s serial console.

esp8266_telnet_serial_consoleThe implementation is still work in progress, as more complete documentation must be written, more features are planned (web console input, https console, etc…), and a few bugs still persist such as Ctrl+C not working with telnet. To work around the latter you can use Putty or socat, which can also allows to upload files over the serial link using Serio Python script.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Beyond Debug Key Enables JTAG & UART Debugging, Supports OpenOCD

November 3rd, 2014 1 comment

Beyond Semiconductor, a fabless semiconductor company based in Slovenia which develops their own 32-bit BA2x IP cores, has sent me one of their development tool, namely Beyond Debug Key supporting JTAG and UART interfaces either with BeyondStudio for the company’s BA2x processor, or the open source suite OpenOCD for other processors. Since I don’t have any Beyond Semi boards, I instead configured it, and quickly tried it with Atmel SAMA5D3 Xplained ARM Cortex A5 development board, and OpenOCD (Open On-Chip Debugger).

Beyong_JTAG_Debug_Key_PackageThe debug tool comes in the package above describing the key features of the kit:

  • Performance
    • Transfer rate in excess of 600 kB/s
    • 30 MHz maximum JTAG clock
    • Less than 20 μW power draw from target board
  • Compatibility
    • Fully compatible with Beyond BA2x processor family
    • Access any 8-bit, 16-bit, 32-bit or 64-bit processors via JTAG
    • Works with all JTAG compliant devices
  • Software Support
    • OpenOCD for access to a range of CPLD, FPGA, flash and processor devices
    • BeyondStudio for graphical debugging of Beyond BA2x processors
  • Diagnostics – 7 autonomous status LEDs for power and flow control diagnostics
  • Target Debugging Integrated in BeyondStudio
    • Eclipse-based integrated development environment
    • Simplified and straightforward setup of target connection in just few clicks
    • Modern source-level debugger with hardware breakpoint, watchpoint and single step features
    • Integrated target console
  • Interfaces
    • USB 2.0 Hi-speed 480Mbps connection to PC
    • IEEE 1149.1 and IEEE 1149.7 JTAG interface standard pinout
    • RS232/RS422/RS485 UART Transfer Data Rate up to 12Mbaud
    • Simultaneous JTAG and UART operation
    • IO voltage range from 1.2 V to 3.3 V and including 5V CMOS compliant signaling
    • Independently controlled SRST and TRST signals
    • One Wire Debug (OWD) and Two Wire Debug (TWD) protocols support

The kit include the Debug Key, a mini USB to cable, and a user’s manual describing the kit, explaining how to configured it with Windows and Linux computers, and listing the seven LED behaviours to diagonalize the connection. The tool uses a 20-pin JTAG connector, so as I did not want to wire JTAG signals manually, I went through my boards trying to find one with 20-pin JTAG receptacle, and I ended-up connecting it to Atmel SAMA5D3 Xpained development board as shown below.

Beyond Debug Key Connected to Atmel SAMA5D3 Xplained Board (Click to Enlarge)

JTAG can be used for board bring-up and flashing firmware, so I initially thought I would show how to configure the debug tool, and flash a firmware image to the board, but since Atmel SAMA5D3 configuration are not available, and it was my first time with OpenOCD, it took a little longer than usual, and I’ll just show the configuration part, and successful (I think) connection to the board.

The Debug key support both Windows and Linux, but I did everything from a computer running Ubuntu 14.04 LTS. The first thing is to install OpenOCD which is part of Ubuntu repo:

So it’s very easy to install, but OpenOCD version in Ubuntu is 0.7.0, and depending on the board you are using, you may want to build latest release (0.8.0), or directly from the source code tree:

OpenOCD requires config scrips both the JTAG key, and the target board. Beyond Semi provided the configuration files for their Debug Key, so that part was easy, and all I had to do was to create beyond.cfg with:

You also need to create a udev rules to be able to access the JTAG debugger as a normal user. so I created 52-beyong-jtag.rules in /etc/udev/rules.d/ with the line:

SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6010", ATTRS{product}=="Debug Key", MODE:="0666"

At this stage, if you run OpenOCD with beyond.cfg only, you get the following output:

At this stage, I had to find or create the script for Atmel SAMA5D3 CPU, and you’ve got a list of scripts in /usr/share/openocd/scripts/ which can help. There’s also site claiming to support Atmel SAMA5D3 with OpenOCD, but checking out the code asked me for a password. So instead I read Atmel SAMA5D3 datasheet (Chip Identification section), where I found relevant information such as SRAM start address, and Cortex-A5 JTAG IDCODE (0x4BA00477). The SRAM address is exactly the same as SAM9G45 processor which has a config files in OpenOCD, namely at91sam9g45.cfg which also includes at91sam9.cfg, so I simply copied both files to create my own at91sama5d3.cfg,  by simply replacing set _CPUTAPID 0x0792603f by “set _CPUTAPID 0x4ba00477”.

Here’s the output if I use both the Debug Key and SAMA5 scripts:

So despite one error, the connection appears to be successful, and both TDO and TDO LEDs blinked on the debug key, which means both JTAG Tx and Rx were active. That’s all I have achieve so far with the amount of time I had.

If you are interested in getting such JTAG Debugger, you can purchase Beyond Debug Key for 90 Euros directly from Beyond Semiconductor.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Linaro 14.08 Release with Kernel 3.16 and Android 4.4.4

September 2nd, 2014 No comments

I’m a little late for that one, as Linaro 14.08 was released last Thursday. Nevertheless, this release features Linux kernel 3.16 (baseline), Linux 3.10.52 (LSK), and Android 4.4.4.

As usual Linaro has worked on member hardware such as Qualcomm based IFC6410 and ARM Juno &Vexpress boards. They’ve also committed changes for LLVM, big Endian, and added a workload generator tool (rt-app) to the Ubuntu and Android image. This tool has been developed and used by the power management working group, presumably to measure and optimize power consumption under various loads.

Here are the highlights of this release:

  • Linux Linaro 3.16-2014.08
    • GATOR version 5.19 (new version)
    • updated topic from Qualcomm LT (ifc6410 board support)
    • updated Versatile Express ARM64 support (FVP Base and Foundation models, Juno) from ARM LT (Landing Team)
    • updated Versatile Express patches from ARM LT
    • updated LLVM topic (follows the community llvmlinux-latest branch)
    • Big endian support (the 2014.05 topic version rebased to 3.16 kernel)
    • config fragments changes: CONFIG_DEBUG_INFO=y added to linaro-base.conf. This is needed to get the debug package containing vmlinux to be built, and vmlinux is required to run perf.
  • Linaro Toolchain Binaries 2014.08 – Based on GCC 4.9, and updated to latest Linaro TCWG releases:
    • Linaro GCC 4.9-2014.08
    • Linaro EGLIBC 2.19-2014.08
    • Linaro binutils 2.24-2014.08
    • Linaro GDB 7.8-2014.08
  • Linaro Android 14.08 – Built with Linaro GCC 4.9-2014.08
  • Linaro OpenEmbedded 2014.08
    • integrated Linaro GCC 4.9-2014.08, Linaro EGLIBC 2.19-2014.08, Linaro binutils 2.24-2014.08, and Linaro GDB 7.8-2014.08
    • added rt-app (contributed from Power Management WG)
    • updated GATOR to 5.19,  LSK kernels, and QEMU to 2.1.0
    • fixed boot wrapper build
    • upstreaming:
      • fixed kexec-tools
      • fixed udev startup script to fix mysql launch failure
      • updated PM QA to 0.4.12
      • fixed PHP build
      • fixed hugetlbfs
  • Linaro Ubuntu 14.08
    • added rt-app
    • updated packages: GATOR 5.19, LSK 3.10.52/3.14.16 and linux-linaro 3.16 kernels.
  • KVM ARMv8 Continuous Integration and Testing is completed
  • Make debug symbols available for Versatile Express ALIP image

You can visit for a list of known issues, and further release details about the LEB, LMB (Linaro Member Builds), and community builds, as well as Android, Kernel, Graphics, Multimedia, Landing Team, Platform, Power management and Toolchain components.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

ARM TechCon 2014 Schedule – 64-Bit, IoT, Optimization & Debugging, Security and More

July 23rd, 2014 No comments

ARM Technology Conference (TechCon) 2014 will take place on October 1 – 3, 2014, in Santa Clara, and as every year, there will be a conference with various sessions for suitable engineers and managers, as well as an exposition where companies showcase their latest ARM based products and solutions. The detailed schedule for the conference has just been made available. Last year,  there were 90 sessions organized into 15 tracks, but this year, despite received 300 applications,  the organizers decided to scale it down a bit, and there will be 75 session in the following 11 tracks:ARM_TechCon_2014

  • Chip Implementation
  • Debugging
  • Graphics
  • Heterogeneous Compute
  • New Frontiers
  • Power Efficiency
  • Safety and Security
  • Software Development and Optimization
  • Software Optimization for Infrastructure and Cloud
  • System Design
  • Verification

There are also some paid workshops that take all day with topics such as “Android (NDK) and ARM overview”, “ARM and the Internet of Things”, or “ARM Accredited Engineer Programs”.

As usual, I’ve gone through the schedule builder, and come up with some interesting sessions with my virtual schedule during the 3-day event:

Wednesday – 1st of October

In this session, Dr. Saied Tehrani will discuss how Spansion’s approach to utilize the ARM Cortex-R line of processors to deliver energy efficient solutions for the automotive MCU market has led the company to become a vital part of the movement toward connectivity in cars. Beginning with an overview of the auto industry’s innovation and growth in connected car features, he will explain how these systems require high performance processing to give drivers the fluid experience they expect. Highlights in security and reliability with ARM Cortex-R, including Spansion’s Traveo Family of MCU’s will also be presented.

HEVC and VP9 are the latest video compression standards that significantly improves compression ratio compared to its widely used predecessors H.264 and VP8 standard. In this session the following will be discussed:

  • The market need for GPU accelerated HEVC and VP9 decoders
  • Challenges involved in offloading video decoding algorithms to a GPU, and how Mali GPU is well suited to tackle them
  • Improvement in power consumption and performance of Mali GPU accelerated decoder
  • big.LITTLE architecture and CCI/CCN’s complementing roles in improving the GPU accelerated video decoder’s power consumption

ARM’s Cortex-M family of embedded processors are delivering energy-efficient, highly responsive solutions in a wide variety of application areas right from the lowest-power, general-purpose microcontrollers to specialised devices in advanced SoC designs. This talk will examine how ARM plans to grow the ARM Cortex-M processor family to provide high performance together with flexible memory systems, whilst still maintaining the low-power, low-latency characteristics of ARM’s architecture v7M.

IoT devices as embedded systems cover a large range of devices from low-power, low-performance sensors to high-end gateways. This presentation will highlight the elements an embedded engineer needs to analyse before selecting the MCU for his design. Software is fundamental in IoT: from networking to power management, from vertical market protocols to IoT Cloud protocols and services, from programming languages to remote firmware update, these are all design criteria influencing an IoT device design. Several challenges specific to IoT design will be addressed:

  • Code size and RAM requirements for the major networking stacks
  • Optimizing TCP/IP resources versus performance
  • Using Java from Oracle or from other vendors versus C
  • WiFi (radio only or integrated module)
  • Bluetooth (Classis versus LE) IoT protocols

Thursday – 2nd of October

Amongst ARM’s IP portfolio we have CPUs, GPUs, video engines and display processors, together with fabric interconnect and POP IP, all co-designed, co-verified and co-optimized to produce energy-efficient implementations. In this talk, we will present some of the innovations ARM has introduced to reduce memory bandwidth and system power, both in the IP blocks themselves and the interactions between them, and how this strategy now extends to the new ARM Mali display processors.

Designing a system that has to run on coin cells? There’s little accurate information available about how these batteries behave in systems that spend most of their time sleeping. This class will give design guidance on the batteries, plus examine the many other places power leakages occur, and offer some mitigation strategies.

64-bit is the “new black” across the electronics industry, from server to mobile devices. So if you are building or considering building an ARMv8-A SoC, you shall attend this talk to either check that you know everything or find out what you shall know! Using the ARMv8 Juno ARM Development Platform (ADP) as reference, this session will cover:

  • The ARMv8-A hardware compute subsystem architecture for Cortex-A57, Cortex-A53 & Mali based SoC
  • The associated ARMv8-A software stack
  • The resources available to 64-bit software developers
  • Demonstration of the Android Open Source Project for ARMv8 running on Juno.

Rapid prototyping platforms have become a standard path to develop initial design concepts. They provide an easy-to-use interface with a minimal learning curve and allow ideas to flourish and quickly become reality. Transitioning from a simple, easy-to-use rapid prototyping system can be daunting, but shouldn’t be. This session presents options for starting with mbed as a prototyping environment and moving to full production with the use of development hardware, the open-source mbed SDK and HDK, and the rich ARM ecosystem of hardware and software tools.Attendees will learn how to move from the mbed online prototyping environment to full production software, including:

  • Exporting from mbed to a professional IDE
  • Full run-time control with debugging capabilities
  • Leveraging an expanded SDK with a wider range of integration points
  • Portability of applications from an mbed-enabled HDK to your custom hardware

Statistics is often perceived as scary and dull… but not when you apply it to optimizing your code! You can learn so much about your system and your application by using relatively simple techniques that there’s no excuse not to know them.This presentation will use no slides but will step through a fun and engaging demo of progressively optimizing OpenCL applications on a ARM-powered Chromebook using IPython. Highlights will include analyzing performance counters using radar diagrams, reducing performance variability by optimizing for caches and predicting which program transformations will make a real difference before actually implementing them.

Friday – 3rd of October

The proliferation of mobile devices has led to the need of squeezing every last micro-amp-hour out of batteries. Minimizing the energy profile of a micro-controller is not always straight forward. A combination of sleep modes, peripheral control and other techniques can be used to maximize battery life. In this session, strategies for optimizing micro-controller energy profiles will be examined which will extend battery life while maintaining the integrity of the system. The techniques will be demonstrated on an ARM Cortex-M processor, and include a combination of power modes, software architecture design techniques and various tips and tricks that reduce the energy profile.

One of the obstacles to IoT market growth is guaranteeing interoperability between devices and services . Today, most solutions address applications requirements for specific verticals in isolation from others. Overcoming this shortcoming requires adoption of open standards for data communication, security and device management. Economics, scalability and usability demand a platform that can be used across multiple applications and verticals. This talk covers some of the key standards like constrained application protocol (CoAP), OMA Lightweight M2M and 6LoWPAN. The key features of these standards like Caching Proxy, Eventing, Grouping, Security and Web Resource Model for creating efficient, secure, and open standards based IoT systems will also be discussed.

Virtual Prototypes are gaining widespread acceptance as a strategy for developing and debugging software removing the dependence on the availability of hardware. In this session we will explore how a virtual prototype can be used productively for software debug. We will explain the interfaces that exist for debugging and tracing activity in the virtual prototype, how these are used to attach debug and analysis tools and how these differ from (and improve upon) equivalent hardware capabilities. We will look in depth at strategies for debug and trace and how to leverage the advantages that the virtual environment offers. The presentation will further explore how the virtual prototype connects to hardware simulators to provide cross-domain (hardware and software) debug. The techniques will be illustrated through case studies garnered from experiences working with partners on projects over the last few years.

Attendees will learn:

  • How to set up a Virtual Prototype for debug and trace
  • Connecting debuggers and other analysis tools.
  • Strategies for productive debug of software in a virtual prototype.
  • How to setup trace on a virtual platform, and analysing the results.
  • Hardware in the loop: cross domain debug.
  • Use of Python to control the simulation and trace interfaces for a virtual platform.
  • 14:30 – 15:20 – GPGPU on ARM Systems by Michael Anderson, Chief Scientist, The PTR Group, Inc.

ARM platforms are increasingly coupled with high-performance Graphics Processor Units (GPUs). However the GPU can do more than just render graphics, Today’s GPUs are highly-integrated multi-core processors in their own right and are capable of much more than updating the display. In this session, we will discuss the rationale for harnessing GPUs as compute engines and their implementations. We’ll examine Nvidia’s CUDA, OpenCL and RenderScript as a means to incorporate high-performance computing into low power draw platforms. This session will include some demonstrations of various applications that can leverage the general-purpose GPU compute approach.

Abstract currently not available.

That’s 14 sessions out of the 75 available, and you can make your own schedule depending on your interests with the schedule builder.

In order to attend ARM TechCon 2014, you can register online, although you could always show up and pay the regular on-site, but it will cost you, or your company, extra.

Super Early Bird Rare
Ended June 27
Early Bird Rate
Ends August 8
Advanced Rate
Ends September 19
Regular Rate
VIP $999 $1,299 $1,499 $1,699
All-Access $799 $999 $1,199 $1,399
General Admission $699 $899 $1,099 $1,299
AAE Training $249 $299 $349 $399
Software Developers Workshop $99 $149 $199 $249
Expo FREE FREE $29 $59

There are more types of pass this year, but the 2-day and 1-day pass have gone out of the window. The expo pass used to be free at any time, but this year, you need to register before August 8. VIP and All-access provides access to all events, General Admission excludes AAE workshops and software developer workshops, AAE Training and Software Developers Workshop passes give access to the expo plus specific workshops. Further discounts are available for groups, up to 30% discount.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Element14 Design Center Helps You find a Development Board and Tools for Your Project

June 27th, 2014 No comments

Element14 has just launched a Design Center, currently in beta version, which let’s you do parametric searches for development kits, debuggers, software tools, by tools vendor, silicon manufacturers, board features, and processor architecture / type. So for example if you want to work on a low power Linux based gateway with Ethernet and Zigbee, you may search for a board with Ethernet and Zigbee, and comes with an ARM Cortex A5 processor.

Element14 Design Center - Zigbee / Ethernet / ARM Cortex A5 Search

Element14 Design Center – Zigbee / Ethernet / ARM Cortex A5 Search

In this example, the website returned four SAMA5D3x evaluation kits from Atmel which support Ethernet, as well as Zigbee via an external module. Then if you want to find which tools are available from Atmel, you can select “Emulation and Debugging”, “IDE & Compiler”, and “Operating Systems & Stacks”, as well as “Atmel” and “ARM” core architecture which will return Atmel Studio 6, and a JTAG emulator. It’s not quite perfect, as the only features you can search for right now are: 802.15.4, Bluetooth, Ethernet, HDMI, LCD, RJ-45, RS232, USB and Zigbee. It won’t let you search for things like memory and storage capacity, the presence and minimum number of interfaces such as GPIO, SPI, I2C, CAN,  etc…, as is often seen for parametric searches for MCUs. I’m not quite sure the parametric search has to be that fine for development boards though, but more options would certainly be welcomed. Nevertheless, Element14 Design Center may be a starting point to find the development board you need for a given application.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Embedded Linux Conference 2014 Schedule

April 19th, 2014 1 comment

The Tenth Embedded Linux Conference (ELC 2014) will take place on April 29 – May 1, 2014 at the San Jose Marriott in San Jose, California. The event will feature 90+ sessions on embedded Linux, Android and IoT with over 450 attendees expected to attend. It will also be co-located with Android Builders Summit and the AllSeen Alliance Hackfest. Even if you can’t attend it’s still interesting to see what will be discussed at the event to get a grasp of on-going developments, learn a few things about different optimization techniques, and so on. So I’ve gone through the sessions’ description, and I’ve designed my own virtual schedule with sessions that could be of interest.

Embedded_Linux_Conference_2014April 29

Linux has taken the embedded world by storm.  Billions (with a ‘B’) of devices have now shipped with a Linux kernel, and it seems unstoppable.  But will the next 10 billion devices ship with Linux or with something else?  How can Linux be specialized for deeply embedded projects, as characterized by the Internet of Things, while still maintaining the network effects of community cooperation and sharing?  Is this possible or even desirable?  The startling truth might be revealed at this keynote. Or, Tim might just rant a bit about device-tree… who knows?

The past year has seen a remarkable growth of interest in super-low-power and super-low-form-factor computing, in the form of ‘wearables’, the ‘Internet of Things’, and the release of exciting new hardware such as Intel’s Quark and Edison SoCs. Taking advantage of this super-small hardware also implies the need for super-small operating systems and applications to match. This talk will describe a super-small-footprint Linux distribution called ‘microYocto”. The main focus will be the kernel and how we achieved what we think is close to the minimal possible kernel footprint, both in terms of static text size and dynamic memory usage. We’ll talk about the tools and methodologies we used and developed to analyze the problem, such as tracing and machine simulation, and will describe the various technologies developed and applied to achieving this minimalistic system.

Many community resources exist about boot time reduction. However, few of them are up to date and share the exact time savings that can be achieved on recent systems. This talk will detail today’s most efficient techniques to reduce boot time. For each of them, figures will be shared, obtained from recent boot time reduction projects and from the preparation of Free Electrons new workshop on this topic. If you attend this talk, you will know which optimization techniques are worth using first, and will save time not exploring techniques that won’t make a significant difference in your project. Don’t tell your boss, and this will leave your more time to contribute to community projects!

In this talk, Chris will describe the internal workings of the Android graphics stack from the Application layer down through the stack to pixels on the screen. It is a fairly complex journey, taking in two different 2D rendering engines, applications calling OpenGL ES directory, passing buffers on to the system compositor, Surface Flinger, and then down to the display controller or frame buffer. All this requires careful synchronisation so that what appears on the screen is smooth, without jitter, and makes efficient use of memory, CPU, GPU and power resources.

Linux-based platforms such as the Beaglebone and Raspberry Pi are inexpensive powerhouses. But, beyond being cool on their own, what else can you do with them? This presentation will step you through the process of building a Wi-Fi enabled, Linux-based robot that you can build without breaking the bank and without special knowledge of robotics and robotic controls.

Since last year, we have been working on supporting the SoCs from Allwinner, a Chinese SoC vendor, in the mainline kernel. These SoCs are cheap, wide-spread, backed by a strong community and, until last year, only supported by an out-of-tree kernel. Through this talk, we would like to share the status of this effort: where we were a year ago, what solutions were in place, where we are currently, and what to expect from the future. We will also focus on the community around these SoCs, the work that is done there, etc.

April 30

GCC is an optimizing compiler, currently most common compiler to build software for Embedded Linux systems like Android, Yocto Project etc. This tutorial will introduce specific optimizations and features of GCC which are less known but could benefit optimizing software especially for embedded use while highlight the effect of common optimizations. While it will focus on squeezing most out of GCC, it will also cover some of “pessimizations” to avoid and will tip the developer to write code thats more conducive (compiler friendly) for general optimizations. They will also get some contrast with other compilers when needed.

Throughout the last two years, a team of engineers at Free Electrons has been involved in mainlining the support for several ARM processors from Marvell, converting the not-so-great vendor-specific BSP into mainline quality code progressively merged upstream. This effort of several hundreds working days, has led to the integration of hundreds of patches in the kernel. Through this talk we would like to share some lessons learned regarding this mainlining effort, which could be useful to other engineers involved in ARM SoC support, as well as detail the steps we have gone through, the mistakes we’ve made and how we solved them, and generally our experience on this project.

This BoFs is intended to bring together anybody that tests the Linux kernel to share best practices and brainstorm new ideas. Topics may range from .config testing, module/built-in drivers, test methods and tools for testing specific driver subsystems, VM/scheduler/interrupt stress testing, and beyond. The discussion is targeted at Linux kernel developers, test engineers, and embedded Linux product teams/consultants with the common task of testing Linux kernel integrity. Attendees should have a firm grasp of building and deploying the kernel as well as kernel/userspace kernel APIs.

Several vendors are getting ready to start enabling the upstream kernel for their upcoming 64-bit ARM platforms, and it opens up a few questions on things that are not quite sorted out yet, especially on the embedded and mobile platforms. This is an open discussion on the issues these maintainers are anticipating, and what we should do about it.

Communication between components is necessary for effective power management in mobile devices. The System Power Management Interface, also known as SPMI, is a standardized bus interface intended to provide power-management related connectivity between components. Josh Cartwright will provide a high-level architectural overview of SPMI and discuss how to leverage the Linux Kernel software interfaces (expected to land in 3.15) to communicate with devices on the bus.

May 1

While Android has been created for mobile devices — phones first and now tablets — it can, nonetheless, be used as the basis of any touch-screen system, whether it be mobile or not. Essentially, Android is a custom-built embedded Linux distribution with a very elaborate and rich set of user-space abstractions, APIs, services and virtual machine. This one-day workshop is aimed at embedded developers wanting to build embedded systems using Android. It will cover Android from the ground up, enabling developers to get a firm hold on the components that make up Android and how they need to be adapted to an embedded system. Specifically, we will start by introducing Android’s overall architecture and then proceed to peel Android’s layer one-by-one.

This half-day workshop is aimed at embedded developers that want to use Android in their embedded designs.

The MIPS processor cores are widely used in embedded platforms, including TVs and set-top-boxes. In most of those platforms dedicated graphics hardware exists but it may be specialized for its use in audio and video signal processing: rendering of web content has to be done in software. We implemented optimizations for the software-based QPainter renderer to improve the performance of Qt —including QtWebKit— in MIPS processors. The target platform was the modern 74kf cores, which include new SIMD instructions suitable for graphics operations (alpha blending, color space conversion and JPEG image decoding), and also for non-graphics operations: string functions were also improved. Our figures estimate that web pages are rendered up to 30% faster using hand-coded assembler fast-paths for those operations.

Software Freedom Conservancy announced last year a renewed effort for cross-project collaborative GPL compliance efforts, including copyright holders from BusyBox, Linux, and Samba. Conservancy uses an internal system of communication and collaboration to take input from stakeholders to discuss and engage in compliance activity to ensure compliance with the GPL throughout the technology industry and particularly in the embedded device market. Compliance with the GPL is the responsibility of copyright holders of the software, and Conservancy helps those copyright holders pursue the work, so those developers can focus on coding. In this talk, the President of Conservancy will discuss how Conservancy handles compliance matters, what matters it focuses on, and how the copyright holders that work with Conservancy engage in a collaborative effort to ensure compliance with the GPL.

Ubuntu Touch is the new Ubuntu-based OS for phones and tablets. Announced at the beginning of 2013, it gives a new UI and design proposal, but also a new way of developing and supporting many different devices, using either the Android HAL or the traditional Linux stack to build the platform. This talk will go over the Ubuntu Touch internals, presenting the technical decisions and also the work that was done to bootstrap this new platform (camera, radio, video decode, GLES and etc) and the future challenges to support a single stack across mobile and the traditional desktop.

These are just a few sessions out of the 90+ sessions available at the Embedded Linux Conference and Android Builder Summit. You can check the full schedule to find out which sessions are most interesting to you.

If you’d like to attend the event, you’ll need to register online.

The attendance fees have significantly gone up compared to last year, at least for hobbyists, but include entrance for both ELC and Android Builder Summit:

  • Professional Registration Fee US$600 (Was US$500 until March 29, 2014)
  • Hobbyist Fee – US$150
  • Student FeeUS$150

After the events, many videos are usually uploaded by the Linux Foundation, and you should be able to find the list of talks with links to presentation slides

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter