Jan, sorry for the debugger issue - it sounds like the debug info is stale: the installer should have removed the object and debug files so that it will do a Build before debugging and syncing the source code with the debug info file, but that does not appear to be the case. I will look into it. You should be able to do a Project->Rebuild and get everything syncs up.

re: low level details of I2C etc.: indeed, that's the whole purpose of the JumpStart API - to abstract away (some of) the low level details. Lets take I2c as an example. The actual I2C protocol is relatively simple, if you know how to toggle a square wave, that's the clock (SCL). Toggling another line and you have data (SDA). Do it with the right timing and sequence and there's your I2C. The problem is that with the complex 32-bit Cortex-M devices, it's no longer trivial to toggle a GPIO pin. You have to enable power to the correct bus, for a particular pin, set its mode to output, set open drain or push-pull (for I2C, it should be open drain), set the output speed, set the optional pull-up or pull-down resistor, and all that before you have to figure out how to generate the correct timing.

Or you can use the built-in I2C subsystem. Great! Except that to use the vendor library, you have to initialize a created structure with fields correspond to the IO register bits. So you end up having to look into the manual for details. Note that they don't bring enlightenment on how the I2C works or anything, it's simply a particular vendor's implementation of the I2C. For example, on the STM32F030, you can set up the subsystem to do "autoend". Wonderful, so you look at STM32F401, and behold, it has a completely different I2C implementation. There is no autoend, but arguably it's a more flexible implementation. So writing I2C on these two chips require completely different sequences of instructions. And these are from the same chip vendor, imagine you then move on to NXP LPC series. Writing I2C on top of them is basically making sure that you fully understand the manuals.

As I noted in one of my responses to the "Preview" article - our primary target audience is in fact professional engineers. Bit-banging I2C is no fun and it's not a whole lot of fun either to fight with the MCU's I2C subsystem. What they want and need are working I2C code so that they can work on their applications at hand. I2C, or any other low level protocols are for solving application programming and should not be the problem by themselves.

Again, JumpStart API does not preclude you from bit banging I2C or use the vendor supplied library. However, if your goal is to write a program to talk to an I2C device in as short a time as possible, JumpStart API is the solution.

Take another example: system clock set up. On every STM32F device's reference manual, there is a "clock tree" diagram. It's non-trivial to see which clock to use, and with all the prescalars and dividers, it's hard to find all the parameters to the PLL variables (some STM32F devices have 2 PLL "variables" and some have as many as 4). Indeed, ST's CubeMX is a valuable tool to see which path a clock may take and to calculate the correct values for PLLQ, PLLN, and so on.

Well, with our next release of the compiler, to be available by end of Nov 6, 2015, JumpStart API also supports the STM32F4xx series and adds a new clock call:

    _Bool JSAPI_CLOCK::SetSystemClock(unsigned hsi_mhz, unsigned hse_mhz, _Bool hse_bypass, unsigned pll_mhz, unsigned flash_ws);

You specify the HSI frequency, the optional HSE frequency, if you use an external OsC, and the desired PLL speed (plus a couple other parameters), and the function does all the calculations for you. Does it do everything you possibly want to do with the clock setup? Just like the I2C API, the answer is no. However, for most people, they just want to write "jsapi_clock.SetSystemClock(16, 0, false, 84, 5);" and have their F401 buzzing at 84 Mhz.

The question is: what would you rather do? Spend times just to get the basic structure going, which is completely useless if you move on to a different chip, even from the same silicon vendor, or spend time writing your application? Again, if the answer is latter, then JumpStart API is for you.

Richard Man wrote:

 

The question is: what would you rather do? Spend times just to get the basic structure going, which is completely useless if you move on to a different chip, even from the same silicon vendor, or spend time writing your application? Again, if the answer is latter, then JumpStart API is for you.

Are those the only two choices? What about Energia, mbed, which make getting going with ARM microcontrollers extremely simple for beginners and hobbyists.

For commercial customers, there are cool tools like TI's PinMux to help set the registers,

and a wealth of peripheral driver code, all with source code.

Even with jumpstart, if you move to different silicon, you'll still need to spend time ensuring

the new microcontroller can support certain functions on certain pins, so you still need to

go through the microcontroller documentation.

With the same vendor usually the peripherals can be fairly similar, so it doesn't take

ages making the necessary tweaks if the manufacturer has not supplied driver code (which is unlikely) - and one gets to learn about the peripherals at the

same time, meaning one can make better use of them.

Jumpstart may be a great product, but it is unfair to imply there are only two choices here

when there is plenty of code from manufacturers to make life easier - no need to work

just from the datasheet to get the basic structure going as you say.

Is source code available for Jumpstart? I'm still not clear.

Also need to emphasize again that our primary focus are professional engineers who want to get into Cortex-M development. mbed is not a serious solution, definitely not for production deployment. For the past few years, you are primarily down to 2 main choices - there are a few other choices of course, but almost certainly a majority of any commercial Cortex-M development have been done with these two groups:

1. GCC/Eclipse
2. IAR/Keil

Each has strengths and weaknesses, but clearly between "GCC - even if it's not free!" and "IAR/Keil even at $7000+ is quite OK", there is a market niche there. This is where we come in. We offer easy-to-use professional tools at reasonable / affordable prices, and we back them up with unparalleled support. The JumpStart API is an icing on the cake, so to speak.

I thought the review was about the "non-commercial, educational license" offering, in which case it is fair to compare with mbed.

However, in my comment I specifically separated energia and mbed from commercial customers, who as mentioned can still use supplied source code from the manufacturer or the tools or autogenerated code, and therefore do not need to delve into the microcontroller manual intensively except for general pin information or to understand what the peripheral modules can do.

But I take your point, this is only examining the jumpstart API specifically which may not be the core part of the offering.

Aside from pricing, and the differences aren't that big (NC license is $99, and commercial licenses start at $249- the MicroBox is an all-in-one special deal), there is no substantial difference between the STD and NC license. So anyone, including an hobbyist, can start with the $99 license or the MicroBox kit, develop a widget and decide to go commercial with it, without then breaking the bank.

The MicroBox is particular attractive for (US/Canada based) educational institutions whereas they can purchase the entire kit from us, without getting hardware from one place, then software from another, and then having to integrate them together and having to write their own examples. I understand that the "teaching kit" may not be popular in Europe, but it is a big market in US/Canada, and from what I understand, Korea and Japan as well. Indeed, we will be releasing internationalized versions of the IDE within the next 2 months, to satisfy the Asian markets.

Hi Richard,

I'm looking for the benefits for a hobbyist or a beginner or students (non-commercial use license) compared to the other options such as a dev board and a free IDE such as Energia, mbed or a free C compiler.

Hopefully they will become clear as the review unfolds. But certainly other options are very compelling too (e.g. a development board and a free IDE and compiler). The institution at which I studied used an off-the-shelf development board from a microcontroller manufacturer, and it worked well enough for us to get jobs in engineering.

Hi Shabaz, it really comes down to how comfortable and how much time a particular department or school wants to devote time in setting things up. "Before us", obviously institutions have been doing fine teaching embedded system courses too. What we offer for them is the complete package aspect: hardware, software, C ebook, example programs - everything. $100 kit is in line of prices I see institutions charge students for these types of courses. In US/Canada, usually a faculty member asks a lab TA to work with the IT department to set up the hardware and software. They want to be able to use the same materials years after years, and having a commercial vendor to support them is important. For example, a lot of schools still use the CPU12 boards. For them, they would get a board from company X, the BDM pod from company Y, and then sometimes use our compiler, or use assembler (GCC for HC12 really isn't a good option), or some "good deals" from expensive compiler companies. With JumpStart MicroBox, places like that can transition to 32-bit MCU easily. If your school has the right resource already, then our product may be not for you, but if you consider all the time and resource to manage different vendors or getting stuff from open source sources, it may still be worth it.

Hi Shabaz, it really comes down to how comfortable and how much time a particular department or school wants to devote time in setting things up. "Before us", obviously institutions have been doing fine teaching embedded system courses too. What we offer for them is the complete package aspect: hardware, software, C ebook, example programs - everything. $100 kit is in line of prices I see institutions charge students for these types of courses. In US/Canada, usually a faculty member asks a lab TA to work with the IT department to set up the hardware and software. They want to be able to use the same materials years after years, and having a commercial vendor to support them is important. For example, a lot of schools still use the CPU12 boards. For them, they would get a board from company X, the BDM pod from company Y, and then sometimes use our compiler, or use assembler (GCC for HC12 really isn't a good option), or some "good deals" from expensive compiler companies. With JumpStart MicroBox, places like that can transition to 32-bit MCU easily. If your school has the right resource already, then our product may be not for you, but if you consider all the time and resource to manage different vendors or getting stuff from open source sources, it may still be worth it.

I should add that for a hobbyist wanting to learn things by themselves, then similar reasoning applies. Of course, there are reasons to just get a $10 or even below dev board and download GCC/Energia/mbed/CoCox and have a go. Certainly the price is right. OTOH, what I mentioned previously still apply. Everything is there in our kits, and there is starting with a simplified environment but then having to move to a more powerful environment/language later on. You can use our tools first just toggling an LED, or to commercial widgets.

BTW, I can disclose that more kits are forthcoming, for the "Internet of Things" thing. So the MicroBox is just one step toward that direction.

Well, let's see how the review goes. It still seems excessive to me to spend $99 when one could purchase a dev-board for a fraction of that cost and rely on online resources (there is a C course on this site for free) - or even purchase a book for that price.

BTW, are you aware that it also comes with the ACE (Arduino Compatible Education) Shield? It has a 8x8 LED matrix, a 2-line graphic/text OLED, a RTC, a SD-card, audio op-amp, thermistor and light light sensor. As for prices, yes, some hobbyists will find it too high a price. We do not aim to compete with the lowest price possible. Good luck.

Hi Richard, yes, I'm aware.

I hope you compete on value - but at $99 minus the cost of a good dev-board (some of which do have on-board input and output devices like LCD displays and buttons), there are some _excellent_ books on programming and free tools that are not as hard to get into as it is implied. And some great online resources for free.

I'm looking forward to seeing the review - that may clear things up for me regarding value.