The design goal of the JumpStart API (Application Programming Interface) is to make it simple to access the peripherals of the microcontroller without sacrificing the power specific to each vendor’s hardware product. Thus, the JumpStart API is not a generic API common to all target devices, but rather a set of library files and header files designed to be specific to each device or device family. You can find the JumpStart API specifications document here. JumpStart API is currently available for the STM32F0xx, and STM32F4xx series.

In thinking abut how best to address the issues of the complexity of the new Cortex-M devices, we found existing solutions from other vendors to be unsatisfactory:

  • The mbed platform abstracts too much; it removes the full power of the underlying hardware from availability to users. mbed also relies on a cloud compiler, which engineers cannot rely on for production. Exporting an mbed project to be used by a local toolchain again brings up the decision of which traditional toolchain to use.
  • The Arduino software environment is too simple for "power users".
  • The ST CubeMX and other vendors' visual tools target only their own device offerings, are too complex to use, and do not solve the problem of programming the device beyond the initialization code.
  • Other vendors offer Board Support Packages (BSP) which mainly address the issues of setting up the memory map and initialization issues, but again; they do not solve the problem of programming the device beyond the initialization code. Additionally, they are useless for hardware designers who prefer to design their own boards.

ImageCraft's solution is the JumpStart API. It is a C/C++ based API which does not prevent the users from accessing the full power of the underlying hardware, and its benefits extend beyond the initialization code. Our beta testers discovered that they could get started on application programming in minutes, rather than taking multiple days to get familiar with the ST StdPeriphLib code. Moreover, the JumpStart API continues to be useful when writing application code, making the whole program easier to write and maintain.

Read an industry expert's evaluation of the JumpStart API on "Nuts and Volts" here.

This is the same design principle behind modular and library coding. For example, imagine if you had to write your own output format routines all the time, instead of just being able to use printf!

The JumpStart API is part of the JumpStart C for Cortex-M Compiler Tools. Purchase JumpStart C forCortex-M Online.


The JumpStart API makes it very easy to get started on programming the Cortex-M devices. Unlike the simpler microcontrollers, such as the Atmel AVR, Cortex-M devices are normally more difficult to get started on; because while the Cortex-M cores and vendors' peripherals provide more power, they are also much more complex to set up. For example, on the STM32F030, to enable external interrupt on a pin, you would have to:

  1. Initialize the system clock.
  2. Enable power to the GPIO port.
  3. Configure the GPIO port pin as input.
  4. Enable power to the EXTI (External Interrupt) subsystem.
  5. Enable power to the SYSCFG subsystem in order to modify the EXTI configurations.
  6. Configure the EXTI to trigger on the specific GPIO port and pin.
  7. Configure the NVIC (Nested Vector Interrupt Controller) to enable interrupt for the EXTI.
  8. Write an interrupt handler, as EXTI interrupts are shared, be sure to process only the interrupt that is for this EXTI.
  9. Modify the system vector table to call the interrupt handler.

This takes a few pages of code, as well as much reading of the data sheet and reference manual to get the details correct. -- OR! You can simply use the JumpStart API!

The following is a complete program for the JumpStart MicroBox, with an STM32F030 that prints out dots '.' on a terminal program's output window, and interrupts on user button pushes, displaying '1', '2', or 'x' depending on which button is pushed, including taking care of debouncing the button. All of this is done with just a few function calls.

The JumpStart API (note the "#include <jsapi.h>", below) does the low-level work, so that you can concentrate on writing programs which use the microcontroller's features, instead of fighting with the microcontroller just to enable them.

Some comments from customers:

"JumpStart API allows you to focus on the application coding and not ARM coding. In a few minutes I had a configured and working skeleton for my hardware." --  Mark Barber

[On looking at JumpStart API] "Your stuff is great; by God, somebody can code old school in your organization!" -- Randall Young

 

Sample Code

Compare the following code to similar ones presented here: http://www.hertaville.com/external-interrupts-on-the-stm32f0.html You can see the JumpStart API simplifies globs of code (a technical term :-) ) to just a few lines.

/*
*
*/
#include <stdio.h>
#include <jsapi.h>

// Hardware setup and initialization
static void Setup(void);

void SW2_closed(void)
{
putchar('2');
exti4.Debounce();
}

void SWx_closed(void)
{
putchar('x');
exti13.Debounce();
}

void SW1_closed(void)
{
putchar('1');
exti0.Debounce();
}

int main(void)
{
Setup();

exti4.MakeEXTI(&porta, PUPDR_UP, EXTI_FALLING_EDGE, 0, SW2_closed);
exti0.MakeEXTI(&portc, PUPDR_UP, EXTI_FALLING_EDGE, 0, SW1_closed);
exti13.MakeEXTI(&portc, PUPDR_UP, EXTI_FALLING_EDGE, 0, SWx_closed);

while (1)
{
putchar('.');
DelaySecs(2);
}
return 0;
}

int putchar(unsigned char ch)
{
if (ch == '\n')
usart2.putchar('\r');
usart2.putchar(ch);
return ch;
}

int getchar(void)
{
return usart2.getchar();
}

static void Setup(void)
{
jsapi_clock.SystemInit(48);
jsapi_cortex_core.SysTick_Timer(SYSTICK_MILLISECOND);

usart2.SetPins(&porta, 2, 1, &porta, 3, 1);
usart2.MakeUSART(9600, 8, 1, true);

printf("\r\nImageCraft JumpStart MicroBox... System running at %dMhz\n", jsapi_clock.GetSysClkFreq() / 1000000);
}