Somewhere between shoving components into a breadboard temporarily and committing them to a piece of protoboard or a PCB lies the copper tape method. This flexible Manhattan-style method of circuitry formed the basis for [Bunnie Huang]’s Chibitronics startup, and has since inspired many to stop etching boards and start fetching hoards of copper tape.

[Hales] hit the ground running when he learned about this method, and has made many a copper tape circuit in the last year or so. He offers several nice tips on his site that speak from experience with this method, and he’ll even show you how to easily work an SMD breakout board into the mix.

Generally speaking, [Hales] prefers plywood as the substrate to paper or cardboard for durability. He starts by drawing out the circuit and planning where all the tape traces will go and how wide they need to be. Then he lays out copper traces and pads, rubs the tape against the substrate to make it adhere strongly, and reinforces joints and laps with solder before adding the components. As you can see, copper tape circuits can get pretty complicated if you use Kapton tape as insulation between stacked layers of traces.

Copper and Kapton (polyimide) tape are just two of the many useful tapes you may not be aware of. Stick with us a moment and check out [Nava Whiteford]’s exploration of various adhesive marvels.

source https://hackaday.com/2020/01/15/the-flexible-permanence-of-copper-tape-circuits/

The Consumer Electronics Show in Las Vegas is traditionally where the big names in tech show off their upcoming products, and the 2020 show was no different. There were new smartphones, TVs, and home automation devices from all the usual suspects. Even a few electric vehicles snuck in there. But mixed in among flashy presentations from the electronics giants was a considerably more restrained announcement from a company near and dear to the readers of Hackaday: Arduino is going pro.

While Arduino has been focused on the DIY and educational market since their inception, the newly unveiled Portenta H7 is designed for professional users who want to rapidly develop robust hardware suitable for industrial applications. With built-in wireless hardware and the ability to run Python and JavaScript out of the box, the powerful dual-core board comes with a similarly professional price tag; currently for preorder at $99 USD a pop, the Portenta is priced well outside of the company’s traditional DIY and educational markets. With increased competition from other low-cost microcontrollers, it seems that Arduino is looking to expand out of its comfort zone and find new revenue streams.

That’s a Lot of Pins

The Portenta H7 is obviously a far cry from the relatively dinky 8-bit Arduinos that we’ve all got filling up our parts drawers. Developed for high performance edge computing applications, the new board is powered by a 32-bit STM32H747XI that utilizes both an ARM Cortex M7 and an M4 running at 480 MHz and 240 MHz respectively. The two cores can work independently, allowing for example one core to run interpreted Python while the other runs code compiled in the Arduino IDE. When they need to work together, the cores can communicate with each other via a Remote Procedure Call (RPC) mechanism.

Outwardly, the new board doesn’t look far removed from the modern Arduino form factor we’re used to. The USB connector has been upgraded to a Type-C, but the Portenta still retains the dual rows of pads ready for hand-soldered headers — that’s their more recent pinout that they call the Arduino MKR form factor.

If you look on the back of the board however, you’ll see that they’ve added two 80-pin high density connectors. According to the product page, these are intended to allow the Portenta to simply be plugged into a device as a removable module. The idea being that devices in the field can easily have their Portenta swapped out for an upgraded model. Some digging into the product page documentation section turns up a schematic that lists the connectors as Hirose DF40C-80DP-0.4V(51).

The base model Portenta features 8 MB SDRAM and 16 MB NOR flash, but it can be custom ordered with up to 64 MB of memory and 128 MB of flash should you need it. It’s also possible to delete various interfaces from the board when ordering, so if you don’t want network connectivity or the NXP SE050C2 crypto chip, they can simply be left off. However as of this writing it is unclear as to what minimum order quantity is necessary to unlock this level of customization, or or how much these modifications will change the unit cost.

Year of the Arduino Desktop?

The Portenta H7 is an impressive enough piece of hardware on its own, but when it’s plugged into the optional Carrier Board, things really start to get interesting. The Carrier Board provides full size connectors for all of the onboard peripherals, and according to documentation, turns the Portenta into an eNUC-class embedded computer. There’s even support for DisplayPort to connect a monitor, and miniPCI for expansion cards.

With a fully loaded Portenta H7 slotted into the Carrier Board, it would seem you have the makings of a low-power ARM “desktop” computer. Albeit one that wouldn’t outperform the Raspberry Pi Zero, and which costs several times more.

The Arduino press release and product page doesn’t make any mention of what kind of software or operating system said computer would run, so presumably that’s left as an exercise for the customer. While not particularly well suited to it, the ARM Cortex-M family of processors is capable of running the Linux kernel, so spinning up a “real” OS image for it should be possible. Of course with a maximum of just 64 MB of RAM, you’ll want to keep your performance expectations fairly low.

Where Does Portenta Fit?

We can’t even speculate what a maxed out Portenta would cost, and there’s no pricing or release date for the Carrier Board. But even at $99, the base model Portenta H7 would be a tough sell for hackers and makers who are used to buying dual-core ESP32 boards at 1/10 of the price, or the Teensy 4.0 which has a 600 MHz Cortex-M7 at 1/4 of the price. Which is fine, since this board isn’t intended for the traditional core Arduino audience.

Seeing the carrier board, we can’t help but notice some parallels here with the Raspberry Pi Compute Module. With connections broken out to a SODIMM header, the idea of the Computer Module was to help bridge the gap between the DIY community and the commercial one by offering up a Raspberry Pi in a more rugged form factor that would be easier to integrate into end-user products. But since it wasn’t any cheaper than the stock Pi, there wasn’t a whole lot of incentive to switch over. We haven’t seen consumer products advertising “Raspberry Pi Inside!” so it’s hard to tell if there has been any meaningful adoption from industry.

One has to wonder why any company that has the resources to integrate such an expensive board into their products wouldn’t just come up with their own custom design around the Portenta’s STM32H747XI chip, which even in single quantities, can currently be had for less than $15. The difference may end up coming down to the world-renowned community that surrounds the Arduino brand, and the company’s efforts to modernize their toolchain.

source https://hackaday.com/2020/01/15/new-part-day-arduino-goes-pro-with-the-portenta-h7/

We sympathize with [learnelectronic’s] statement: “I’m ashamed. I may have bought another oscilloscope.” We get it and we enjoyed watching him tear down the OWON SDS1102. (Video, embedded below.) As you might guess, this is a 100 MHz, two-channel scope, and very similar to many other Chinese scopes you can get inexpensively.

The last ten minutes are so of the video below shows him removing the case. There’s only three little boards inside. One is clearly a power supply. The other two don’t have much on them. There’s a tiny RF shield over one part of the board, so you assume that’s the input section.

The larger board looks like it just mounts the user interface controls. The central board appears to have all the front end and microprocessor components. It is amazing how little there is to see.

The scope runs about $250 or so, new. Like most scopes in this price class it has a relatively small screen, and an 8-bit front end. The claimed sample rate is 1GS/s. However, the screen is larger than a Rigol DS1102E, which is pretty comparable and is about $50 more than the OWON.

We’ve asked readers to help us pick a cheap scope, and found that everyone has their own opinion. The last time we looked at an OWON scope, it was a confusing digital scope impersonating an analog one.

source https://hackaday.com/2020/01/15/owon-oscilloscope-teardown/

For years we’ve seen a trickle of really interesting home automation projects that use the Node-RED package. Each time, the hackers behind these projects have raved about Node-RED and now I’ve joined those ranks as well.

This graphic-based coding platform lets you quickly put together useful operations and graphic user interfaces (GUIs), whether you’re the freshest greenhorn or a seasoned veteran. You can use it to switch your internet-connected lights on schedule, or at the touch of a button through a web-app available to any device on your home network. You can use it as an information dashboard for the weather forecast, latest Hackaday articles, bus schedules, or all of them at once. At a glance it abstracts away the complexity of writing Javascript, while also making it simple to dive under hood and use your 1337 haxor skills to add your own code.

You can get this up and running in less than an hour and I’m going to tackle that as well as examples for playing with MQTT, setting up a web GUI, and writing to log files. To make Node-RED persistent on your network you need a server, but it’s lean enough to run from a Raspberry Pi without issue, and it’s even installed by default in BeagleBone distributions. Code for all examples in this guide can be found in the tutorial repository. Let’s dive in!

What It Is

Node-RED is a graphical programming language built on Node.js. It implements a server and runs what are called “Flows”: programs based on Javascript. Why would you want to run a server-side IDE for your programs? Because Node-RED also makes it dead simple to spin up web apps and use them as your online information and control system.

Installation

To make your Node-RED programs persistent you do need a server, however, if you just want to play for now you can run locally. Your server can be as simple as installing the platform on a Raspberry Pi or an always-on computer on your LAN. Prerequisites include Node.js and npm (the Node.js package manager) which on a Linux system are an easy install.

sudo apt install nodejs

Now we can install Node-RED and, to follow the examples below, you should also install the dashboard package:

npm install node-red
npm install node-red-dashboard

To run locally you can just type node-red in the terminal. However, the more eloquent way to run this is as a systemd service. Copy the contents of the nodered.service file to /etc/systemd/system/nodered.service and update the User, Group, and WorkingDirectory variables in that file to match an actual user on your system. With that in place, just enable and start the service. It will now restart on a crash or system reboot from here on out.

systemctl enable mqtt_porchlight.service
systemctl start mqtt_porchlight.service

You can now load up the Node-RED IDE simply by visiting localhost:1880 in a web browser.

Hello World

The simplest thing to do as your first “flow” in Node-RED is: click button, get timestamp. To make the image above I did nothing more than drag the “Inject” and “Debug” nodes from the left column into the center, then drag the line that connects the two nodes. You need to click the “Deploy” button on the upper right any time you make changes, and then clicking the button hanging off the left side of the inject node, which has the “timestamp” label by default, to spit out the time in the debug window. Click the bug icon in above the right window if you’re not seeing the debug output.

This example isn’t very useful, but that’s not the point of Hello World code. This drives home the power of the graphical code system. What’s also interesting is that flows can be exported as json files. Here’s what this Hello World looks like and it can be imported to your own Node-RED installation.

[
    {
        "disabled": false,
        "id": "ff177395.3cf468",
        "info": "",
        "label": "Hello World",
        "type": "tab"
    },
    {
        "crontab": "",
        "id": "1c6883be.759c24",
        "name": "",
        "once": false,
        "onceDelay": 0.1,
        "payload": "",
        "payloadType": "date",
        "repeat": "",
        "topic": "",
        "type": "inject",
        "wires": [
            [
                "1fec91a8.ab7156"
            ]
        ],
        "x": 200,
        "y": 140,
        "z": "ff177395.3cf468"
    },
    {
        "active": true,
        "complete": "false",
        "console": false,
        "id": "1fec91a8.ab7156",
        "name": "",
        "tosidebar": true,
        "tostatus": false,
        "type": "debug",
        "wires": [],
        "x": 370,
        "y": 140,
        "z": "ff177395.3cf468"
    }
]

MQTT Quickstart

Node-RED feels like it’s made specifically to be used with MQTT, the popular Internet of Things protocol for which Elliot Williams has written a fantastic guide. It feels that way because an MQTT client is built in and most of the nodes have “topics” as well as message payloads which is all you really need to communicate with an MQTT broker.

As you can see above, I’m doing the exact same inject/debug trick but now I’ve dragged an “mqtt in” and “mqtt out” node from the “Network” column of possible nodes.

There’s slightly more setup here as we need to choose an MQTT server and select a topic to publish to and listen for. But the interface makes this very easy, just double-click one of the MQTT nodes. Here I’m using the mosquitto test server (test.mosquitto.org)and the topic Hackaday/nodered/test. Just realize that anyone looking at messages on that server can see this and if you use the exact same topic you may see other readers sending test messages. Node-RED can actually be used as an MQTT broker as well.

Try double-clicking the inject node and changing the payload from timestamp to a string and you can send your own custom messages. For the most part I find it easy to find my way around Node-RED and playing with settings is low-effort. Just make sure to hit the deploy button — your changes won’t actually be in place until you do.

Web Gui Hello World

Let’s get to the really exciting part of Node-Red, the ability to spin up a web app with very little effort.

Here you can see a smartphone displaying our app. The only really useful part here is the button. Click it and you’ll get “Hello Hackaday!” in the debug window of Node-RED as seen above. All it took to create this page was to install the dashboard package for Node-RED and then drag a button onto the canvas. Once deployed, your web app will be located at localhost:1880/ui

Installation of the package is a simple one-liner:

npm install node-red-dashboard

Dragging the button onto the canvas and hooking it to a debug node is also simple, but you need to do just a bit of configuration. Double-clicking on the button node you can change the payload to affect what message is sent to the debug window, but you also need to set a Group, and within the group edit dialog you’ll need to set a Tab. This affects the web app, with Groups organizing blocks on each page of the web app, and Tabs selecting different pages from the hamburger menu at the upper left. You can name groups and tabs however you like.

Let’s Build a Web App!

Enough with the Hello World code, let’s build something useful. I’ve been using Node-RED for a month or so and have built up a couple of useful apps, one interacts with my MQTT broker to control and monitor my front porchlight, the other I use as a simple button-press to keep track of the days I exercise. Let’s build up the exercise app bit by bit because there’s more to it than merely sending MQTT packets back and forth.

Here is the current state of the exercise app, which includes a button that records today’s date to a log file and a gauge that reads the log file to display how many of the last seven days have included exercise. Let’s build it up one block at a time.

GUI Button Writing to Files

This is where the flow begins. It consists of a button from the Dashboard package that sends a timestamp when clicked. This message will be logged to two “file” nodes, the first is exerciselog-raw.txt which simply records one UNIX timestamp for each line. That’s not human readable, so the second file node has a function node which translates the timestamp using the following JavaScript snippet. There’s a bit of magic in there to make sure the month and day are always two digits.

var date;
date = new Date();
var year = date.getFullYear();
var month = date.getMonth();
month = (month < 9 ? '0' : '') + (month+1)
var day = date.getDate();
day = (day < 10 ? '0' : '') + day
msg.payload = year + '-' + month + '-' + day;
return msg;

Adding a User Notification

The button works as expected, but it gives no feedback to the user. To improve upon this I added a notification node from the dashboard package. It is connected after the file node to confirm that the date had been written to the log file.

Reading a File, Displaying Data, Refreshing at Startup

This last part of the flow uses the tan “file in” node to read UNIX timestamps from the raw log file and displays it on the teal “gauge” node from the dashboard package. It is activated by two different triggers, one updates after a new date is written to the log files. The other is the lavender “inject” node which has an “index once after n seconds” option to populate the initial data when Node-RED starts.

The gauge is just looking for a number to populate and this is fed by a function node (I called it Magic). The following code reads in the logfile as an array, figures out the UNIX date code for seven days ago, and then iterates back through the last seven timestamps in the log file.

//Turn incoming timestamps log into an array:
var exercisearray = msg.payload.split("\n");
if (exercisearray.slice(-1)[0] === "") exercisearray.length = exercisearray.length-1

//Get timestamp for week ago to compare against
var thismorning = new Date()
thismorning.setHours(0)
thismorning.setMinutes(0)
thismorning.setSeconds(0)
thismorning.setMilliseconds(0)
var sixdays = 1000*60*60*24*6
var oneweekago = thismorning.getTime()-sixdays

//Iterate and count past week of exercise
var count = 0
var secondsinday = 60*24*7
for (var i=1; i<8; i++) {
  if (i>exercisearray.length) break;
  var testval = parseInt(exercisearray.slice(-i)[0]);
  if (testval >= oneweekago) ++count;
}

//Store our answer as the payload and pass along
msg.payload = count;
return msg;

Give Node-RED a Try!

One of my first concerns with the platform was version control but that’s available too. There is git integration built-in called Node-RED projects but it’s not enabled by default. I’m not accustomed to using a GUI for git, but then again I’m not accustomed to graphical programming interfaces so it doesn’t hurt to try something new.

The examples I’ve shown here are really the tip of the iceberg. Look around and you’ll find a ton of enthusiasm for Node-RED which translates to incredible flows and awesome web apps. For instance, I’ve been reading Scargill’s Tech Blog for years and there you’ll find a ton examples of what can be accomplished. Here we see Scargill’s thermostat control panel that has all kinds of customization to give it a special look. Finding examples that you like isn’t hard, and copying their code is even easier.

You can easily pick up Node-RED in an afternoon and end up with something useful. For those who want to spend more time, the sky’s the limit. If you have any kind of home automation, it’s something you must try as it unlocks the ability for anyone on your LAN to access information and control without installing an app. You can easily pull a disused smartphone out of the drawer and turn it into a dedicated control panel, something I did for the image at the top of this article with the help of an Android app called Fully Kiosk Browser Lockdown for a true fullscreen browser experience not provided by Chrome or Firefox for Android. Give it a try with your own surplus gear!

---

Resources:

• Example code repository

source https://hackaday.com/2020/01/15/automate-your-life-with-node-red-plus-a-dash-of-mqtt/

We were concerned when we saw [Brick Experiment Channel] test a drone propulsion pod made with Lego. After all, the thrust generated was less than the weight of the assembly. But a few tweaks got enough lift to overcome the assembly weight, as you can see in the video below.

The next step was to build three more pods and add some lightweight avionics and a battery. The first flight was a little dicey because the sensor orientation was off. Then there was some more software tuning before things really got airborne.

Judging from the nearby curtains, the drone puts out quite a bit of wind. However, it still needed a little more power from a bigger battery pack. It doesn’t look like the bird is a joy to fly, but it is impressive to see a bunch of Lego flying around the house. Granted the flight controller, the radio, and the battery aren’t Lego, but it looks like everything else is.

We aren’t sure we would recommend trying this project, but if you do, there is a bill of materials at the end of the video. The total cost was about $500 and you can get a pretty good commercial drone for that price. Still, the thrill of it would be worth something.

We’ve seen someone selling a kit to make Lego drones. If you’d rather stay on the ground, how about a monowheel?

source https://hackaday.com/2020/01/15/lego-drone-finally-takes-off/

From the 1920s until the 1970s, most gasoline cars in the USA were using fuel that had lead mixed into it. The reason for this was to reduce the engine knocking effect from abnormal combustion in internal combustion engines of the time. While lead — in the form of tetraethyllead — was effective at this, even the 1920s saw both the existence of alternative antiknock agents and an uncomfortable awareness of the health implications of lead exposure.

We’ll look at what drove the adoption of tetraethyllead, and why it was phased out once the environmental and health-related issues came into focus. But what about its antiknock effects? We’ll also be looking at the alternative antiknock agents that took its place and how this engine knocking issue is handled these days.

It’s a Matter of Octane

In an internal combustion engine (ICE), ideally the air-fuel mixture that gets injected into a cylinder will detonate at the perfect moment where the flame front will travel outwards from the point of ignition, with every bit of the air-fuel mixture burning up fully. This will allow for maximum use of the energy in the fuel mixture, while causing a clean stroke of the piston.

In reality, however, pockets of this fuel-air mixture will detonate before the flame front reaches them. These so-called ‘cool flames’ occur because of the compression by the piston combined with slight unevenness in the mixture, causing additional pressure waves in the cylinder. This raises the cylinder pressure and causes the typical metallic pinging noise that is indicative of engine knocking. Depending on how many of these pockets detonate outside of the spark plug’s flame front, the result may be increased wear on components, or even their outright destruction.

Hereby the octane rating of the fuel is crucial, as it essentially determines at which compression level the fuel will detonate (without spark). High octane fuels thus do burn less easily, but allow for far higher levels of compression, which effectively produces more power. In contrast, diesel engines require lower octane fuels, as they only compress air, with the fuel being injected at the end of the compression cycle, with the heat from the compressed air detonating the fuel.

Time to Knock It Off

There are fortunately a number of ways to prevent this premature detonation effect. These include:

• Using a fuel with a higher octane rating.
• Adding more fuel to the air-fuel mixture.
• Reducing the compression level in the cylinder.
• Reducing the load on the engine.

You can choose the first point by using a so-called antiknock agent, a chemical that raises the octane rating of the fuel by raising the temperature and pressure at which auto-ignition occurs. Tetraethyl lead (TEL) is one example of such an agent. Its chemical formula is (CH3CH2)4Pb.

Inside the engine’s cylinders, the function of TEL is to quench the spontaneous ignitions that occur outside of the flame front by dealing with the pyrolized radicals that would otherwise sustain the chain reaction of the cool flame. Here the lead is the actual reactive agent, while the rest of the TEL serves to allow it to dissolve into gasoline (courtesy of its alkyl groups).

As the TEL is burned, it produces carbon dioxide, water and lead:

(CH3CH2)4Pb + 13 O2 → 8 CO2 + 10 H2O + Pb

The lead can further react with oxygen to form lead(II) oxide:

2 Pb + O2 → 2 PbO

Left alone, the lead and lead(II) oxide would accumulate inside the engine and destroy it. To prevent this, lead-scavengers such as 1,2-dibromoethane and 1,2-dichloroethane are added to form lead(II) bromide and lead(II) chloride respectively (unfortunately neither are as pretty as lead(II) iodide). These compounds are easily removed from the engine during normal operation, from where they’d be released into the environment.

The Competition

In addition to lead, two other substances were known to increase the octane rating of gasoline fuel: ethanol (C2H6O) and benzene (C6H6). For ethanol this octane rating raising property is due to ethanol being suitable as a complete (albeit more expensive) replacement for gasoline fuel. As ethanol has by default a higher octane rating than most gasoline fuels, mixing a percentage of ethanol into gasoline fuel causes the latter to have a higher octane, which achieves the desired antiknocking effect.

Benzene is a hydrocarbon which appears naturally in crude oil. It’s present in gasoline as a result, where it’s also responsible for the characteristic sweet smell around gasoline refueling stations. Although now usually kept at less than 1% in gasoline due to the carcinogenic properties of benzene, before TEL’s introduction in the 1920s as a fuel additive, benzene was regarded as a good antiknock agent as it too raised the octane rating. By the 1950s TEL had virtually replaced benzene as antiknock agent.

Ethanol can be produced from oil (ethylene), as well as from biomass (sugar cane, corn, etc.). It is however a fuel type that has only seen widespread popularity since the 1970s. TEL had the benefit over ethanol as an antiknock agent that only a small amount would be needed to have the same effect, yet at similar cost. TEL however also had the additional benefit that its use as fuel-additive could be patented.

TEL Fallout

Ultimately history shows us that TEL would prevail over benzene and ethanol, with ethanol only making a resurgence in the 1970s during the phase-out of TEL. As information uncovered over the past decades shows, the reason for this was a deliberate strategy by the companies behind the Ethyl partnership (General Motors, ESSO and DuPont) to bury the science about the well-known harmful effects of lead, the expected blood serum lead levels from adding TEL to gasoline and the expected effects on the environment.

As this 2005 paper by William Kovarik (PDF) summarizes, the use of ethanol as an antiknock agent was commonplace by the time that TEL was introduced, but over the decades, the misinformation campaign by Ethyl was so effective that people came to believe that TEL was the only antiknock agent available. In the end it would take fifty years of research, as well as scientific, court and regulatory challenges to produce evidence about the harmful effects of TEL that were so damning that leaded gasoline was phased out in the 1970s in the US, though not without Ethyl first suing the Environmental Protection Agency (EPA).

Among one of the effects noted by researchers of the effects of increased lead levels in blood serum was that of a sharp negative effect on the developing brain, leading to a lower IQ, poor impulse control and troubles at school. Later studies introduced the lead-crime hypothesis, which links the rise in violent crime since the 1930s and the sharp drop-off in the early 1990s with the exposure of children to high blood serum lead levels, which would have impaired brain development.

Although the Ethyl corporation still exists today, the use of TEL in gasoline has been essentially reduced to zero, aside from use in avionics fuel, antique cars, and so on. As the use of TEL is incompatible with catalytic converters due to lead being a catalyst poison, the requirement of adding a catalytic converter to new cars in the late 1970s US made the demise of TEL for cars a certainty. Europe, Asian nations and so on also phased out TEL until today only one plant in the world still (legally) produces leaded gasoline.

Antiknock Strategies Today

Even though modern ICEs have hardened components that can withstand engine knocking without damage, and the mixing of ethanol into the gasoline fuel is becoming ever more commonplace, other antiknock agents are still around, with methylcyclopentadienyl manganese tricarbonyl (MMT, (C5H4CH3)Mn(CO)3) having been used for years in a number of countries.

Ferrocene (Fe(C5H5)2) is also used as a fuel additive, used as an alternative to TEL, such as for use in antique cars. Increasing the amount of 2,2,4-trimethylpentane (iso-octane, also a petroleum product) in gasoline serves to reduce the knocking, as was originally discovered by Graham Edgar in 1926. Iso-octane forms the 100 point on the octane rating scale.

In addition to fuel additives, modern digitally controlled gasoline engines have built-in mechanisms that detect and control engine knocking, by adjusting the ignition timing and pressure. This allows for the engine to automatically adjust itself to fuels with different octane ratings. This of course comes with its own set of challenges, as for example this 2017 paper by Petyon Jones et al. titled “Stochastic Simulation and Performance Analysis of Classical Knock Control Algorithms” details.

Just A Historical Footnote

It’s interesting to consider these revelations and new innovations in light of the transition of the car industry from the internal combustion engine to electric motors, which do not have any of these issues. Free from the stigma of leaded gasoline and its combustion products, it will be interesting to see how we will regard this chapter in human history fifty years from now.

By then not having regenerative braking would probably seem beyond quaint, as would be the ritual of weekly (or daily) refueling or recharging. Maybe the issue of fine particulate dust from tires and brake disks will have become the next environmental issue.

[Main image source: Tetraethyl Lead by David Brodbeck CC-BY 2.0]

source https://hackaday.com/2020/01/15/tetraethyl-lead-the-solution-to-one-and-cause-of-many-new-problems/

Those of us who have worked with vintage sound generator chips such as the Yamaha FM synthesizers in recent years have likely run into our own fair share of “fake” or “remarked” chips, sometimes relabeled to appear as a chip different than the die inside the packaging entirely. [David Viens] from Plogue has finally released his findings on the matter after 3 years of research.

The first thing to determine is in what way are these chips “fake”? Clearly no new YM2612’s were manufactured by Yamaha in 2015, but that doesn’t mean that these are simply unlicensed clones put out by another die factory. [David] explains how these chips are often original specimens sourced from recycled electronic waste from mostly environmentally unsafe operations in China, which are then reconditioned and remarked to be passed as “new” by resellers. Thankfully, as of 2017, he explains that most of these operations are now being shut down and moved into an industrial park where the work can be done in a less polluting manner.

The next thing that [David] dives into is how these remarked chips can be spotted. He explains how to use telltale signs in the IC packaging to identify which chip plant produced them, and visible indications of a chip that has been de-soldered from a board and reconditioned. There are different ways in which the remarking can be done, and sometimes it’s possible to undo the black-top, as it’s called, and reveal the original markings underneath with the simple application of acetone with a cotton swab.

We’ve talked about fake chips and how they can lead to hardware failure here before, but in the case of chips like these which aren’t manufactured anymore, we’re not left with much choice other than FPGA or software reimplementations. Check out [David]’s 40-minute look into these chips after the break.

[Thanks Greg Kennedy for the tip!]

source https://hackaday.com/2020/01/15/what-to-know-when-buying-chips-that-havent-been-made-for-three-decades/

There are times when a sensor is required that does its job without the need for human attention over a long period, and for those applications a minimal power drain is a must. [Dave Davenport] had an EPS8266-based moisture sensor, and became disappointed in having to replace its AA batteries every few months. With an 18650 Li-ion cell and a bunch of power-saving tricks that time has been extended so far to over a year and still going, so he’s written a blog post detailing how he did it.

Some of his techniques such as turning off the sensor or using a better LDO regulator than the stock Wemos one are straightforward. Others though are unexpected, such as using the memory associated with the on-board RTC to store the WiFi connection info and channel number during sleep. The normal ESP8266 connection sequence involves a network scan, by hanging onto what it found last time the extra time and thus power expended by it can be avoided. Similarly switching from a DHCP lease to a fixed IP address cuts the time the device waits for a lease and thus the time it has to stay awake.

We might not all have ESP8266 moisture sensors to build, but we’re many of us on a quest to sip less power in our projects. Let us help you with a previous sojourn into that arena.

ESP8266 image: connorgoodwolf [CC BY-SA 4.0].

source https://hackaday.com/2020/01/15/one-esp8266-one-battery-one-year-and-counting/

We generally cast a skeptical eye at projects that claim some kind of superlative. If you go on about the “World’s Smallest” widget, the chances are pretty good that someone will point to a yet smaller version of the same thing. But in the case of what’s touted as “The world’s smallest vector monitor”, we’re willing to take that chance.

If you’ve seen any of [Arcade Jason]’s projects before, you’ll no doubt have noticed his abiding affection for vector displays. We’re OK with that; after all, many of the best machines from the Golden Age of arcade games such as Asteroids and Tempest were based on vector graphics. None so small as the current work, though, based as it is on the CRT from an old camcorder’s viewfinder. The tube appears to be about 3/4″ (19 mm) in diameter, and while it still had some of its original circuitry, the deflection coils had to be removed. In their place, [Jason] used a ferrite toroid with two windings, one for vertical and one for horizontal. Those were driven directly by a two-channel push-pull audio amplifier to make patterns on the screen. Skip to 15:30 in the video below to see the display playing [Jerobeam Fenderson]’s “Oscilloscope Music”.

As much as we’d love to see a tiny game of Battlezone played on the diminutive display, there’s only so much it can do. Maybe an analog version of this adorable digital oscilloscope would be possible?

source https://hackaday.com/2020/01/14/camcorder-viewfinder-converted-to-diminutive-vector-display/

If you were asked to imagine a particle accelerator, you would probably picture a high-energy electron beam contained within a kilometers-long facility, manned by hundreds of engineers and researchers. You probably wouldn’t think of a chip smaller than a fingernail, yet that’s exactly what the SLAC National Accelerator Laboratory’s Accelerator on a Chip International Program (ACHIP) has accomplished.

The Stanford University team developed a device that uses lasers to accelerate electrons along etched channels on a silicon chip. The idea for a miniature accelerator has existed since the laser’s invention in 1960, but the requirement for a device to generate electrons made the early proof-of-concepts difficult to manufacture in bulk.

The electromagnetic waves produced by lasers have much shorter wavelengths than the microwaves used in full-scale accelerators, allowing them to accelerate electrons in a far more confined space – channels can be shrunk to three one-thousandths of a millimeter wide. In order to couple the lasers and electrons properly, the light waves must push the particles in the correct direction with as much energy as possible. This also requires the device to generate electrons and transmit them via the proper channel. With an accelerator engraved in silicon, multiple components can fit on the same chip.

Within the latest prototype, a laser hits a grating from above the chip, directing the energy into a waveguide. The electromagnetic waves radiate out, moving with the waveguide until they reach an etched pattern that creates a focused electromagnetic field. As electrons move through the field, they accelerate and gain energy.

The results showed that the prototype could boost the electrons by 915 electron volts, equivalent to the electrons gaining 30 million electron volts over a meter. While the change is not on the scale of SLAC, it does scale up more easily since researchers can fit multiple accelerating paths onto future designs without the bulk of a full-scale accelerator. The chip exists as a single stage of the accelerator, allowing more researchers to conduct experiments without the need to reserve space in expensive full-scale particle accelerators.

source https://hackaday.com/2020/01/14/particle-accelerators-that-fit-on-a-chip/

A while back, [lonesoulsurfer] stumbled upon a mind-blowing little DIY synth on YouTube and had to make one of his own. We don’t blame him one bit for that, ’cause we’ve been down that cavernous rabbit hole ourselves. You might want to build one too, after you hear the deliciously fat and guttural sounds waiting inside those chips and passives. Don’t say we didn’t warn you.

The main synth is built on five LM358 op-amps that route PWM through a pair of light-dependent resistors installed near the top. There are two more oscillators courtesy of a 40106 hex inverting Schmitt trigger, which leaves four more oscillators to play with should you take the plunge and build your own.

He didn’t just copy the guy’s schematic and call it good. He added [a 555-based arpeggiator that’s controlled with two homebrew optocouplers. These sound fancy and expensive, but can be bred easily at home by sealing an LED and an LDR inside a piece of black heat shrink tubing and applying a bit of PWM. With the flick of a toggle, he can bypass the momentary buttons and use the yellow knob at the top to sweep through the pitch range with a single input.

Although he doesn’t hold your hand through the build, [lonesoulsurfer] has plenty of nice, clear pictures of the process that nearly give a step-by-step guide. That plus the video demo and walk-through should get you well on your way to DIY synthville.

If this all seems very cool, but you’d really like to understand what’s happening as you descend into the rabbit hole, our own [Elliot Williams]’s Logic Noise series is an excellent start.

source https://hackaday.com/2020/01/14/make-a-mean-sounding-synth-from-average-components/

The ability to get professionally manufactured PCBs, at least small ones, for dirt cheap has had a huge impact on the sort of projects we see around these parts. It’s getting to the point where experimenting with PCB enclosures is not only a way to make your next project stand out, but an economical choice.

Which is how this ESP8266 sensor gadget from [Josef Adamčík] got its unique “folded over” look. The top panel is where the microcontroller and headers for various sensors live, the bottom panel is home to the TP4056 USB charging module, and the center panel provides mechanical support as well as holds the single 18650 cell. Rather than close the whole thing up with a fourth panel, he decided to leave it open so the battery can easily be removed. Plus, of course, it looks cooler this way.

Could [Josef] have fit all his electronics on a single 100 x 100 PCB and then put the whole thing into a 3D printed enclosure? Well, sure. But that’s been done to death at this point, and besides, he was looking for an excuse to get more comfortable doing PCB design. We think it also makes for a considerably more visual appealing final product than simply taking the “normal” way out.

Currently [Josef] has an SHT21 humidity/temperature sensor and a BH1750 light sensor slotted into the headers on the top side of the device, but they could just as easily be swapped out with something else if you wanted to do something a bit more exciting. We notice that homebrew air quality monitors are becoming increasingly popular.

Building bespoke enclosures from PCBs is a fantastic trick that frankly we’d love to see more of. It’s somewhat of an artform in itself, but if you’re willing to put the effort in to do it right the results can be truly phenomenal.

source https://hackaday.com/2020/01/14/a-slightly-bent-esp8266-sensor-platform/

Modern home cinema equipment is well-equipped with features for interoperability and convenience, but in practice, competing standards and arcana can make it fall over. Sometimes, you’ve gotta do a little work on your own to glue it all together, and that’s what led [Victor] to develop a little utility of his own.

ChromecastControls is a tool that makes controlling your home cinema easier by improving Chromecast’s integration with the CEC features of HDMI. CEC, or Consumer Electronics Control, is a bidirectional serial bus that is integrated as a part of the HDMI standard. It’s designed to help TVs, audio systems, and other AV hardware to communicate, and allow the user to control an entire home cinema setup with a single remote. Common use cases are TVs that send shutdown commands to attached soundbars when switched off, or Blu-Ray players that switch the TV on to the correct output when the play button is pressed.

[Victor]’s tool allows Chromecast to pass volume commands to surround sound processors, something that normally requires the user to manually adjust their settings with a seperate remote. It also sends shutdown commands to the attached TV when Chromecast goes into its idle state, saving energy. It relies on the PyChromecast library to intercept traffic on the network, and thus send the appropriate commands to other hardware. Simply running the code on a Raspberry Pi that’s hooked up to any HDMI port on a relevant device should enable the CEC commands to get through.

It’s a project that you might find handy, particularly if you’re sick of leaving your television on 24 hours a day because Chromecast never bothered to implement a simple CEC command on an idle timeout. CEC hacks have a long history, too – we’ve been covering them as far back as 2010!

source https://hackaday.com/2020/01/14/better-controls-for-your-chromecast-through-cec/

Remember the WOPR from WarGames? The fictional supercomputer that went toe-to-toe with Matthew Broderick and his acoustic coupler was like a love letter to the blinkenlight mainframes of yesteryear, and every hacker of a certain age has secretly yearned for their own scaled down model of it. Well…that’s not what this project is.

The [Unexpected Maker] is as much a WarGames fan as any of us, but he was more interested in recreating the red alphanumeric displays that ticked along as the WOPR was trying to brute force missile launch codes. These displays, complete with their thoroughly 1980s “computer” sound effects, were used to ratchet up the tension by showing how close the supercomputer was to kicking off World War III.

Of course, most us don’t have a missile silo to install his recreated display in. So when it’s not running through one of the randomized launch code decoding sequences, the display doubles as an NTP synchronized clock. With the retro fourteen segment LEDs glowing behind the smoked acrylic front panel, we think the clock itself is pretty slick even without the movie references.

Beyond the aforementioned LEDs, [Unexpected Maker] is using a ESP32 development board of his own design called the TinyPICO. An associated audio “Shield” with an integrated buzzer provides the appropriate bleeps and bloops as the display goes through the motions. Everything is held inside of an understated 3D printed enclosure that would look great on the wall or a desk.

Once you’ve got your launch code busting LED clock going in the corner, and your illuimated DEFCON display mounted on the wall, you’ll be well on the way to completing the WarGames playset we’ve been dreaming of since 1983. The only way to lose is to not play the game! (Or something like that…)

source https://hackaday.com/2020/01/14/a-replica-from-wargames-but-not-the-one-you-think/

The modern ideal of pixel art is a fallacy. Videogame art crammed onto cartridges and floppy discs were beholden to the CRT display technology of their day. Transmitting analog video within the confines of dingy yellow-RCA-connector-blur, the images were really just a suggestion of on-screen shapes rather than clearly defined graphics. Even when using the superior RGB-video-over-SCART cables, most consumer grade CRT televisions never generated more than about 400 lines, so the exacting nature of digitized plots became a fuzzy raster when traced by an electron beam. It wasn’t until the late 90s when the confluence of high resolution PC monitors, file sharing, and open source emulation software that the masses saw pixels for the sharp square blocks of color that they are.

More importantly, emulation software is not restricted to any one type of display technology any more than the strata of device it runs on. The open-source nature of videogame emulators always seems to congregate around the Lowest Common Denominator of devices, giving the widest swath of gamers the chance to play. Now, that “L.C.D.” may very well be the Raspberry Pi 4. The single board computer’s mix of tinker-friendly IO at an astonishingly affordable entry price has made it a natural home for emulators, but at fifty bucks what options unlock within the emulation scene?

The Dubious Price Tag That’s  Still Quite Low, All-In

The technological gap between the Raspberry Pi 4 and its predecessor is sizeable. A 22% jump in clock speed, upwards of four times the RAM, and support for 4K resolution all while retaining the same footprint should not be undersold. Those advancements were coupled with a heightened 3A power requirement meaning extra cost as not just any PSU over USB-C will do. All those additional amps added up to a worryingly hot surface temperature anywhere from 50 to 80 °C on launch firmware. Even with updated firmware, any serious user will want an additional cooling solution in place. You will also shell out some clams for all the gaming accouterments: keyboard/gamepad, micro-HDMI cable, and flash storage. Ultimately the promise of an inexpensive emulation box fluctuates depending on the amount of pre-existing equipment. But even considering all of the add-ons, to have a dedicated gaming rig at this entry price is pretty incredible. The question is, what kind of gaming is possible?

When it comes to arcade game emulation on a Raspberry Pi, most users’ first stop is the RetroPie distribution. It provides a lightweight user interface that scales well on a variety of resolutions. RetroPie employs the use of advMAME v3.9 as its arcade machine emulation software. While plenty capable, advMAME is actually a port of MAME v0.108 which dates back to 2006. The bulk of emulators written in that time typically prioritized speed over accuracy in order to maintain playability, so the concept of a CRT filter or console chip-level cycle accuracy was hardly possible given the constraints of mid-2000s hardware. This example is not to denigrate any of the developers of advMAME or the RetroPie wrapper, but to point out that there is a cost to the relative convenience of a Raspberry Pi. If the proficiency of emulation is relegated to the era of the original Xbox, then why not use a Xbox instead? The rebuttal is simply two words… runahead mode. And the quad-core nature of the Pi 4 makes it particularly well suited for this.

Run (Kokiri) Forest, Run

For the uninitiated, Retroarch is a frontend that aggregates a large collection of emulation software and is part of retroPie. The development team behind Retroarch announced Raspberry Pi 4 support for a latency-reduction process known as runahead mode. Their description highlights the low-latency benefits of the effort: “The runahead feature calculates the frames as fast as possible in the background to rollback the action as close as possible to the input command requested.” Emulators can be resource intensive, soaking up all the available CPU horsepower and memory. Controller polling can fall out of sync with what is currently displayed on screen when a particular game sequence becomes more demanding. Things can get laggy.

Enabling Retroarch’s runahead mode on the select emulation cores for which it is available (Genesis Plus GX, Snes9x 2010, and VBA Next) can alleviate the input lag caused by the emulator itself.

When runahead mode is properly implemented on a Raspberry Pi 4, games control more-or-less as they did on the original hardware. This means losing a life in a run n’ gun the likes of Gunstar Heroes is solely due to user-error. On the other hand, turn based games in the vein of Final Fantasy are safe to play without runahead mode enabled. Those behemoths sure are patient folk.

It should be noted that this revolutionary feature is predicated upon being paired with a halfway decent LCD and wired gamepad/keyboard. Unfortunately, all the simultaneous instances of a game cannot overcome a poor pixel response time or a sub-par Bluetooth radio controller.

Optical Media Shifts Into View

For the first time in the Pi-lineage, there are multiple options for disc-based console emulators. Dreamcast, PSP, Saturn, and even PlayStation 2 cores via Retroarch v1.7.8 have all made their way onto Raspberry Pi 4. Granted the bulk of these systems do not run at full-speed quite yet, but there are some real overachievers still in their nascent beta forms. Specifically redream, a recently developed Sega Dreamcast emulator, has shown remarkable progress (video below) despite having no Raspberry Pi builds considered stable. Games play at or around sixty frames per second at a 720p resolution. The venerated Dolphin emulator (Gamecube/Wii) has even shown signs of promise running on the single board computer.

Beyond Gamecube, there are an array of arcade games that have only now been emulated due to their complexity and are not likely to run on a Raspberry Pi for years to come. Recreating the authentic 20th-century arcade experience may not be within reach in this form factor as more comprehensive emulators like the current iteration of MAME are simply too taxing to run currently. The yearly cadence of new Pi device revisions will prove difficult to retain developer’s attention, and further maturation of emulation software will only help alleviate a device’s lack of raw computing prowess. Runahead mode and access to previously inaccessible emulators certainly bolster the viability of the Raspberry Pi 4 as an all-in-one solution, though what’s most important is that these good ol’ games are being played at all.

source https://hackaday.com/2020/01/14/raspberry-pi-4-and-the-state-of-video-game-emulation/

Python is often touted as a great language for beginner coders to learn. Until recently, however, it simply wasn’t a viable choice in the embedded space. That’s begun to change with projects like CircuitPython, and now it’s available on the Teensy 4.0!

This milestone is thanks in part to [arturo182], who did the ground work of getting CircuitPython to run on the iMX RT series of microcontrollers. This was built upon by [tannewt], who is the lead in charge of the CircuitPython project.

There are some bugs to work out; currently, the project is in a very early stage of development. [Paul Stoffregen], who heads Teensy development, has already pointed out that there needs to be allowance for the 4096 byte recovery partition in the Teensy 4.0’s storage, for example. Development continues at a rapid pace, and those with ideas about where the project should go can weigh in online.

It’s an exciting development, which brings easy Python development to one of the more powerful embedded development platforms on the market. We look forward to seeing many more projects take advantage of the power of the Teensy 4.0 moving forward. If you’re eager to see what can be done with CircuitPython, be sure to check out projects we’ve featured before. Video after the break.

source https://hackaday.com/2020/01/14/circuitpython-now-working-on-teensy-4-0/