ImageCraft InfoBytes Blog

News, Notices and stuff we're talking about.

Major Step for ImageCraft, JumpStart C++ for Cortex Beta Now Available

Major changes to the JumpStart product! We are rolling out C++ support, plus  access to 3rd party and vendor libraries and GUI Builders such as ST CubeMX. Read some of the info here:

Download the beta here:
Continue reading
303 Hits

Smart.IO Apps now available!

Apple just approves the Smart.IO app, it will be available at the App Store within 24 hours.

The Android version is already live at the Google Play Store since a day or so ago.

Be sure to check out our monthly Smart.IO design contest and have your chance of winning $500!

Continue reading
611 Hits

Smart.IO App Screencaps

Smart.IO is shipping before end of August! Now anyone can create an App UI for their embedded tech!

Sample UIs  We design Smart.IO to be easy to use, yet powerful. Notice that in the "Pokemon Control" the power up slider is automatically dependent on the state of the expandable list: if no Pokemon is selected, then the slider is inactive. This is done with a single API call. 

Check out for more details.


Continue reading
507 Hits

Smart.IO Production Hardware Are Here!

1000x pieces are here and ready to be shipped!


We do have some other stuff to finish though:

1) A manufacturing error means that we have to redo the Arduino shields. We are trying to salvage what we have, and if so, they should be finished in about 2 weeks.

2) The iOS and Android Apps are functional complete. We are now fixing any issues we find, and getting them to be put on the Apple and Google stores.

3) The (revised) Smart.IO firmware had some delay, mainly due to some personal reasons. Sorry about that.

4) Documentations are being written and uploaded to our website

So definitely on the final stretch. Shipping will commence as soon as the firmware is finalized, and we are aiming for end of July / beginning of August delivery.


Thank you for your patience!

Continue reading
607 Hits

Six Weeks and Counting

"Smart.IO hardware production has commenced!!"

This is a phrase I really wanted to write 4+ months ago. However, a hardware redesign and patent filing delayed the production schedule; very sorry about that. However, this delay gave us the opportunity to rework the firmware architecture as well as the user software model.

For embedded prototypes that want more than just a few buttons or knobs for their user interface, Smart.IO is miles ahead in terms of features, cost, and time required for implementation. These advantages carry over if you decide to go into production using Smart.IO as well.

We will be shipping hardware modules before the end of July, and will be releasing documentation on our site It's been a long time preparing, but the exciting journey has just begun...

The production modules will have blue lettering on white PCB; for now, here is an image of the prototype on the Arduino style shield.

Continue reading
572 Hits

Smart.IO Status

The draft version of the GUI User Guide can be downloaded from here (PDF file). Status:


  • The Smart.IO chip module has been redesigned using the latest ST BlueNRG1 BLE chipset for high performance and low cost.
  • The Smart.IO chip module should go into manufacturing by end of March / beginning of April with a production time of 4-6 weeks.
  • We expect to have the Smart.IO programmable app for iOS available at the same time the Smart.IO chip modules are ready for delivery.
  • The Android version of the programmable app is in development as well. It's approximately 6 weeks behind the iOS version in schedule.


This is a mock-up of a sample UI for a "Smart Wall Plug" - see the GUI User Guide for details. With Smart.IO, it takes just a dozen+ lines of code to create this UI, with no wireless or app coding.


Continue reading
866 Hits

Smart.IO is now Patent Pending

More detail and user documentation coming soon!

Continue reading
745 Hits

Smart.IO funding success on KickStarter!

Smart.IO was funded successfully on KickStarter (project link here). We will add more information to this page shortly. A few quick notes:

  • We will be setting up a forum at for Smart.IO users.
  • As we reached our stretch goal for the KickStarter, we will start work on the Android version of the programmable app soon.
  • Pre-production purchases will be available shortly.

Thank you for your support!

Continue reading
879 Hits

Smart.IO Demo Project coming soon.

KickStarter link here.

To make it easier to get started with Smart.IO, we will be releasing the complete design to make a smart wall plug. Remember this "old-school" programmable timer?

old style programmable wall plug
old style programmable wall plug

With Smart.IO, the wall plug would be physically much smaller and the programmability is only limited by your imagination. 

For the demo project, we will show you how to write firmware and the UI to use it as a vacation timer or as a timer with daily schedules. The firmware source code and the PCB design will be made freely available. We will even stock some of the parts (such as the plastic housing) to make it easy for you to get started.

Join the Smart.IO revolution today!

Continue reading
779 Hits

Smart.IO KickStarter is LIVE!!

Sorry for the earlier post - the blog software was messing up the formatting, so I deleted it, forgetting that the software sends out notifications to some people already.

The Smart.IO project is now live on KickStarter. Please check out the write up and watch the video. I hope you will join and become one of the backers. Thank you.

Continue reading
968 Hits

Smart.IO.. coming soon

All embedded product designers want to provide a great user interface for their products. In 2016, the obvious state-of-the-art solution is to write an app to more easily use Widget X. The only problem is that it takes quite a bit of time and $$$ to incorporate the wireless technology needed, and of course even more time for writing the app.

Until Now! - or until Real Soon, that is! Only $16, a few lines of API calls, NO wireless programming, NO app writing... details coming soon on KickStarter!!... Stay Tuned!!


Continue reading
1083 Hits

Coming Soon... Smart.IO

A teaser pic:

The IO Solution For Smart Products


Coming Real Soon Now....


Continue reading
970 Hits


A screenshot of the prototype, details forthcoming...

Continue reading
948 Hits

Spiffy New Animation On Our Homepage

Check out our home page if you have not done so in the past couple days. The "Hero Slides" concept is good but I thought we can do better. Our superhuman web designer met the challenge and did exactly what I envision. It describes our focus perfectly.


Continue reading
893 Hits

ST BlueNRG support and ImageCraft BLE Products

So many product ideas, so little time ;-) We now have ST's BlueNRG working using JumpStart C for Cortex-M:


We will have the modified source uploaded to Github later. If you are interested in a beta release of the ST's stack, feel free to email me.

This is just the beginning though. Having support for the BlueNRG is nice, but we are working on some great integrated products that will enhance your embedded systems. Stay tuned.

Continue reading
1166 Hits

Advantages of a Message-Passing OS

ImageCraft's upcoming RTOS (Real Time Operating System) product is based on a message-passing kernel. The working code name for the product is eMOS, short for Embedded Message-Passing OS, the eventual product name may differ. In this post, we will examine some of the advantages of using a message-passing kernel (we will explain WHY we are writing our own RTOS - and describe its architecture - in a later post.)  

While most traditional RTOS and desktop/server OSes are "monolithic" in design (i.e. the kernel includes a large number of kernel functions), a message-passing kernel includes only a small set of functions, as most functions of a monolithic kernel may instead be written to run in non-kernel space as normal tasks.  While not as widely used as monolithic kernels, there are significant design, peformance, and robustness advantages to a message-passing kernel. As an example, QNX, the kernel behind BlackBerry smartphone's BB OS, is one of the most well known message-passing kernels.

Let's look at how message passing can replace the requirement for certain functions in kernel space; for example: memory allocation using something similar to C's malloc and free library calls. In a monolithic kernel, if the low level memory management routines are outside of the kernel space, then certain code regions must be protected so that the internal data structures will not be corrupted by multiple tasks modifying the same data due to task switching.

Hence, monolithic kernels usually include low-level memory management routines as kernel functions. By running them in kernel space, the kernel provides automatic protection for the memory management data structure. However, this increases the size of the kernel, and limits the ability to replace memory management routines with others best suited for a given situation. For example, one may wish to use best-fit or first-fit or other algorithms to manage memory allocation. Having these fixed in the kernel code delivered by the RTOS vendor limits replacibility.

A message-passing kernel provides a better alternative. By using message-passing mechanisms, memory management routines run as normal tasks:

// message buffer
typedef struct {
    unsigned cmd;
    unsigned args[4];

void MemManager(void)
    SYSCALL op;
    int pid;

    while (1)
        if (eMOS_MsgReceive(&pid, &op, sizeof (op), 0) >= 0)
            if (op.cmd == 0)
                void *rp = ...; // code to allocate memory

     eMOS_ResourceTrackingAdd(pid, rp);
                eMOS_MsgReply(pid, &rp, sizeof (rp));
            else if (op.cmd == 1)
                ...(void *)op.args[0]... // code to deallocate memory
     eMOS_ResourceTrackingRemove(pid, op.args[0]);
                eMOS_MsgReply(pid, 0, 0);
            ... // other requests such as realloc

void *malloc(unsigned size)
    void *rval;
    op.cmd = 0;
    op.args[0] = size;
    if (eMOS_MsgSend(mem_manager_pid, &op, sizeof (unsigned) * 2, &rval, sizeof (void *)) >= 0)
        return rval;
    return 0;

void free(void *vp)
    unsigned rval;

    op.cmd = 1;
    op.args[0] = (unsigned)vp;
    eMOS_MsgSend(mem_manager_pid, &op, sizeof (unsigned) * 2, &rval, sizeof (unsigned ));

In eMOS, a message is an arbitrary-length buffer. The sender uses eMOS_MsgSend to send a message, and the receiver uses eMOS_MsgReceive to receive a message. A task sending a message using eMOS_MsgSend waits until the receiver both receives the message and sends a reply using eMOS_MsgReply. The message passing calls are synchronous, and the calls do not return until the the functions are done. Internally, the kernel schedules tasks as needed, and tasks waiting for message processing are blocked and will not use up CPU time.

In the above example, MemManager is a normal eMOS task acting as a memory management server. It loops forever while waiting for messages to come in. Each message is a memory management request. The command code 0 is used to denote an allocation request, and 1 is for deallocation (the codes can be anything, as long as the sender and receiver agree on their meanings).
malloc and free send messages to MemManager to perform the actual memory allocation. If all memory requests go to this task, the internal data structures are automatically protected, because the server only processes one request at a time, and additional requests through eMOS_MsgSend are queued up by the kernel until the server task is able to process those requests.

Moreover, since it is not part of the kernel, MemManager can be replaced with other memory allocation algorithms, even if the source code for the kernel is not provided. This allows tailoring the most useful memory allocation scheme to a given scenario.

Using message passing has some overhead, but the tradeoffs are more robustness and better scalability. As more and more embedded systems are used in mission-critical situations, safety concerns must be high in the design goals of a system. For example, two potential nasty source of errors in an RTOS are race conditions and priority inversion (for example: priority inversion caused the Mars Pathfinder Rover to crash repeatedly, until an software patch was sent from Earth) and their chances of occurring are greatly reduced in a message-passing OS. (We will look at these issues, and more, in a future post.)

Continue reading
1371 Hits

New io2go Module Prototype Board

wifi2go is just the first of the many Internet of Things module that we have planned. This is the prototype of one of the next products. The MCU will be the STM32F746 216Mhz M7 MCU with DRAM, QuadSPI connected external flash etc.

*crack whips and start working*...

Continue reading
1093 Hits Reviews Our Book "C 4 Everyone"

Check it out!

Continue reading
1219 Hits

Customer Review of JumpStart Tools

Unedited from a new customer Wesley R:


I used arduino for quite a few years tinkering and building projects. Recently, I decided to take an idea out of the world of arduino and into the world of true embedded systems. I started my search for a simple way to create an embedded system that i could put into a commercial product. I found the answer and then some by using Jumpstart microbox from Imagecraft. I found Imagecraft originally by searching for a compiler to use with avr MCUs but after a month and a half of reading and looking at code. I was no closer to my goal of creating a commercial MCU. Then Richard at Imagecraft suggested i try their Jumpstart Microbox with the Jumpstart API.

After looking at a few examples, I knew this was going to be a much easier and faster way for me to get my code onto a micro controller. I ordered a Jumpstart Microbox kit, and it was at my door a few days later. The compiler I used was Imagecrafts Jumpstart C for Cortex M series micro controllers. I have very little experience with other Cortex-M C compilers, but I had their example programs running within 30 minutes. A 32 bit 84 MHz micro controller was under my control (a mechanical engineer with little c programming experience). The example code and documentation from Imagecraft was very easy to follow and understand.

I was able to use a 32 bit micro controller just like i would an arduino. I couldn't be more impressed with this product. If you are interested in making a commercial product or learning more about micro controllers, and you want or need to use a powerful micro controller. Jumpstart microbox is the answer period.  The last thing and probably the best thing about this product is the customer service. The guys at Imagecraft would answer any question i had within minutes no kidding. They even answered questions i didn't know i would need to ask. Excellent job Imagecraft.

Continue reading
1043 Hits

216 MHz MCU

Well, how times have changed. I remember Digital Equipment Corp. had a major celebration when we released the DEC Alpha "EV4" running at 200MHz. This sounds kind of slow when PC processors are now running at a few GIGA-Hertz, but at that time, the competitors' CPUs were chugging along at ... 60MHz or so. The DEC teams used all the tricks they had to achieve that. The price of that processor were in the multi-thousands.

And now we have the STM32F746 MCU, with so many GPIOs, Timers, and plethora of peripherals, all for about $10:


p.s. this is from porting the JumpStart API to the F7xx series. The demo is done with just a few lines of JumpStart API code, vs. pages of code using ST's HAL library.


Continue reading
1060 Hits