Archive

Posts Tagged ‘C/C++’

2013 Embedded Market Study – Software Development & Processors

May 21st, 2013 2 comments

UBM releases a study of the embedded market every year, by surveying over 1,000 embedded professional every year. They’ve just published their 2013 Embedded Market Study (85 pages report), after surveying over 2,000 engineers and managers, so let’s see whether anything has evolved in the software development and processor space compared to 2012.

Again this year, most respondents are based in the US (62%), followed by Europe (20%), and Asia (12%).

C/C++ languages still rule the embedded world with 81% market share, although a little less than last year (85%), assembler is a distant third (5%).

Programming_Language_Embedded_Systems_2013

Interestingly, the average size of development teams seems to have shrunk from 15.9 in 2012 to 14.6 in 2013, the average project being composed of 4 software engineers, 2.9 hardware engineers, 2.7 firmware engineers, 2 QA/Test engineers, 1.5 system integrators, and 1.5 with other functions.

About a third of project last less than 6 months, another between 6-month and a year, and the last third over a year, with project lasting 12.5 months on average.

embedded_systems_project_duration_2013

Embedded Projects Duration in Month

Projects life cycle breakdown shows much more time is spent detailed design stage, and a bit less on testing and debugging. Another interesting point is that only 1% of the time is now spent on documentation,  so either people gives even less of a damn about documentation than the previous years, or everybody has become highly efficient at writing docs.

embedded_systems_development_schedule_breakdown

Percentage of Time Spent on Different Stages of Development

The trends continues, as less and less Embedded projects use commercial operating systems, and companies opt more and more for open source operating systems, and in 2013, the survey shows that most projects are likely to use an open-source OS without commercial support. The top 3 reasons for choosing a commercial OS is real-time capability, good software tools, and processor & hardware compatibility.

Type of Operating System used in Current (left) and Next (right) Project

Type of Operating System used in Current (left) and Next (right) Project

AS with previous years, the operating system choice is mainly influenced by software engineering staff & managers (62%), but it’s still sometimes decided by corporate management (17%). The top three reasons for OS selection are a little different from last year, as real-time performance, although still important (29%),  has been kicked out:

  • Full source code availability (42% in 2013 vs 41% in 2012)
  • Availability of tech support (34% in 2013 vs 30% in 2012)
  • No royalties (30% in 2013 vs 31% in 2012).

54% of respondents are currently using or consider using embedded Linux in their next project because it is low cost (66%) and easily adaptable and extensible (52%), but 47%, a bit more than last year, would not consider embedded Linux mainly because they don’t need it (72%), but also because of software/app/driver incompatibility (18%)  and performance/real-time capabilities (15%). Legal reasons seem to have become less important, as only 6% consider it an issue with  embedded Linux, compared to 14% last year.

The enthusiasm for Android in embedded systems seems to have faded a bit compared to last year (28% vs 34%), FreeRTOS is still very much used, and 19% companies still rely only their own OS. Micrium and QNX have declined the most compared to last year.

Embedded_OS_List_Android_Linux_RTOS_2013

Overall there has been very little changes and Linux share, including Android, is still strong with about 60%, compared to last year 70%. I’m a bit confused with the chart above, as most OS seem to be stable, or have lost market share, but only In-house OS and Keil have gained slightly.

Most embedded projects still use 32-bit processors (63%), followed by 14% using 16-bit version, 12% 8-bit and 8% for 64-bit. Both 8-bit and and 16-bit usage is declining, 32-bit usage is stable compared to last year, and 64-bit usage is on the rise. Most embedded projects still have a main processor clock rate below 250 MHz, the average frequency is creeping up (485 MHz in 2013 vs 425 Mhz in 2012), and 1 and 2+ GHz processors are on the rise.

Frequency of Main Processor in Current Embedded Project

Frequency of Main Processor in Current Embedded Project

When asked to cite one and only one vendor with the best ecosystem for the needs of the respondent, Texas Instruments still gets the lead (19%), followed by Freescale (12%) and Microchip (10%) in just the same order as last year.

According to the points above in UBM survey, there hasn’t been drastic changes between 2012 and 2013, but there are still some long and slow trends over several years, such as the increased share of open source operating systems, and the predominance of 32-bit processors.

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

Replicate CAPE Adds 3D Printring Capability to the Beaglebone

February 2nd, 2013 No comments

Beagleboard.org launched the Beaglebone Cape Design Contest back in November, several designs were submitted, and yesterday, they announced the 3 winning CAPEs who will be manufactured and sold by Circuitco Electronics:

  • Replicape by Elias Bakken - 3D printer cape
  • Interacto by Chris Clark – Cape with a triple axis accelerometer,a gyroscope, a magnetometer and a 640×480 30fps camera.
  • Geiger cape by Matt Ranostay – Geiger counter cape

Since today I’ve started to write about 3D printing, let’s carry on and have a closer look at the Replicape.

Replicape

The Replicape 3D printer cape includes:

  • 5 stepper motors (X, Y, Z, Ext1, Ext2)
  • 3 high power MOSFETs (PWM controlled) for 2 extruders and 1 HPB
  • 3 medium power MOSFETs (PWM controlled) for up to 3 fans
  • 3 analog input ports for thermistors
  • 3 inputs for end stops (X, Y, Z)
  • Programmable current limits on steppers motor drivers (SMD). No need to manually adjust a pot meter.
  • Microstepping individually programmable for each SMD from 1 to 32.
  • X, Y and Ext 1 SMDs wired to PRUICSS for hard real time operation.
  • Option for stackable LCD cape

It seems to be working, albeit slowly, as a control board for the Makerbot Cupcake.

The replicate hardware files (schematics, bill of materials, gerber files), and the source code (Python and C) for the PRU and controlling stepper motors, are available on Bitbucket. So you could make it yourself, or buy the Replicate from Circuitco when it’s available, and improve the source.

You can also follow Elias progress on his blog: hipstercircuits.com.

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

Collabora and Fluendo Release GStreamer SDK for Android

December 3rd, 2012 No comments

Collabora and Fluendo have recently announced the availability of GStreamer’s Software Development Kit for Android, which allows developers to create multimedia playback applications for Android smartphones and tablets using Gstreamer and the Android NDK..

The GStreamer SDK for Android targets Android 2.3.1 Gingerbread or higher (API Level 9 or greater). However, due to some of the restrictions of previous versions of Android, some features such as hardware acceleration are only available on Android 4.1 Jelly Bean (API Level 16 up).

Normally, you’d need the GStreamer SDK which can be installed on Linux (Ubuntu, Fedora and Debian), Windows (XP/Vista/7/8) and Mac OS X (10.6 to 10.8). But for developing Android applications using Gstreamer, you don’t. What you do need first is a typical Android development environment with the latest Android SDK, the latest Android NDK, and optionally, but recommended, the Eclipse IDE with Android ADT and NDK plugins. Once everything is setup correctly, and you have made sure you can build NDK apps, you can download and install GStreamer SDK for Android (ARM only).

I’ve tried the instructions in Eclipse 4.2.1 with Android NDK 8b and Android Tools SDK 21 following the the instructions to install GStreamer for Android development. In Eclipse IDE, make sure the Android SDK and NDK paths are correctly setup (Window->Preferences->Android->NDK), and set  GSTREAMER_SDK_ROOT_ANDROID to the folder where you unzipped the SDK, by going to Window->Preferences->C/C++->Build->Build Variables and defining GSTREAMER_SDK_ROOT_ANDROID.

There are 5 tutorials provided in the GStreamer SDK for Android:

  • Tutorial 1: Link against GStreamer
  • Tutorial 2: A running pipeline
  • Tutorial 3: Video
  • Tutorial 4: A basic media player
  • Tutorial 5: A Complete media player

Eventually, it will be possible to add GStreamer code to Java apps, but language bindings for the GStreamer API are not complete yet. The tutorial are written in both C and Java code with Java used for the User Interface, and C for the GStreamer code, with both parts interacting through JNI.

To import a tutorial into the Eclipse workspace, click on File->New->Project… ->Android->Android Project from Existing Code, and select the folder android-tutorial-1 in GSTREAMER_SDK_ROOT_ANDROID/share/gst-sdk/tutorials.

At this stage, Eclipse might complain about missing files, but this is normal, and we need to add native development support by right-clicking on the project tutorial1 and selecting Android tools->Add Native Support… The NDK plugin should ask for a library name, just keep the default (libTutorial1.so) and accept. Click on Project->Build Project in the top menu. Once the build is complete, run the project: Run->Run, and after a little while, the demo should appear in the emulator or your Android device.

You should be able to reproduce the same steps with tutorial 2 to 5. Details are available on GStreamer’s Android tutorials page.

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

Designing An Android Sensor Subsystem: Pitfalls and Considerations – Android Builder Summit 2012

March 14th, 2012 No comments

Jen Costillo of Lab 126 discusses the Android sensor subsystem at the Android Builder Summit in February 2012.

Abstract:

This lecture will arm Android device architects with the tactical knowledge they need to navigate the Android Sensor subsystem and make knowledgeable design choices to improve user experience and improve battery performance. The talk will address:

  • Hardware architecture and trade-offs including latency, power, and software architecture implications:
  • Wake up events and power considerations
  • Gesture Detection Algorithm processing location and considerations
  • Testing methodologies (Creating tools to aid develop and collect data.

This talk targets the kernel/firmware developer responsible for the sensor architecture. They should be familiar with kernel drivers, embedded systems, hardware bring up, Android services, and the C language.

You can also download the presentation slides on linuxfoundation.org website.

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

Debian is Worth a Lot (Yet it’s Free) and C/C++ Language Still Rules

February 16th, 2012 No comments

James E. Bromberger (JEB) , a contributor to Perl CPAN and Debian, has estimated the cost of developing Debian Wheezy (7.0) from scratch based on the the number of lines of code (LOC) counted with SLOCCount tool, the Constructive Cost Model (COCOMO) and the average wage of a developer of 72,533 USD (using median estimates from Salary.com and PayScale.com for 2011).

He found 419,776,604 lines of code in 31 programming languages giving an estimated cost of producing Debian Wheezy in February 2012 of 19 billion US dollar (14.4 Billion Euros), making each package source code (out of the 17,141 packages) worth an average of 1,112,547.56 USD to produce.

He also estimated the cost of Linux 3.1.8 Kernel with almost 10 millions lines of source code would be worth 540 million USD at standard complexity, or 1.877 billions USD when rated as ‘complex’.

I don’t know which tool he used for the calculation (maybe his own), but there are two simple COCOMO calculators on the internet in order to estimate the number of man hours required for a particular project based on the LOC and the code complexity:

Bromberger also estimated the cost of several individual projects used in Debian and found that developing Apache 2.2.9 would cost 33.5 million USD and MySQL 64.2 million USD with today’s salary.

Of course, there are some caveats to such cost estimation. First, those costs assume software engineers based in the US. Taking into account outsourcing would significantly reduce those cost estimations. Second, he also tried another source code analysis tool (Ohcount) which found much less lines of code in Debian Wheezy. Finally, you also need to estimate the code complexity in the COCOMO model which may lead to great variation in the final costs.

In the last section of his post, Bromberger also analyzed the 31 programming languages that were used to develop the Debian software (See his chart below). It shows C and C++ still rule the (programming) world with respectively 40% and 20% of code written in those 2 programming languages. Java comes a distant third at 8%.

C/C++ Rules the World !!!

Top 11 Programming Languages of Debian Wheezy

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

Design West Summit – 26-29 March 2012

December 12th, 2011 No comments

Embedded System Conference 2012UBM Design announced the schedule and pass pricing for Design West Summit (previously Embedded System Conference) which will now bring 7 summits in one location (San Jose McEnery Convention Center) on 26-29 March 2012:

  • Embedded Systems Conference & Exhibition -  Conference Dates:  March 26 – 29, 2012.  Exhibition Dates:  March 27-29, 2012. (See Details below)
  • Android Summit – March 28, 2012 -  Everything Android  from embedded design to Apps development.
    • Android Certification Program
    • Android Speed Training
    • Android Fundamentals Course on the Expo Floor
    • Android Conference Program
  • Multicore DevCon- March 27 & 28, 2012 – Embedded multicore and multimedia.
    • 7th annual Multicore Conference Courses
    • Multicore Expo Floor Zone
    • Multicore Fundementals Courses
    • Keynote Addresses
    • Industry Addresses
    • Expo floor parties and giveaways
  • BlackHat – March 29, 2012 – One-day conference focused on security in embedded systems.
    • Security Fundementals Course
    • Black Hat Summit Conference Courses
    • Security focused presentations in the expo floor theater
    • Keynotes and Industry Addresses
    • Expo Floor Parties and Giveaways
  • Sensors in Design – March 28-29, 2012 – Technical presentations on the application of sensor technology in real-world products.
    • Sensors Conference and Expo Programs
    • Sensors Fundementals Course
    • Sensors expo floor theater events
  • DesignMED - March 28, 2012 – Medical electronics design and regulatory issues.
    • DesignMED zone on the expo floor
    • DesignMED Fundementals course
    • DesignMED Conference courses
    • Special presentations iand teardowns in the expo floor theater
  • Designing with LEDs – March 27, 2012 – Design of high-brightness LEDs in lighting and illumination
    • Conference and Expo exclusive for LED Summit
    • LED Fundamentals Course
    • Keynote Addresses
    • Industry Addresses
    • Expo floor parties and giveaways

The detailed schedule is not finalized yet, but key tracks for the Embedded System Conference will include:

  • Analyzing, Debugging, and Agile Development:  Software and hardware methodologies that rely on agile development, static analysis, model-driven tools and other techniques to maximize system performance while avoiding costly and time-wasting mistakes.
  • Best Practices; Managing, Process and Quality: From concept to production-worthy code and systems,  “best practices” information for engineering project management, maintaining quality and avoiding common s/w and h/w mistakes.
  • Challenges and Solutions in Embedded Design: Experts describe myriad successful outcomes to embedded design’s most difficult problems. An emphasis on case studies and real world examples.
  • Connectivity and Networking: Understanding and implementing wired and wireless Internet,  “cloud”,  local interface and network connections to and within embedded systems.
  • Design, Test, Prototype and System Integration:  Time to market: a whole-system approach to software and hardware, focusing on modeling, simulation (including virtual), testing  and software/hardware system integration and test.
  • FPGAs in Embedded Systems: FPGAs with intelligent peripherals, multicore processors, DSPs and on-the-fly reconfiguration can replace entire PCBs. Here’s what you need to know about the latest instantiations, programming, IP and coexistence with other CPUs.
  • Hardware, Architectures, and I/O:  Hardware-centric approaches to small form factors, HMI displays, multicore, popular CPUs and microcontrollers,  reference design examples, more.
  • Linux, Android and Open Source:  Evaluating, understanding and using embedded Linux, the Android platform, and other popular open-source software.
  • Low-Power Design: It’s all about balancing low power, performance and cost – from processor selection and low-power modes, system design, tips and tricks, and writing efficient software.
  • Microcontrollers and SoCs in Embedded Designs:  Understanding, selecting, designing, programming, and using MCUs and SoCs in embedded. Sessions vary from coding the latest ARM (and other) processors to designing the entire system with I/O and sensors.
  • New Directions in Software, Processes and Tools:  Changes are coming to modern languages like C, C++, Java and others, and common IDEs like Eclipse and other tool suites keep evolving to meet new requirements. Tune in to stay plugged into what’s new.
  • Programming, Languages and Techniques:  This track offers insights that will help you write code that’s more reliable, maintainable, efficient and/or portable using the most popular languages for developing embedded systems.
  • RTOS and Real Time:  Fundamental real-time concepts, selecting and understanding an RTOS, developing and verifying real-time systems.
  • Security and Safety Come to Embedded:  Examining security and malicious attack mitigation for connected embedded systems; and aspects of developing, testing and deploying for life- and safety-critical systems.

If you plan to only access the expositions, the pass (Expo Pass) is free and you only need to register. For details about the other pass see table below. Super Early rates are available until the 18th of December 2011. All pass includes an 10.1″ Android tablet.

Super Early
Rates Expire
12/18/2011
Early
Rates Expire
2/19/2012
Advanced
Rates Expire
3/25/2012
Onsite
Rates apply
3/26- 3/29 2012
All Access (Recommended – Best Value + Offical Show Tablet) $1,999 $2,299 $2,599 $2,799
ESC Only Pass (4 Day ESC Pass) $1,499 $1,699 $1,999 $2,299
2 Day Pass (Tuesday-Wednesday OR Wednesday – Thursday ONLY) $1,099 $1,299 $1,599 $1,899
1 Day Pass (One Day access Tuesday-Thursday) $599 $799 $899 $999
Expo Pass FREE FREE FREE FREE

Further details are available on Design West Official Website.

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

ARM Releases Free DS-5 Community Edition For Android Developers

November 29th, 2011 No comments

ARM announced a free version of its Eclipse-based  DS-5 tools for small development firms (with 10 or fewer developers) and individuals who publish applications for Android. The ARM Development Studio 5 (DS-5) Community Edition (CE) helps create performance- and power-optimized native software by integrating a graphical debugger for code generated for the Android Native Development Kit (NDK) and a basic version of the ARM Streamline performance analysis tool.

Eclipse Android Debuger for ARM

ARM DS-5 Android Debugger

DS-5 CE is designed to work with Android Virtual Devices ( AVDs), development boards and devices that run Android 2.2 and API 8 or higher. ARM Development Studio 5 (DS-5) Community Edition is distributed as plug-in for Eclipse and completes the app developer toolkit with a C, C++ and Assembly graphical debugger that builds on the Android Debug Bridge (ADB), a software performance profiler and system analyzer (ARM Streamline).

ARM Profiling Report with Eclipse

ARM Streamline Report

To get started, you’ll need Eclipse IDE, the Android SDK and the Android NDK installed. Then you can install DS-5 CE from Eclipse.

ARM explains that native code optimized for ARM cores performs up to 4 times faster than Java code, native code is easier to reuse for other platforms and most smartphones are based on ARM processors.

Companies with more than 10 developers can get the fully featured version of DS-5 which includes an ARM Compiler, an OS-aware debugger that supports a range of debug operations from bare-metal debug to Linux kernel debug and SMP debug, system-wide performance analyzer and real-time system simulator.

More details on Developer Studio 5 Community Edition can be found on DS-5 CE page.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Shout it
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter
Categories: Android, Programming Tags: Android, C/C++, arm, eclipse, ndk