arm

375 Articles

Bike Lock Secures Car

April 11, 2020 by 13 Comments

[Buttim] loses his car a lot, which might sound a little bit like the plot from an early-00s movie, but he assures us that it’s a common enough thing. In a big city, and after several days of not driving one’s car, it can be possible to at least forget where you parked. There are a lot of ways of solving this problem, but the solution almost fell right into his lap: repurposing a lock from a bike share bicycle. (The build is in three parts: Part 2 and Part 3.)

These locks are loaded with features, like GPS, a cellular modem, accelerometers, and in this case, an ARM processor. It took a huge amount of work for [Buttim] to get anything to work on the device, but after using a vulnerability to dump the firmware and load his own code on the device, spending an enormous amount of time trying to figure out where all the circuit traces went through layers of insulation intended to harden the lock from humidity, and building his own Python-based programmer for it, he has basically free reign over the device.

To that end, once he figured out how it all worked, he put it to use in his car. The device functions as a GPS tracker and reports its location over the cellular network so it can’t become lost again. As a bonus, he was able to use the accelerometers to alert him if his car was moving without him knowing, so it turned into a theft deterrent as well. Besides that, though, his ability to get into the device’s firmware reminded us of a recent attempt to get access to an ARM platform.

Industrial Robot Given New Life And Controller

April 8, 2020 by 9 Comments

We all think we could use a third arm from time to time, but when we actually play this thought experiment out in our heads we’ll eventually come to the same hurdle [caltadaniel] found, which is a lack of a controller. His third arm isn’t just an idea, though. It’s a Yaskawa industrial robot that he was able to source for pretty cheap, but it was missing a few parts that he’s been slowly replacing.

The robot arm came without a controller or software, but also without any schematics of any kind, so the first step was reverse engineering the wiring diagram to get an idea of what was going on inside the arm. From there some drivers were built for the servos, but the key to all of it is the homemade controller. The inverse kinematics math was done in Python and runs on an industrial PC. Once it was finally all put together [caltadaniel] had a functioning robotic arm for any task he could think of.

Interestingly enough, while he shows the robot brushing his teeth for him, he also set it up to flip the switch of a useless machine that exists only to turn itself off. There’s something surreal about a massive industrial-sized robotic arm being used to turn on a $20 device which will switch itself back off instantly, but the absurdity is worth a watch.

Continue reading “Industrial Robot Given New Life And Controller” →

Breaking Into A Secure Facility: STM32 Flash

March 24, 2020 by 20 Comments

In a perfect world, everything would be open source. Our current world, on the other hand, has a lot of malicious actors and people willing to exploit trade secrets if given the opportunity, so chip manufacturers take a lot of measures to protect their customers’ products’ firmware. These methods aren’t perfect, though, as [zapb] shows while taking a deeper look into an STM microcontroller.

The STM32F0 and F1 chips rely on various methods of protecting their firmware. The F0 has its debug interface permanently switched off, but the F1 still allows users access to this interface. It uses flash memory read-out protection instead, which has its own set of vulnerabilities. By generating exceptions and exploiting the intended functions of the chip during those exceptions, memory values can be read out of the processor despite the memory read-out protection.

This is a very detailed breakdown of this specific attack on theses controllers, but it isn’t “perfect”. It requires physical access to the debug interface, plus [zapb] was only able to extract about 94% of the internal memory. That being said, while it would be in STM’s best interests to fix the issue, it’s not the worst attack we’ve ever seen on a piece of hardware.

Google’s Pigweed For ARM Development Is A Nice Surprise

March 21, 2020 by 25 Comments

Setting up an environment for Embedded Development was traditionally a pain and so vendors provide integrated development environments to help bridge the gap. Google has open-sourced their version of an embedded targeted environment designated as embedded-targeted libraries which they trademarked Pigweed.

Google trademarked Pigweed with the U.S. Patent and Trademark Office in February and it popped up on the Google Open Source Blog along with some details.

The repository contains what Google is calling modules but taking a better look reveals that it a little more than that. Packaged in a Python Virtual Environment is a number of tools including an ARM compiler, the clang-format tool and Python 3.8 interpreter which runs more than a few things. The modules that come with Pigweed assist developers by running micro-automations such as the pw_watch module that monitors files for change and triggers a build, test and even flash and debug on hardware. There is also a module that allows pre-submit checks such as linting and formatting.

Google still does not consider this offering production ready though from what we have seen so far, it is a great place for many to start experimenting with for their embedded development automation needs. Anyone tried it out yet?

If you have been inspired with the amazing powers of automation and want to dive in yourself, have a look at Software Development in BASH and Continuous Integration with Python.

 

Open-Source ARM Development Simplified

March 17, 2020 by 12 Comments

The ARM series of processors are an industry standard of sorts for a vast array of applications. Virtually anything requiring good power or heat management, or any embedded system which needs more computing power than an 8-bit microcontroller is a place where an ARM is likely found. While they do appear in various personal computers and laptops, [Pieter] felt that their documentation for embedded processors wasn’t quite as straightforward as it could be and created this development board which will hopefully help newbies to ARM learn the environment more easily.

Called the PX-HER0, it’s an ARM development board with an STM32 at its core and a small screen built in. The real work went in to the documentation for this board, though. Since it’s supposed to be a way to become more proficient in the platform, [Pieter] has gone to great lengths to make sure that all the hardware, software, and documentation are easily accessible. It also comes with the Command Line Interpreter (CLI) App which allows a user to operate the device in a Unix-like environment. The Arduino IDE is also available for use with some PX-HER0-specific examples.

[Pieter] has been around before, too. The CLI is based on work he did previously which gave an Arduino a Unix-like shell as well. Moving that to the STM32 is a useful tool to have for this board, and as a bonus everything is open source and available on his site including the hardware schematics and code.

Civilian RC Car Uses Lego NXT And Ada

March 14, 2020 by 4 Comments

Back in the last century, the US Department of Defense declared that Ada was going to be used everywhere and for everything. Books were published, schools build curriculum. Working programmers, however, filled out waivers to continue working in their languages of choice. As a result, only a little bit of safety-critical software really used Ada. However, we’ve noticed a bit of a resurgence lately. Case in point: an RC car using Ada for the brains. You can watch it tool around in the video below.

This isn’t the first time we’ve heard about Ada in the past few months. Partially, this could be because of the availability of the GNU compiler, although that’s been around since 1995, so maybe there’s another explanation. Ada’s strong typing does tend to plug holes that hackers exploit, so while we would hate to say it is hack proof, it certainly is hack resistant compared to many popular languages.

Continue reading “Civilian RC Car Uses Lego NXT And Ada” →

A Super-Brain For An E-bike

March 7, 2020 by 12 Comments

There’s no better way of improving a project than logging data to make informed decisions on future improvements. When it came to [Brian]’s latest project, an electric bike, he wanted to get as much data as he could from the time he turned it on until the time he was finished riding. He turned to a custom pyBoard-based device (and wrote it up on Hackaday.io), but made it stackable in order to get as much information from his bike as possible.

This isn’t so much an ebike project as it is about a microcontroller platform that can be used as a general purpose device. All of the bike’s controls flow through this device as a logic layer, so everything that can possibly be logged is logged, including the status of the motor and battery at any given moment. This could be used for virtually any project, and the modular nature means that you could scale it up or down based on your specific needs. The device is based on an ARM microcontroller so it has plenty of power, too.

While the microcontroller part is exceptionally useful ([Brian] talks about some of its other uses here and gives us even more data on his personal webpage), we shouldn’t miss the incredible bike that [Brian] built either. It has a 3 kW rear hub motor and can reach speeds of around 60 mph. While we let the commenters below hash out the classic argument of “bicycle vs. motorcyle” we’ll be checking out some electric vehicles that are neither.