Hackaday-feed 🤖

@Hackaday-feed

Hardware hacking blog

hackaday.com/

Presented as a Cohost Page by @RSS-feeds bot

(Btw, ppl who like this page may also like @twostopbits-feed)

Hackaday-feed 🤖@Hackaday-feed9/5/2024, 6:02 PM

If Wood Isn’t The Biomass Answer, What Is?

Hackaday comments

Hackaday tags: Featured, Interest, News, biomass, green energy, wood pellets

As we slowly wean ourselves away from our centuries-long love affair with fossil fuels in an attempt to reduce CO₂ emissions and combat global warming, there has been a rapid expansion across a broad range of clean energy technologies. Whether it’s a set of solar panels on your roof, a wind farm stretching across the horizon, or even a nuclear plant, it’s clear that we’ll be seeing more green power installations springing up.

One of the green power options is biomass, the burning of waste plant matter as a fuel to generate power. It releases CO₂ into the atmosphere, but its carbon neutral green credentials come from that CO₂ being re-absorbed by new plants being grown. It’s an attractive idea in infrastructure terms, because existing coal-fired plants can be converted to the new fuel. Where this is being written in the UK we have a particularly large plant doing this, when I toured Drax power station as a spotty young engineering student in the early 1990s it was our largest coal plant; now it runs on imported wood pellets.

Wood Ain’t What You Think It Is

An active coppiced woodland, this one looks about half way through its regrowth cycle. Martinvl, CC BY-SA 4.0

The coal-to-wood story has a very rosy swords-into-ploughshares spin to it, but sadly all isn’t as well as it seems with wood biomass power generation. Nature has a feature expressing concerns about it, both over its effect on the areas from which the wood is harvested, and over the CO₂ emissions it creates. The problem is that it produces so much CO₂ with such a long renewal time of regrowing all those trees, that over the next century it’s likely to make the CO₂ problem worse rather than better. The article has provoked a storm of criticism of the biomass industry from environmentalists, but in doing so do they risk tarnishing the whole biomass sector unfairly?

A millennia-old sustainable farming practice is that of coppicing. This is the repeated harvesting of wood from the same tree in a continuous cycle of cutting and regrowth of the same trees, and a typical coppiced woodland will contain trees at all stages of the cycle. This is a very practical example of carbon neutral biomass production, but the problem is that for a power-station scale operation it becomes one of replacing older trees with hew ones. While a coppiced tree will take in the order of a decade to replace its growth, a new full-sized forest tree takes many decades to do the same. The establishment of a coppiced forest is a slow process meanwhile, so there’s little prospect of their soon achieving the scale to replace the traditional forests harvested by the power industry.

The Answer Lies Down On The Farm

Fortunately, wood represents only one sector of the biomass industry. There’s an alternative model to that of the enormous former coal plant burning wood pellets, and it comes in the form of much smaller local plants running on biomass crops or crop waste from farms, usually in the form of straw. It’s worth looking at these plants in order to remind anyone tempted to dismiss biomass as a whole based on the wood pellet plants that there is a more sustainable alternative.

A straw-fired power station in Cambridgeshire, UK. Michael Trolove, CC-BY-SA 2.0.

A feature of growing up in rural England before the end of the 1980s was that at this time of year the land would be enveloped in a curious smog. We produced much more straw than we could use as a country, and the surplus used to be burned where it lay in the fields. The resulting ash would return what nutrients it contained to the soil, and the land being blanketed by smoke was just part of life.

When the practice was banned it became the norm for combine harvesters to chop the straw and distribute it across the field, where it would be ploughed in to break down naturally. Naturally this represented a significant biomass crop going to waste, so as the demand for green energy rose there appeared local plants all across the country. These typically have a capacity in the tens of MW, and buy their straw under contract from farms within an easy transport radius. This is usually surplus straw from feed crops, but is sometimes also ones specifically grown for biomass such as rye or elephant grass. It’s something of a mark of the season, when the contractors turn up with their huge high-speed baler to process the crop.

In the second half of the 20th century we concentrated on the economies of scale offered by very large coal-burning plants because it was relatively cheap to move a trainload of coal from the colliery to the power station. It’s unlikely that we’d now build similar plants to burn wood unless we already had them left over from the coal era, so it’s important to remind anyone put off biomass power by concerns similar to those in the Nature article that it doesn’t need to be done that way. There is an alternative, it relies on biomass that grows back on a yearly cycle with the harvest, and it could be coming to your county if it hasn’t already.

“Drax power station cooling towers” by [Andrew Whale], CC BY-SA 2.0.

Hackaday-feed 🤖@Hackaday-feed9/5/2024, 4:26 PM

Launching Model Airplanes With a Custom Linear Induction Motor

Hackaday comments

Hackaday tags: Science, airplane launcher, electromagnetic, launcher, linear induction motor

Launching things with electromagnetism is pretty fun, with linear induction motors being a popular design that finds use from everywhere in hobby designs like [Tom Stanton]’s to the electromagnetic launchers on new US and Chinese aircraft carriers. Although the exact design details differ, they use magnetic attraction and repulsion to create a linear motion on the propulsive element, like the sled in [Tom]’s design. Much like the electromagnetic catapults on a Gerald R. Ford-class carrier, electrical power is applied to rapidly move the sled through the channel, akin to a steam piston with a steam catapult.

Model airplane sparking its way through the launcher’s channel. (Credit: Tom Stanton, YouTube)

For [Tom]’s design, permanent magnets are used along both sides of the channel in an alternating north/south pole fashion, with the sled using a single wound coil that uses brushes to contact metal rails along both sides of the channel. Alternating current is then applied to this system, causing the coil to become an electromagnet and propel itself along the channel.

An important consideration here is the number of turns of wire on the sled’s coil, as this controls the current being passed, which is around 90 A for 100 turns. Even so, the fastest sled design only reached a speed of 44 mph (~71 km/h), which is 4 mph faster than [Tom]’s previous design that used coils alongside the channels and a sled featuring a permanent magnet.

One way to increase the speed is to use more coils on the sled, with a two-coil model launching a light-weight model airplane to 10.2 m/s, which is not only a pretty cool way to launch an airplane, but also gives you a sense of appreciation for the engineering challenges involved in making an electromagnetic catapult system work for life-sized airplanes as they’re yeeted off an aircraft carrier and preferably not straight into the drink.

Hackaday-feed 🤖@Hackaday-feed9/5/2024, 3:23 PM

I2C For Hackers: Digging Deeper

Hackaday comments

Hackaday tags: Hackaday Columns, Microcontrollers, Peripherals Hacks, howto, i2c

Last time, I gave you an overview of what you get from I2C, basics like addressing, interface speeds, and a breakdown of pullups. Today, let’s continue looking into I2C capabilities and requirements – level shifting, transfer types, and quirks like combined transfers or clock stretching.

Level Shifting

Today, the overwhelming majority of I2C devices are 3.3 V logic. but this wasn’t always the case. If you work with old tech or with I2C on VGA/DVI/HDMI ports, you will see 5 V I2C networks, and if you work with very new tech, you will see 1.8 V I2C networks; rarely, you might even see 2.5 V networks!

Interfacing 5 V devices with a 3. 3V controller, it might not be necessary to level shift. You need to a) wire pullups to 3.3 V, and b) win the device input tolerance lottery. Same goes interfacing 3.3 V devices with 1.8 V hosts – wire up pullups to 1.8 V and pray to the stars. It can work in production – here’s Adafruit taking the 3.3 V-pulled-up Raspberry Pi I2C bus, and connecting it to a 5 V-powered MCP23017 chip that drives a 5 V-connected HD44780 display.

If your arrangement is different, or you’re experiencing a problem, you will want a level shifter circuit. At their simplest, two N-FETs like 2N7002 will do wonders. If you want smaller PCB footprint, better parameters, or more channels, there are level shifter chips, with many of them wonderfully suited for I2C (read the datasheet!). As we’ve featured before, some shifter ICs are too smart for their own good, while others will do just fine – if in doubt, remember to use your logic analyzer judiciously.

Two Ways To Talk

There are two kinds of I2C transfers you could expect to perform – I’d call them “simple transfers” and “register transfers”. With simple transfers, you send an address, and after the device ACKs, you either send or receive a single byte – it’s just like working with a shift register. With register transfers, you send an address, then a register number, and the device sends you the “contents” of that register – it’s more like working with an SPI display.

The PCF8574 is an I2C GPIO expander that does simple transfers. It has eight GPIO pins, and it only does simple transfers. How does that work, given it does both input and output? Well, the PCF8574 has only three possible states for all pin, with two of them combined together. The “Low” state (writing 0) is a hard pull down to GND. The “High” state (writing 1) is a weak pull to VCC – which also makes the pin work as an input with a pullup enabled. To check the input state, just read the expander state, and see if any of the pins you’ve set to 1 are now reading as 0. You can’t do a lot of high-side driving, sure, but you can still drive LEDs and check buttons, plus, this scheme is dead simple and covers a ton of use cases.

A good few I2C devices use simple transfers – the LM75 temperature sensor, for instance, only has to return temperature. You can read out multiple bytes at once, of course – simple transfers aren’t inherently limited to a single byte! PCF8575, the 16-bit sister of the PCF8574, has 16 GPIOs, I’ve used simple transfers with an ATMega328P keypard controller I created at some point – it would return keycodes, taken from a ring buffer. However, at some point, I decided to add more features to it, like ADC reading to help out a Pi Zero it was connected to, and had to upgrade it to register transfers.

The MCP23017 is a GPIO expander that uses register transfers. It has 16 GPIO pins, and a ton of features, each with their own register. Since one register contains 8 bits and we have 16 GPIOs, there are two registers per feature, and as such, there are two registers for pin directions, two for enabling integrated pullups, two for reading out input states, two for setting pins as outputs, and so on. They can even be arranged in two different ways, one backwards compatible with a different chip, by changing a bit in the status register! It’s a fair bit more complex chip than the PCF8574, but the complexity pays off where you need it.

I2C EEPROMs work with register transfers, too – some use 8-bit addresses, which allows for up to 256 bytes of storage. Higher-capacity EEPROMs use 16-bit (two-byte) addresses, where you’re expected to send in two bytes before you can read data out; if you try to read from such an EEPROM using two-byte addresses, you will just read back zeroes, so beware!

Quirks

But what if the device can’t keep up with the multi-byte transactions that your microcontroller is asking for? Maybe you have an EEPROM that needs time before it can read out a value from its internal memory so that it your MCU can receive it, maybe it’s a sensor that needs to average some values quickly and it just can’t catch up with even the lax timing requirements of 100 kHz I2C.

There’s a solution – it’s called clock stretching, and it’s basically an I2C device holding SCL low after receiving a byte, extending ACK state for a long time, until it can actually return meaningful data. As long as SCL is low, the controller should wait for the device. It’s essentially a way for a device to say “wait, not yet, I need some time before I can give you what you’re looking for”.

Raspberry Pi didn’t support clock stretching for the longest time due to a silicon bug. Every single Pi version before Pi 4 couldn’t handle clock stretching, including all of the Pi Zero versions released at the time of writing this article. The workaround, if you need one – use software I2C. It consumes more CPU since you have to use a kernel driver that bitbangs the bus, but it does have functional clock stretching. And of course the Raspberry Pi isn’t alone: if you are likely to need clock stretching, make sure that the microcontroller hardware peripheral supports it properly.

Next time, we dive into the physical layer, look at logic analyzer traces, understand how communication happens, and the ways it can break despite our best intentions.

Hackaday-feed 🤖@Hackaday-feed9/5/2024, 12:14 PM

Getting Root on Cheap WiFi Repeaters, the Long Way Around

Hackaday comments

Hackaday tags: Network Hacks, Reverse Engineering, curl, CVE, linux, openwrt, RCE, remote code execution, ssh, uart, wifi repeater

What can you do with a cheap Linux machine with limited flash and only a single free GPIO line? Probably not much, but sometimes, just getting root to prove you can is the main goal of a project. If that happens to lead somewhere useful, well, that’s just icing on the cake.

Like many interesting stories, this one starts on AliExpress, where [Easton] spied some low-cost WiFi repeaters, the ones that plug directly into the wall and extend your wireless network another few meters or so. Unable to resist the siren song, a few of these dongles showed up in the mailbox, ripe for the hacking. Spoiler alert: although the attempt on the first device had some success by getting a console session through the UART port and resetting the root password, [Easton] ended up bricking the repeater while trying to install an OpenWRT image.

The second attempt, this time on a different but similar device, proved more fruitful. The rudimentary web UI provided no easy path in, although it did a pretty good job enumerating the hardware [Easton] was working with. With the UART route only likely to provide temptation to brick this one too, [Easton] turned to a security advisory about a vulnerability that allows remote code execution through a specially crafted SSID. That means getting root on these dongles is as simple as a curl command — no hardware hacks needed!

As for what to do with a bunch of little plug-in Linux boxes with WiFi, we’ll leave that up to your imagination. We like [Easton]’s idea of running something like Pi-Hole on them; maybe Home Assistant would be possible, but these are pretty resource-constrained machines. Still, the lessons learned here are valuable, and at this price point, let the games begin.