Thank you all for backing the AshimaCore project!
As we progress through to getting the boards and flyers shipped in July, we will keep everyone in-the-loop via the "Updates" tab on this page.
If you missed out on the Kickstarter and want to get hold of an AshimaCore board or flyer, check out our (stiil in development!) product website at http://polyhelo.com
Since we're now funded, we've added the following stretch goals:
1. We've had a lot of comments about the power board, so our first stretch goal at $7k is to use the same components and basic design as our current AshimaCore power board but to package them into a tiny single channel power board that we'll completely open source (board layout, schematic and BOM). We've already met this stretch goal, so the board will be designed as soon as the first "prototype production" run is sent off to be printed. Thanks for your continued support!
2. We continue to use the AQ32Plus code to obvious great effect! Our second stretch goal at $10k will be to dedicate time to use our experience with Kalman filters to assimilate and model spacecraft data to build an effective height hold for the AQ32Plus code.
AshimaCore is a flight control system for multi-rotor flyers, although it can also moonlight for any robotics or sensing projects which need an IMU, wireless, and µSD, running on a microcontroller that is over ten times as fast as your typical Arduino. Based on a STM32F4xx processor, AshimaCore is ready to be programmed with any of the increasing number of open source multi-rotor projects which have chosen this 168MHz processor as the replacement for Arduino.
Here are some things we wanted and thought you might want as well:
- a more powerful board than Arduino which can run many different open source RC multi-rotor software projects
- many wireless communication options (e.g. WiFi, Bluetooth, XBee) so that you’re not limited to RC twin-sticks systems
- 10 degrees-of-freedom sensing on one board
- room for additional sensors to be added, like GPS and range finders
By default, the boards and quadcopter kits for the various pledge levels will ship with the open source AQ32Plus flight software as used in the video, above. They can easily be reprogrammed.
What’s different about AshimaCore?
More and more people are finding that Arduinos are too slow for the multi-rotor software they want to write. Many are finding that ARM Cortex-M4F processors provide the needed speed and peripherals to take things to the next level. Unfortunately, the boards people have made so far have run into a few catches:
- some of the sensors chosen are in short supply, keeping boards out of stock
- each board tends to be developed with only one software package in mind
- most boards cost closer to $200 or $300
AshimaCore is not tied to any particular multi-rotor software, uses sensors that are in plentiful supply, and costs $99. We made it as compact as we could, while still providing plenty of options for expansion.
We want your help in getting this flight board out to the multi-rotor community. Our goal is a controller that is affordable, easy to get hold of, and is compatible with a range of open source flight software packages. We want to give you everything needed to start flying with 32-bit power and stability in an affordable and compact package.
- main board - 64mm x 35mm; 15g; 3.3v in (5v tolerant I/O)
- power board - 27 mm x 35 mm; 7g; 6-20v in / 3.3v and 5v out
On the board
We picked the STM32F405/7VG because it is a really good, all-round chip. We wanted an ARM Cortex-M4F because of the support and the well-proven nature of the architecture. The STM32F belongs to a family of well-supported chips from ST that share common peripherals and interfaces. This is important for future-proofing and for continued growth of the development community. A feature that particularly caught our eye with the STM32F4 is the unerasable bootloader that ships preprogrammed on the chip. It uses standard firmware updating protocols and ensures that you can never "brick" the chip!
Specs: 168 MHz 32-bit Cortex-M4F (FPU); 1Mb Flash; 192K SRAM; 5v tolerant I/O; 14 timers; CRC and RNG units; 96 bit unique ID; RTC calendar; I2C, SPI, USART I/O; USB; 3 ADC, 1 DAC
- IMU Sensors
The MPU-9150 collocates and co-aligns a 3 axis accelerometer, 3 axis gyro, and a 3 axis magnetometer in a very small package. We chose the 9150 as there is nothing else like it on the market. High quality sensors that are tightly co-located allow for measurements at effectively the same location, which is a significant advantage for applications where precise pose estimation is important. You can read the sensors individually and do your own pose estimation (as we do) or you can use the MPU-9150's embedded digital motion fusion processor.
We've taken great care to place the IMU at the center of the board mounting holes. This is done to make it easy to align the IMU with whatever you're mounting it on.
The board also includes a pressure sensor for altitude estimation. We chose a BMP180: a widely used, ultra low power sensor that is easy to source. The board also comes ready to accept a MS5611 (for when this part becomes more readily available).
- Support Components
We put a few other support features on the board. We have a high-speed 4-bit SDIO micro-SD card slot for logging. We've put 8 Kbytes of EEPROM on the board. For testing and quick board state assessment, we included 3 user and 4 status LEDs. Finally, who needs buzzers when you have a 1W audio amp?
We originally designed this board to be the avionics for flying vehicles. This necessitates radio communications, which is supported through XBee compatible modules. You can even reprogram via these modules, though normally we'd program through the USB. Communication with other on- or off-board devices is supported by various standard bus interfaces. We have designed AshimaCore to use WiFi or ZigBee wireless protocols and I2C or SPI-controlled ESCs, but the board can also support the standard PWM in and out used by most hobbyist quadcopters today, including standard RC receivers.
- Radio: XBee module port
The board's XBee header supports various communications modules including the XBee's WiFi (802.11g/n), ZigBee (802.15), and Pro 900 (with 15 mile range!) modules, and XBee-compatible Bluetooth modules. For the XBee WiFi, we're ready to do up to 3.5 Mbps via SPI.
- Wired Interfaces
The USB interface is broken-out via the power board specifically to allow development and programming. Additionally, standard 0.1 inch headers break-out a combination of 1 I2C, 2 SPI, and 4 UARTS that can be wired for communications.
- Digital Control
We believe that the right way to control ESCs, servos, etc. is via a digital bus. This allows for more accurate timing, better noise immunity, and is easier to program. We also get feedback such as motor speeds and health status. The board breaks-out I2C, SPI, and USART buses. Digital control is our preferred method for in-house projects - in fact, we've already prototyped our digital ESC and will release it in the near future.
- Analog Control
A major change from the prototype to the production board has been the breaking-out of 4 dedicated PWM channels in addition to the 13 other PWM channels that are shared with various other functions. This was done to make it easier to directly support older and more common PWM-based ESCs and servos.
There is also a 1 W DAC output and 5 ADC input for monitoring analog sensors, batteries, etc.
Power and Programming Board
The STM32F4 is supported by most of the major commercial embedded-processor developer toolchains. This is great, but not necessarily what you're looking for as an individual or small company developer. In fact, this has been one of the biggest negatives for the Cortex-M4F's.
Excellent open-source support for the Cortex-M4F exists in the gcc ARM compiler and the newlib standard c library, but we found the STM32's peripheral library options lacking. In the pursuit of more robust and easier to use code, we decided to build our own peripheral library and release it under a friendly open source license.
The foundations of the free, open source library are available on our github repository. And we're committed to building these out further: We need them for our own projects anyway! We've added the minimum necessary components to allow you to use the freely available compilers to build projects using the STM32F4 and MPU-9150 and we're adding more all the time: We are currently extending support for peripherals already on the board (e.g. CAN, crypto unit, I2S), support for other sensors that one can attach to the I2C or SPI bus, and adding targets for other STM chips such as the STM32F050.
Together, the AshimaCore and the open source dev environment provides a great learning environment for embedded programming and hardware control with ARM chips, especially for applications involving pose estimation and vehicle control.
Goal for Future Board Availability
One of the major issues with new control boards is that they tend to have limited and unpredictable availability. This inhibits development and uptake. Thus one of the goals for this Kickstarter is to demonstrate to electronics / hobby retailers that there is demand for this kind of board and get the board into the wider, mass-produced market.
This project began with our interest in platforms for image and scene reconstruction, and that brought us to working on small, multi-rotor flight systems (amongst other things). We also have a background in developing climate sensors and control systems for instruments bound for Mars. We will come back to this later.
We began exploring multi-rotor flight control systems using processors in the 8-bit ATmega family via the usual Arduino pathway (below is some onboard footage from a GoPro mounted on our old ATmega-based quadcopter). These boards are just about fast enough to do an approximate form of orientation state estimation and motor control. But only barely. We were able to use our ATmega-based quadcopter for testing camera systems and flight behaviors, but there is no getting around the fact that these systems require a fair amount of RC piloting skill. For many applications, such as aerial photography, and for a wide range of potential users, the hobby of actually flying the platforms is not the main goal. Fully and semi-automated stable flight is much more desirable in these cases.
It is widely recognized that the limitation on stable and automated flight behavior has been the slower 8-bit chips. This has prompted a recent move towards ARM embedded chips across the multi-rotor community.
The other significant problem we found with extant control boards is that they use analog means of communicating both with their ESCs and their radio receivers. This ends up being both resource-hungry and introduces noise into the end-to-end control system. For our projects, we have addressed this problem by building all-digital ESCs and using Wifi for communications.
As we migrated to the ARM processors, we found there was no board available that was time or cost effective for us to use on our projects. As we developed our own ARM / IMU avionics board, we quickly realized that it would be of wider use, especially if we built in some analog backward compatibility. That's where the AshimaCore and this Kickstarter project were born.
P.S. So you might now be wondering where Mars climate instrumentation comes into all of this. The team that now makes up Ashima formerly constituted a research group at Caltech. There we worked on instruments for Mars landers with JPL and NASA. By design these instruments needed to be semi-automonous and use a wide range of sensors. Some parts of these systems ultimately made it to Mars on the Curiosity rover (but that's an even longer and entirely more complex story).
The design of the prototype boards (the main and power boards, pictured at page top) were completed in January, with the printed boards arriving in February. We have documented some of this on the Ashima Devices' blog. The prototype boards were assembled and tested back in March. As can been seen in the images, the prototype boards are fully-populated production-quality PCBs. The changes from this prototype board to the production board included exposing more analog I/O, adding the 1W amp and EEPROM, and accommodating a future MS5611 pressure sensor.
Most recently, we have been working on the software to support this board. You can follow and contribute on our github repository.
What Happens After We're Funded
There are a number of stages left in the project before shipping. It should be noted that the following steps overlap and that the total time to shipping should be closer to two months. Here's a quick break-down:
1. Finalize and test the production board (4-6 weeks). This involves printing new PCB's, hand assembly, and system testing.
2. Production run, including automated assembly (4 weeks). This involves interacting and resolving issues with the automated assembly vendor, sourcing all of the various components, and taking delivery of the final products.
3. Quality control, testing, and shipping (4 weeks). Each board will be booted up with a standard test program before it is shipped.
Risks and challenges
We have already completed two loops of prototype development. This gives us confidence in design and the manufacturing process. However, there remain risks in this project. The risks can best be illustrated by examining our development schedule (above).
The risk in stage (1) is that we may need to make more than one prototype to fix errors. We think this risk is relatively small given the prototypes that we have already developed.
The risks in stage (2) are that some of the items may have longer lead times than we currently expect, or that there are problems with the assembly process that require modifications of the board. We have already communicated with our chosen automated assembly vendor and see no problems at this time.
Stage (3) reveals yield fraction problems (i.e. how many boards that are made are lemons due to bad components, mis-assembly, etc.) This problem impacts all manufacturing of electrical components. It is the highest risk element for this project as it relies on external vendors and is the only stage that the prototype has not gone through in development. We have mitigated this by interacting with our chosen vendor and by modifying design and component selection based upon their advice.Learn about accountability on Kickstarter
- (33 days)