Nigan tipped us to a simple open source Bluetooth stack for embedded devices, the SmallTooth:
A newly developed open source Bluetooth stack for PIC32/24 * The code is really easy to understand, very well documented and really small. * Designed to be extended and ported. * Works straight out of the box with the PIC32 USB Starter Kit II and should be fairly simple to port to other PIC32 or PIC24 boards.
The camera, in this case the one from an iPhone 6, is mounted to an off-the-shelf robot chassis that tools around on a pair of DC motors. The camera mount uses a stepper motor to get just the right shot. A PIC32 on board the ‘bot takes Bluetooth commands from an iOS app that the team built. The dolly works two ways: it can be controlled manually in free mode, or it can follow a predetermined path at a set speed for a specified time in programmed mode.
Our favorite part of the build? The camera’s view is fed to a smart watch where [Ope] and his team can take still pictures using the watch-side interface. Check it out after the break, and stick around for a short time-lapse demo. We’ve featured a couple of dolly builds over the years. Here’s a more traditional dolly that rides a pair of malleable tubes.
On paper, bicycling is an excellent form of transportation. Not only are there some obvious health benefits, the impact on the environment is much less than anything not directly powered by a human. But let’s face it: riding a bike can be quite scary in practice, especially along the same roads as cars and trucks. It’s hard to analyze the possible threats looming behind you without a pair of eyes in the back of your head.
[Claire Chen] and [Mark Zhao] have come up with the next best thing—bike sonar. It’s a two-part system that takes information from an ultrasonic rangefinder and uses it to create sound-localized pings in a rider’s ears. The rangefinder is attached to a servo mounted on the seat post. It sweeps back and forth to detect objects within 4 meters, and this information is displayed radar-sweep-style graphic on a TFT screen via a PIC32.
Though the graphic display looks awesome, it’s slow feedback and a bit dangerous to have to look down all the time — the audio feedback is by far the most useful. The bike-side circuits sends angle and distance data over 2.4GHz to another PIC mounted on a helmet. This PIC uses sound localization to create a ping noise that matches the distance and location of whatever is on your tail. The ping volume is relative to the distance of the object, and you just plug headphones into the audio jack to hear them. Bunny-hop your way past the break to check it out.
Back problems are some of the most common injuries among office workers and other jobs of a white-collar nature. These are injuries that develop over a long period of time and are often caused by poor posture or bad ergonomics. Some of the electrical engineering students at Cornell recognized this problem and used their senior design project to address this issue. [Rohit Jha], [Amanda Pustis], and [Erissa Irani] designed and built a posture correcting device that alerts the wearer whenever their spine isn’t in the ideal position.
The device fits into a tight-fitting shirt. The sensor itself is a flex sensor from Sparkfun which can detect deflections. This data is then read by a PIC32 microcontroller. Feedback for the wearer is done by a vibration motor and a TFT display with a push button. Of course, they didn’t just wire everything up and call it a day; there was a lot of biology research that went into this. The students worked to determine the most ideal posture for a typical person, the best place to put the sensor, and the best type of feedback to send out for a comfortable user experience.
We’re always excited to see the senior design projects from university students. They often push the boundaries of conventional thinking, and that’s exactly the skill that next generation of engineers will need. Be sure to check out the video of the project below, and if you want to see more of this semester’s other projects, we have you covered there too.
Every December and May the senior design projects from engineering schools start to roll in. Since the students aren’t yet encumbered with real-world detractors (like management) the projects are often exceptional, unique, and solve problems we never even thought we had. Such is the case with [Mark] and [Peter]’s senior design project: a pick and place machine that promises to solve all of life’s problems.
Of course we’ve seen pick-and-place machines before, but this one is different. Rather than identifying resistors and capacitors to set on a PCB, this machine is able to identify and sort candies. The robot — a version of the MeARM — has three degrees of freedom and a computer vision system to alert the arm as to what it’s picking up and where it should place it. A Raspberry Pi handles the computer vision and feeds data to a PIC32 which interfaces with the hardware.
One of the requirements for the senior design class was to keep the budget under $100, which they were able to accomplish using pre-built solutions wherever possible. Robot arms with dependable precision can’t even come close to that price restraint. But this project overcomes the lack of precision in the MeArm by using incremental correcting steps to reach proper alignment. This is covered in the video demo below.
Senior design classes are a great way to teach students how to integrate all of their knowledge into a final class, and the professors often include limits they might find in the real world (like the budget limit in this project). The requirement to thoroughly document the build process is also a lesson that more people could stand to learn. Senior design classes have attempted to solve a lot of life’s other problems, too; from autonomous vehicles to bartenders, there’s been a solution for almost every problem.
One way to get around limitations in computing resources is to throw more computers at the problem. That’s why even cheap consumer-grade computers and phones have multiple cores in them. In supercomputing, it is common to have lots of processors with sophisticated sharing mechanisms.
[Henk Verbeek] decided to take 80 inexpensive PIC32 chips and build his own cluster programmed in — of all things — BASIC. The devices talk to each other via I2C. His example application plots fractals on another PIC32-based computer that has a VGA output. You can see a video of the device in action, below.
The slave boards are simple and use wire jumpers to select a different address on the I2C bus. Each has a multi-color LED that shows when it is working on a task and when the task is complete. So from a blinking light perspective, the computer is a success.
One problem with setups like this is having an efficient way to communicate between processors. [Henk] found that I2C is the bottleneck. Even though he has 80 CPUs, he found the fractal program bogged down if you applied more than twelve processors to the job.
One nice thing about Hackaday is you never have to ask why you did something like this. The fact is, this probably isn’t very practical as a parallel supercomputer. But it is still an interesting and educational project and might be the most CPUs we’ve ever seen running BASIC together.
Wireless networks have been reduced to a component, for most of us. We fit a device, maybe an ESP8266 module or similar, and as if by magic a network exists. The underlying technology has been abstracted into the firmware of the device, and we never encounter it directly. This is no bad thing, because using wireless communication without having to worry about its mechanics gives us the freedom to get on with the rest of our work.
It is however interesting once in a while to take a look at the operation of a real wireless network, and [Alex Wong], [Brian Clark], and [Raghava Kumar] have given us a project with the opportunity to do just that. Their PIC Mesh university project is a distributed wireless mesh network using 2.4GHz NRF24L01 transceiver modules and PIC32 microcontrollers. They have it configured for demonstration purposes with a home automation system at the application layer, however it could be applied to many other applications.
The real value in this project is in its comprehensive but easy to read write-up of the kind you’d expect from a university project. The front page linked above has an overview of how the mesh works, but there are also pages taking us through the hardware, the networking software layer, and the home automation application layer. If you have ever wanted to understand a simple mesh networking system, this is a good place to start.
The PicBerry is a student final project by [Advitya], [Jeff], and [Danna] that takes a hybrid approach to creating a portable (and affordable) combination digital oscilloscope and function generator. It’s based on the Raspberry Pi, features an intuitive Python GUI, and can generate and measure simultaneously.
But wait! The Raspberry Pi is a capable little Linux machine, but meeting real-time deadlines isn’t its strong suit. That’s where the hybrid approach comes in. The Pi takes care of the user interface and other goodies, and a PIC32 over SPI is used for 1 MHz sampling and running a DAC at 500 kHz. The idea of combining them into PicBerry is to get the best of both worlds, with the Pi and PIC32 each doing what they are best at. The readings are sent in batches from the PIC32 to the Pi, where the plot is updated every 30 ms so that user does not perceive any visible lag.
The project documentation notes that improvements can be made, the speeds are a far cry from regular bench equipment, and the software lacks some typical features such as triggering, but overall not bad at all for under $50 of parts. In fact, there are hardly any components at all beyond the Raspberry Pi, the PIC32, and a MCP4822 digital-to-analog converter. A short demo video is embedded below.
[Mike] wanted to drive several SPI peripheral from a PIC32. He shows how much latency his conventional interrupt handlers were taking away from his main task. He needed something more efficient. So he created the SPI channels using DMA. He also made a video (see below) with a very clear explanation about why he did it and shows oscilloscope traces about how it all works.
Although the project is specific to the PIC32, the discussion about DMA applies to any computer with direct memory access. The only thing missing is the code. However, there are plenty of examples on the web you can look at, including a Microchip webinar.
DMA is a powerful technique, although it can be tricky to debug. Big computers have used it for ages for high performance I/O, like disk drives or displays. We’ve covered DMA for the ARM before. Not surprisingly around here, driving LEDs seems to be a common use case for DMA.