A prototype is a preliminary model of something. Projects that offer physical products need to show backers documentation of a working prototype. This gallery features photos, videos, and other visual documentation that will give backers a sense of what’s been accomplished so far and what’s left to do. Though the development process can vary for each project, these are the stages we typically see:
Proof of Concept
Explorations that test ideas and functionality.
Demonstrates the functionality of the final product, but looks different.
Looks like the final product, but is not functional.
Appearance and function match the final product, but is made with different manufacturing methods.
Appearance, function, and manufacturing methods match the final product.
CortexProg - the best value in Cortex-M programming and debugging
Tired of paying too much for microcontroller flashing and debugging solutions, having to split money between projects and devtools, proprietary tools that become difficult to automate and update? You need CortexProg!
CortexProg is a debugger for Cortex-M microcontrollers. It can serve as the only tool needed
to reverse-engineer devices, create new designs, debug prototypes, program boards on production
lines, or general for-fun hacking on devboards. CortexProg can read data from a microcontroller,
write data into it, program flash, provide live tracing for printf-style debugging
(ZeroWireTrace), and even allow complete GDB debugging. The PC-side tool uses the HID
transport to not need any drivers on any of the supported OSs: Linux, Windows, MacOS. The tool
source is also available, so you can build yourself a copy for whatever other esoteric
environment you might desire to run it on. CortexProg is the complete solution for all your
ARM Cortex-M debuggng and programming needs.
ZeroWireTrace allows you to output text from your target device without needing any additional wires or peripherals. No need for UARTS, SWO pins, or anything else. Using ZeroWireTrace is incredibly simple - it only requires three lines of code. This is wonderful for pin-limited or space-limited devices where extra connection points are simply not available.
Gang-loading support is built-in with CortexProg. Each device has a unique serial number and the PC-side CortexProg tool can simultaneously talk to as many devices as desired, issuing them individual instructions. This makes CortexProg very convenient for collecting data from many devices at the same time or mass-programming the entire first run of you prototypes in parallel.
Firmware updates on CortexProg will be used to add new features and improvements.
Multi-core chip support on CortexProg allows you to debug multiple cores in chips that have them, making development on such chips a breeze!
Plugin-based chip support No software or firmware update is required for support of any new or previously-unsupported cortex chip. Adding support is easy thanks to our documentation and sharing is not only recommended, it's encouraged. Community based scripts will be shared through our website on the downloads page.You can see the list of currently-supported chips here, and with you generous support, more will come soon.
LUA-based scripting of every aspect of the debugger for all those complex custom tasks you may want to accomplish. For example: unlocking security-locked chips, reverse engineering, and custom factory flows.
And much more. Of course, all the things you'd expect of a Cortex-M debugger are present as well: ability to set breakpoints and watchpoints, read and write RAM, program and erase flash, trace execution, etc.
Best choice for hobbyists
Compared to JLINK or ULINK, CortexProg is undoubtedly a better solution. It is significantly cheaper, while providing all the same functionality. It is in fact so cheap, that you can leave one attached to every project you have in progress, to every breadboard, to every prototype, and not even approach the cost of a single JLINK or ULINK device. Additionally, CortexProg has a few unique features like ZeroWireTrace.
Compared to the manufacturer-provided tools for various microcontrollers, CortexProg comes out ahead as well. Not only does it support any chip, but, it also comes loaded with plenty of useful options like real debugging support and gang-loading abilities.
Best choice for startups
Smart devices and IoT are the latest craze, but why waste the limited money supply on overly-expensive tools? Choose CortexProg and enjoy a much better value. You can use CortexProg from the very first dev board all the way to your production run. It is versatile and convenient.
"The CortexProg has given us a real edge on traditional flashing devices with respect to easy and straightforward programming. Where cost was prohibitive and tools such as the STLink were too error prone, the CortexProg allowed us to scale from a handful of boards to the hundreds with ease. The gang-load support has become a welcome feature as our startup has grown and the ability to power our device externally has been ideal for CI/CD power testing. Highly recommended.
Officially announced in 2004, Cortex-M3 became popular in various devkits by 2011. It was soon followed by the much-cheaper, yet still highly efficient Cortex-M0. Much faster than devices like AVRs and PICs, they were programmable purely in C and required no assembly or weird tricks. They were supported by GCC, thus not requiring expensive proprietary compilers. There was only one weakness: each manufacturer came up with their own method for flashing and debugging. There was no standardization. This passed muster for devkits, but hobbyists making their own board quickly lost track of all the different devices they needed for one project.
The Generic Cortex-M debugger
Two products were created with the capability to debug multiple Cortex-M chips: JLINK and ULINK. Both cost upwards of $1,000 USD and were marketed towards large companies developing hardware with Cortex-M chips. While cheaper version were eventually offered, they were still $200 USD or more. It was time for a more accessible solution.
2014: CortexProg is born
The CortexProg started with this challenge – how to build a generic Cortex-M debugger only out of components that any hobbyist would already have, on a perforated board. The actual protocol used to talk to the ARM Cortex-M core is documented by ARM. The task at hand was to implement it in a correct and performant manner.
The very first CortexProg prototype was implemented on an AVR ATTiny85 using the ModulaR bootloader. This provided for a HID-based communications protocol to the PC and easy firmware updates to support further development. It could only debug 3.3V targets, and rather slowly at that. With a blazing upload speed of 800 bytes per second, on a good day, the CortexProg prototype served a very important function. It proved that an inexpensive device was possible. In fact, to commemorate this first attempt, the design and all the PC-side tools are still supported, so that any enthusiast could build one themselves.
While the prototype served as proof of concept, it was not yet a practical solution to the problem. It needed higher speed, more features and a real PCB. Each successive version of the CortexProg was programmed and debugged with its predecessor. Here is the first ARM-based CortexProg: the v0. Today a few v0 devices are around. They are supported by all the tools and firmware updates are still provided.
Each iteration on the design added essential features. CortexProg v1 increased the speed three-fold. CortexProg v2 allowed for the debugging of targets with variable voltages and gave the option to supply 3.3 V to the target. Additionally, v2 included a built-in CDC serial functionality for easier data input/output to the target device.
CortexProg v3 included the ability to supply variable voltages to the target up to 2.4 V, at currents up to 350mA.
CortexProg v4 perfected the design by opening up the range of the supplied voltages to 0.7V - 3.3V, making the device usable for every potential target. As a bonus it now supports the debugging of multi-core chips and SWD clock speed control.
CortexProg v4 is what this Kickstarter page is all about. What's after that? You decide. We're happy to hear your suggestions. Send them to firstname.lastname@example.org.
Risks and challenges
With a bit of support from you to cover the initial manufacturing costs, CortexProg can become the go-to solution for Cortex-M debugging.
CortexProg itself will be used to mass-flash the firmware to the boards.