For information on JumpStart C for Cortex-M ("V8"), please click here.

JumpStart C++ for Cortex with GCC Compiler

ImageCraft’s new release (“V9”) of the JumpStart compiler addresses one of the most glaring problems with JumpStart C for Cortex-M (”V8”): how do we ensure that we can build all the third party and open source stacks, as well as examples both from silicon vendors and those found on the web? The solution is obvious: we are moving to adopt GCC as the underlying compiler in the new JumpStart C++ for Cortex product. With GCC’s dominance in the Linux and other Open Source projects, GCC is now the standard third party compiler that most (if not all) silicon vendors support in their example and library releases.

From our users’ point of view, ImageCraft’s core competencies have not changed:

  1. Support: ImageCraft has been in business supporting embedded development since 1994. Our customers range from consulting engineers, to higher institution classes, and to Fortune 500 companies. ImageCraft understands the importance of products that work “out of the box”, and when the customers have an issue or questions, timely support is of utmost importance. These do not change with the compiler choice.
  2. Professional features: the IDE (Integrated Development Environment) has all the features you would expect: code-aware editor, code browsing, workspace and project management with multiple target support, plus compiler and debugging integration.
  3. Ease of use: we have tuned and continue to enhance the CodeBlocks IDE to offer user-friendly features, such as generating the compiler/linker commands automatically by allowing a user to select the target device by name.
  4. World-class debugging: integrated with the IDE, our from-the-ground-up visual debugger works with industry standard backends and debug pods. Features such as I/O register view, instruction trace etc. are highly valuable in difficult debug situations.
  5. Sensible licensing policy and pricing: commercial embedded tools tend to be expensive. Indeed, ImageCraft pioneered the “low cost professional embedded tools” back in 1994 with a $100 HC11 compiler at a time when the norm was $1200-$2500. Unlike companies that charge $7000+ for the initial license and $1000+ for annual support maintenance, our licensing is much lower than that. It is only $249 for ImageCraft’s STD (Standard) license, with an annual maintenance of just $125 . We even have very low cost option for students and hobbyists. Maintenance is only needed for support and upgrade to latest version, but otherwise your license remains valid and the product will remain fully functional.

    NOTE: Prices subject to change

Third Party Libraries

And now, with adopting GCC, we are adding one more major feature: the ability to use all the open source libraries and the third party stacks provided by the silicon vendors. We will implement simple-to-use-and-install schemes for downloading and building popular third party stacks, so that the users do not have to collect bits and pieces from all over the place. In addition, JumpStart C++ can import projects created by ST’s graphical CubeMX tools. We expect to support other vendors’ GUI tools in a similar fashion.

C Support Is Still Here

Of course, moving to C++ is a major step. Fortunately, GCC supports pure C, including the ISO C99 Standard and the 0x Standard, and since JumpStart C for Cortex-M (“V8”) uses our Standard C90/C99 compiler, your source code can be recompiled with minimal effort. We even include a V8 project importer command in the V9 IDE, so that you can convert your existing projects effortlessly. You can continue to write entirely in C if you wish.

Optionally, you can start with the simplest but most useful C++ enhancements such as objects for encapsulation, variable length array, literal structures etc. that are helpful for simplifying your C code, without using the more complex aspects of C++.

Footnote: AVR Compiler Support

Given the limited memory available in the Atmel AVR, and since our customers have a large number of existing projects written in our ICCAVR/JumpStart C for AVR, we do not feel it necessary to switch to GCC for the AVR product at this time. The only advantage might be to be able to compile some of Atmel’s latest software releases in their “walled garden” environment. However, the tradeoffs do not currently seem worth doing so. Therefore, JumpStart C for AVR remains our current AVR release.

Major Features of JumpStart C++ Tools

  • Professional IDE with workspace/project management, syntax aware features, code browsing etc.
  • Import CubeMX projects.
  • No need to write linker command files. Select target device by name and our tools do the rest.
  • Full set of GCC compiler tools including C compiler, assembler, linker and library file manager. Industry compatibility and industry leading performance.
  • Native visual debugger, integrated with the IDE.
  • Seamless integration with Segger JLINK, SAM-ICE, and ST-LINK/V2 debug pods.
  • Support Cortex-M0, Cortex-M3, M4, and M7 series from all major vendors.
  • Easy to use JumpStart API. Get started in Cortex-M programming in minutes, not days or months.
  • Built-in flash downloader.

JumpStart Tools Come in Two Different Editions

  • STD (Standard) - for basic commercial development. 
  • NC (Non-Commercial) - for students and hobbyists. Non-commercial use only.

More comments from a customer Patrick Cowan:

Your business model is awesome, and I think it has huge potential to sell your software by making it very easy to use and basically idiot-proof. I don't know much about software, but I was able to learn how to use an Arduino fairly easily. The idea of your software being that same level of simple/easy, but working on other processors is very appealing. In fact we found your company existed because I told [my partner] that someone HAD TO be making software like this. After doing some google searching we found you guys! 

CodeBlocks IDE

ImageCraft enhanced the Open Source CodeBlocks IDE to add user friendly features such as selecting target device via point-and-click, instead of writing complicated linker files. We integrated it with our own JumpStart Debugger including the ability to see the MCU's IO register content. More information and screenshots here.

JumpStart Debugger

The integrated debugger is described here. It requires a separate license purchase to enable all of its features.

 

Purchase Online

You can download Smart.IO related software here. Be sure to read the documentation here.

Software from ImageCraft

Smart.IO firmware upgrade instructions can be found on this page.

There are two methods to find the version number of your Smart.IO hardware:

  1. Connect to Smart.IO hardware and run the Smart.IO app, click on the system menu (the gear icon on the upper right), then click "About Us". If the firmware version is lower than the one in the table, email us at This email address is being protected from spambots. You need JavaScript enabled to view it. and we will send you the download instructions to download the latest firmware.
  2. Connect the UART port of the Smart.IO to a terminal programming running at 9600 baud (see Hardware Integration Guide here for details) and reset the module. The version will be displayed as part of the initialization message.

When searching for the Smart.IO app, use the terms "ImageCraft Smart.IO" and look for this logo:

Software Version
Smart.IO firmware (email This email address is being protected from spambots. You need JavaScript enabled to view it. to request download link) 1.01
   
Smart.IO iOS App at the Apple App Store
 
auto-update from iOS App store
Smart.IO Android App at the Google Play Store

auto-update from Google Play store
   
Host Interface Layer source (.zip archive)
ST32F4x1 reference port using JumpStart C for Cortex-M, and
AVR Mega328P port using JumpStart C for AVR,
plus demo program source.
1.04
   

 

Software from ST st.com

Smart.IO uses the BlueNRG1 Bluetooth SoC. You need one of the following pieces of software to update the Smart.IO firmware. See instructions here. If a ST software link no longer works, please email us at This email address is being protected from spambots. You need JavaScript enabled to view it.m. A web search with relevant terms (e.g. "BlieNRG1 ST-LINK") should provide the proper links.

  • BlueNRG1 ST-LINK Utility requires the ST-LINK JTAG/SWD debug pod. Current version 1.0.0 as of 2017/08/30. Provides faster download if you already own the debug pod. NOTE: normal ST-LINK utility does not work with the BlueNRG1.
  • BlueNRG1 DK (development kit) software. Current version 2.50 as of 2017/08/30. In particular, you can use the BlueNRG1 flasher to update the Smart.IO firmware with just a serial connection (e.g. a FTDI based USB to serial cable, or the FTDI based connector in the Smart.IO Arduino shield).

 If you are using the ST-Nucleo as evaluation platform, you need the ST-LINK utility to program the boards. As mentioned, you must use the BlueNRG1 specific ST-LINK to program the Smart.IO and the "generic" ST-LINK utility to program the ST-Nucleos.

  Smart.IO forum is now live. Click here to enter the forum. Smart.IO is great for prototyping, as well as product realization.

Download the Smart.IO slide show presentation here.

Smart.IO: the Paradigm Changing Way of Creating a GUI for Your Embedded Tech

An App UI in a few lines of code with no App or wireless coding

Embedded prototyping - or even embedded products, and "elegant and useful UI", are usually not mentioned in the same sentence. Embedded technology has typically been hampered by “old school”-looking hardware UI with limited functionality (a tiny LCD screen, limited commands, and a few buttons which invoke different commands depending on the sequence in which they are pressed). This "primitive" hardware UI has required accommodation in the physical appearance of each device.

Smart.IO was successfully funded on KickStarter. It is inexpensive and even less costly when purchased in bulk. Smart.IO is now shipping. READY TO BUY? Click here

It is clear, however, that App UI is the wave of the future. With the rise in popularity of smartphones, providing an App for your embedded products will soon be a necessity, not just a "checkbox on your wish list".

Figure 1: An app-based UI for even a simple "smart wall plug” is more accessible and easier to use than multi-function buttons and small LCD


Traditional app design methods have involved choosing and designing custom wireless technology on a per-individual-product basis, and have required hardware and software designers who are experienced in both wireless and app design. These, of course, have added to the development time and cost. Moreover, if you are just doing prototyping or creating hobbyist projects, it is impossible to justify the costs involved in creating an app UI.

Smart.IO is a game-changer for creating app UIs. Its key features are:

  1. A firmware-created UI which runs on both iOS and Android devices with no app coding.
  2. A complete single module BLE module with SPI interface. No BLE coding necessary.
  3. An easy-to-use software API.  You only need to port the Host Interface Layer to your MCU compiler system. (Standard C source code provided for easy porting)
  4. Simple-to-create device-independent UI which looks good regardless of the target screen resolution.
  5. Access to native OS features such as touch controls, a virtual keyboard, etc.

Figure 2: The Smart.IO hardware module, measuring 15mmx25mm (Version 1)


In a nutshell, the embedded firmware calls the Smart.IO API functions, which are then interpreted by the app to create the UI as instructed by the API calls.

Smart.IO is great for prototyping and for small-volume products, as well as mass production. Once the hardware is designed into a prototype and the embedded firmware is modified to work with the Smart.IO API, then you only need to install a free Smart.IO app to control the device.

Smart.IO API includes advanced features such as automatic enabling/disabling a UI control based on the state of another UI control. In this example, while it may be hard to see on the screen caps, the slider control is a lighter shade on the first image and is disabled (i.e. it cannot be changed) since no item is selected in the expandable list. In the second image, the user selects an item and the slider can be adjusted. This coupling is done once by the host MCU firmware and does not require any other host MCU processing.

       


For volume production, we offer volume pricing. In highly pricing-sensitive applications, you can incorporate the Smart.IO components directly onto your PCB and license our IP, both reducing component costs and saving space in the design.

Software-wise, the app can be modified to display your custom logo and company brand (e.g. end users would install an “Acme gadget controller” rather than the generic Smart.IO app). For even more complete customization, we can modify the app and use only your custom logos and graphics, effectively giving you a full custom app for significantly less cost than the time and money that would otherwise be spent developing an app solution from scratch, while getting your products out to market much faster.

For more information, please see this documentation page https://imagecraft.com/documentation/smart-io-documentation or email us at This email address is being protected from spambots. You need JavaScript enabled to view it.

Smart.IO is inexpensive and even less costly when purchased in bulk. Smart.IO is now shipping. READY TO BUY? Click here

Free iOS and Android apps:  the free Smart.IO apps, available on Apple App Store and Google Playstore, can be used with any Smart.IO-enabled devices. An app user may enable caching for faster UI startup time for $4.99 (in-app purchase). We can provide customized app for a vendor-specific device. Email is This email address is being protected from spambots. You need JavaScript enabled to view it.for details.

Here's a quick basic demo:

Finally, the UI in figure 1 is done using the following code fragment, no other code is needed other than the callback functions to handle user input.

 SmartIO_AppTitle("Smart Wall Plug");
tHandle p1 = SmartIO_MakePage();
tHandle h1 = SmartIO_MakeOnOffButton(0, 0, 1, Button1);
SmartIO_AddText(h1, "Power");
SmartIO_SetSliceIcon(h1, SMARTIO_ICON_POWER);
tHandle h3 = SmartIO_MakeSlider(1, 0, 30, Slider1);

SmartIO_MakeSpacerSlice(2);
tHandle tl0 = SmartIO_MakeLabel(0, 1, "Auto On/Off Schedule");
tHandle tl1 = SmartIO_MakeLabel(0, 0, " Weekdays");
tHandle th1 = SmartIO_MakeTimeSelector(0, 1, "17:00", ts1);
SmartIO_AddText(th1, "ON at");
SmartIO_SetSliceIcon(th1, SMARTIO_ICON_QUERY);
tHandle th2 = SmartIO_MakeTimeSelector(0, 1, "12:00", ts2);
SmartIO_AddText(th2, "OFF at");
SmartIO_SetSliceIcon(th2, SMARTIO_ICON_QUERY);
SmartIO_GroupObjects(0, tl1, th1, th2, 0);
SmartIO_MakeSpacerSlice(1);

tHandle tl2 = SmartIO_MakeLabel(0, 0, " Weekend");
tHandle th3 = SmartIO_MakeTimeSelector(0, 1, "18:00", 0);
SmartIO_AddText(th3, "ON at");
SmartIO_SetSliceIcon(th3, SMARTIO_ICON_QUERY);
tHandle th4 = SmartIO_MakeTimeSelector(0, 1, "1:00", 0);
SmartIO_AddText(th4, "OFF at");
SmartIO_SetSliceIcon(th4, SMARTIO_ICON_QUERY);
SmartIO_GroupObjects(0, tl2, th3, th4, 0);
SmartIO_MakeSpacerSlice(3);
SmartIO_AutoBalance(p1); 

Smart.IO User Guide

All previous separate Smart.IO documents have been subsumed into a single "Smart.IO User Guide". V0.2 (2018/01/02) in PDF available here.

 

Schematics:

Smart.IO Schematic in PDF

Arduino Shield for Smart.IO Schematic in PDF

MCU Datasheet

BlueNRG1 Datasheet from ST in PDF

Sell Sheets

JPG sell sheet

PDF sell sheet

JumpStart C for Cortex-M download and documentation are elsewhere on this site.

wifi2go datasheet in PDF is here.

wifi2go User Guide in PDF is available here.

Schematics of the wifi2go and the Carrier modules are available as a zip file here.

wifi2go Altium files for designing the module in your designs are available as a zip file here.

Copies of the TI document on CC3100, SimpleLink etc. are available as a zip file here.