Now is an amazing time to be involved in the hobby electronics scene. There are robots to build, cheap microcontrollers which are easy to program, and computers themselves are able to be found for very low prices. That wasn’t the case in the 1960s though, where anyone interested in “electronics” might have had a few books about ham radios or some basic circuits. If you were lucky though, you may have found a book from 1968 that outlined the construction of a digital computer made out of paperclips that [megardi] is hoping to replicate.

One of the first components that the book outlines is building an encoder, which can convert a decimal number to binary. In the original book the switches were made from paperclips and common household parts, but [megardi] is using a more reliable switch and some 3D prints to build his. The key of the build is the encoder wheel and pegs, which act as the “converter” between decimal and binary and actually performs the switching.

It’s a fairly straightforward build, but by working through the rest of the book the next steps are to build two binary encoders and hook all of them up to an ALU which will give him most of a working computer from long lost 1960s lore. He’s been featured recently for building other computers from this era as well.

Thanks to [DancesWithRobots] for the tip!

source https://hackaday.com/2019/12/17/simple-computer-from-the-60s-now-3d-printed/

Piloting a boat is all well and good, but can get dull when you’d rather be reclining on the deck with a cold beverage in hand. For [Timo Birnschein], this simply wouldn’t do. He began to gather parts to put together an autopilot to keep his boat on the straight and narrow.

The build is based around OpenPlotter, which uses a battery of marine-ready software to handle routing charts, autopiloting, and providing a compass heading for navigation. Naturally, it all runs on a Raspberry Pi. In combination with PyPilot, it can be used to let the vessel drive itself around a series of waypoints, allowing you to soak up the atmosphere on the water without having to constantly steer the craft.

[Timo] ran into some issues, however, with the hardware side of things. Existing implementations for motor control to drive the rudder weren’t quite cutting it, so the system was reworked to run with a robust H-bridge and some fresh Arduino code. This was combined with a custom rudder sensor built with a potentiometer and some 3D printed gears. Future work aims to double up the rudder sensors for redundancy, something we should all consider at times.

Overall, the system is starting to come together, and [Timo]’s enjoying letting his boat think for itself. He notes that it’s very important to keep an eye on the boat while operating in this condition, lest it veer off course – many a boat has been lost this way. We’re always supporters of a mature attitude towards autonomous vehicle operations!

source https://hackaday.com/2019/12/17/an-open-source-boating-autopilot-with-some-custom-tweaks/

PCB rework for the purpose of fixing unfortunate design problems tends to involve certain things: thin wires (probably blue) to taped or glued down components, and maybe some areas of scraped-off soldermask. What are not usually involved are flexible PCBs, but [Paul Bryson] shows us exactly how flex PCBs can be used to pull off tricky rework tasks.

It all started when [Paul] had a run of expensive PCBs with a repeated error; a design mistake that occurred in several places in the board. Fixing with a bunch of flying wires leading to some glued-on components just wasn’t his idea of tidy. A more attractive fix would be to make a small PCB that could be soldered in place of several of the ICs on the board, but this idea had a few problems: the space available into which to cram a fix wasn’t always the same, and the footprints of the ICs to be replaced were too small to accommodate a PCB with castellated mounting holes as pads anyway.

It’s about then that he got a visit from the Good Idea Fairy, recalling that fab houses have recently offered “flex” PCBs at a reasonable cost. By mounting the replacement parts on a flex PCB, the board-level connection could reside on the other end of an extension. Solder one end directly to the board, and the whole flexible thing could be bent around or under on a case-by-case basis, and secured in whatever way made sense. Soldering the pads of the flex board to the pads on the PCB was a bit tricky, but easy enough to pull off reliably with a bit of practice. A bonus was that the flex PCB is transparent, so solder bridges are easy to spot. He even mocked up a solution for QFP packages that allows easy pin access.

Flex PCBs being available to hobbyists and individuals brings out fresh ideas and new twists on old ones, which is why we held a Flexible PCB Design Contest earlier this year. Repairs were definitely represented as applications, but not to the extent that [Paul] has shown. Nice work!

source https://hackaday.com/2019/12/17/tidy-board-rework-uses-flex-pcbs-no-wires/

[Ioszelos] built a nixie clock with a dizzying array of features.

Do you ever wish that you could log in to your clock from your phone and turn off your TV? We assume that [Ioszelos] did. The clock can also play MP3s and stream radio stations. It can record the indoor temperature, humidity, and barometric pressure. Did we mention it’s an FM radio too? We’re not sure, but we wouldn’t be surprised if there was a faucet hiding somewhere on the contraption.

A team effort shared between an ESP32 and Mega 2560 run the Rube Goldberg-like show. Custom boards were spun up to provide the control and voltages needed for the nixie tubes. The clock is constructed from machined plates and 3D printed files.

It all comes together in a steampunk reminiscent assembly. The glow from the RGB leds and nixie tubes combine to make an interesting visual effect. We’ve certainly never seen a clock quite like it before.

source https://hackaday.com/2019/12/17/a-nixie-radio-clock-fit-for-a-victorian-mad-scientist/

If you connect to remote computers over the Internet, it is a pretty good chance you use some form of SSH or secure shell. On Linux or Unix you’ll use the ssh command. Same goes for Linux-like environments on Windows like Cygwin or WSL. For native Windows, you might be using Putty. In its simplest form, ssh is just a terminal program that talks to a server using an encrypted connection. We think it is very hard to eavesdrop on anyone communicating with a remote computer via ssh.

There are several tricks for using ssh — some are pretty straightforward and some are things you might not think of as being in the domain of a terminal program. You probably know that ssh can copy files securely, and there are easy and hard ways to set up logging in with no password.

However, you can also mount a remote filesystem via ssh (actually, there are several ways to do that). You can use ssh to securely browse the web in your favorite browser, or even use it to tunnel specific traffic by port or even use it as a makeshift VPN. In fact, there’s so much ground to cover that this won’t be the last Linux Fu to talk about ssh. But enough setup, let’s get to the tricks.

A Few Good Options

We’ll assume you know the basics: scp and sftp for file copies and ssh-copy-id for setting up password-less login. (If not, you have ten minutes to do a quick web search.) But one of the things ssh is great at is manipulating the network. Keep in mind, though, that the server has to have certain options set to do some of the most interesting things, so if you don’t control the ssh server, some of these tricks might not work for you.

There are a lot of options to remember on the ssh command line, but luckily you don’t have to. You don’t even have to remember your hostname or user name. In the ~/.ssh/config file you can create an alias. For example, suppose you want to connect to your home server:

Host homeserver
  HostName mih0me.dyndns.org
  Port 1234
  User TheAl
  IdentityFile ~/.ssh/home_id
  ForwardX11 yes
  Compression yes
  TCPKeepAlive yes

You can have as many aliases as you like. Just keep repeating the Host line and then follow it with options. You can also add more than one alias to a single Host statement. The subsequent options will then apply to any of the aliases. Now to connect just issues ssh homeserver and you are in with all the right options.

Of course, if you are using Putty, your options will mainly be in the host profile and on the ssh panel of the options screen. You might not get as many options, but there are some you can try.

Be Persistent

One really nice set of options to include set the master control file. For example:

ControlMaster auto
ControlPath ~/.ssh/master-%r@%h:%p

This lets multiple sessions to the same host share a single TCP socket. Because it takes a some time to set up a secure socket, this can be speed things up if you keep several sessions going between two hosts. You can set it for all hosts by using the Host * line in the config file. You can use that for any global options you might have.

On the other hand, if you shove a lot of data over multiple connections, turning on ControlMaster might not be a great idea. You can add -S none to override the global setting.

One other thing to note is that your first ssh session might appear to hang if you try to exit it before all the other connections are closed. Some people deliberately run a hidden ssh session on login to a host they often connect to which avoids that problem. However, a better way is to set ControlPersist to yes. That will cause the original session to go to the background indefinitely. If you want a little grace period you can set ControlPersist to a number like 180. That would cause the background session to end if there are no connections for three minutes.

Another downside to this approach is that you tend to get orphaned master files. In rc.local I have the following line:

/bin/rm /home/*/.ssh/master-* || true >/dev/null

 

With Putty, you can click the “Share SSH connections if possible” button in the SSH options panel.

Configuration

There are quite a few configuration options you can use in the config file. For example, BatchMode lets you tell ssh the connection is made for unattended use so don’t bother prompting the user for passwords or anything else. That’s not to say it will just let you in, of course. It just means it will fail if you don’t have things set up to login without a password.

There are some other interesting items. For example, you can run a local or remote command on connection. You can also send an environment variable to the remote host or even just set one. For example, suppose you want to always keep your LS_COLORS the same on your workstation and the server, but you frequently change them and don’t want to use the same profiles.  You could add this to the host’s config file entry:

SendEnv LS_COLORS

The server has to be configured to accept this, of course. Putty can handle setting an environment variable from the Data tab in its setup.

On the network side, you can specify TCPKeepAlive to yes if you want the server and client to test their connection during idle periods. This is a two-edged sword. If the connection is idle, you won’t get disconnected. But if the network drops at the right moment for a brief period you might get disconnected where you wouldn’t have if you had stuck with the default. There’s even a way to open a layer 3 or layer 2 tunnel between the machines — a topic for a future Linux Fu.

By Your Command

Don’t forget that ssh can execute a command and send its output to you. As a practical example, I occasionally reflash my 3D printer firmware. The printer is connected to a Raspberry Pi, but I do the firmware build on my main machine. For a long time, I copied my file to the Pi (using scp) and then logged into the Pi to run a script I wrote called flash. The script disables the Reptier server software, flashes the Atmel chip on the printer control board, and then turns the server back on.

Here’s the script that runs on my main computer. Note the ssh commands. One turns off the server. One scp command copies the new firmware over. Then another ssh does the flash and renables the server. There are many other ways to do this, of course. But don’t forget that ssh can run a remote command and then return.

#!/bin/bash
if [ -z "$1" ]
then
  echo Usage: flash hexfile [remote_name]
  echo If omitted, remote_name will have date attached
  exit 1
fi
ONAME="$2"
EXTRA=$(date "+%Y%m%d.%H%M")
if [ -z "$2" ]
then
  $2="$1-$EXTRA.hex"
fi
IP=192.168.1.110
  echo Stop Server
  ssh -l pi $IP "sudo systemctl stop RepetierServer"
  echo Copy...
  scp "$1" "pi@$IP:a8fw/$ONAME"
  echo Flashing...
ssh pi@$IP "cd a8fw; ./flash $ONAME"
echo Restart
ssh "pi@$IP" "sudo systemctl start RepetierServer"
echo Done
exit 0

If you want a more hacker-friendly example, consider using the same idea to run Wireshark locally and analyze a remote packet capture:

ssh root@someserver 'tcpdump -c 1000 -nn -w - not port 22' | wireshark -k -i -

You can do the same trick with tshark, if you prefer.

Speed Test

What to know how fast your ssh connection is? Make sure you have pv installed and try this:

yes | pv | ssh remote_host "cat >/dev/null"

Pretty cool!

If you have good speeds — or even if you don’t — you can try mounting a remote file system using sshfs. This is a FUSE filesystem — that is, a filesystem that lives as a regular user program, not part of the kernel. With nothing on the remote side but the ssh server and standard tools, you can make any host you can connect to look like a local file system.

But Wait…

There’s a lot more you can do with ssh, and I’ll cover more shortly. But for now, hopefully you found at least one ssh trick you can use that was, if not new, at least a reminder for you.

source https://hackaday.com/2019/12/17/linux-fu-stupid-ssh-tricks/

Time is tricky, and it’s only gonna get worse when we become a multi-planet species. Fortunately, [Folkert van Heusden] has a clock ready for what may be our second home with the Mars Clock. This simple build shows the current time on Mars, using the Martian calendar that NASA uses for their planetary probes.

This calendar, called Mars 24, was designed by [Michael Allison] of NASA back in 1998, and is used by the current batch of Martian probes. You can’t just use an Earth clock on Mars because a Martian day is 24 hours and 39 minutes. Instead, [Michael] created a new calendar based on the rotation and orbit of Mars that also allows you to calculate sunrise and sunsets, which is vital for a probe that uses solar power. It is based on the same breakdown of time, with 24 hours, 60 minutes and 60 seconds, but each of these is slightly longer than the Earth equivalent.

[Folkert] tool the example formulas that NASA themselves provide for calculating Mars 24 time, and wrote an Arduino program that converts Earth to Mars 24 time. This then drives an LED ring that indicates the hour in (appropriately enough) red, the minute in green and the second in blue. This is then mounted on a wooden plate and case that he created with Makercase, a neat site that creates plans for wood laser-cut cases.

It’s a neat, simple build overall, although I would like to see one addition: a switch to go between Earth and Mars time. And perhaps a heat ray attachment that will assist the inevitable victory of our new Martian overlords.

 

source https://hackaday.com/2019/12/17/what-time-is-it-on-mars/

Can you imagine a near future where your family doctor can effectively prick your finger and test you for a dozen or so types of cancer? Currently, cancer detection is a time-consuming and expensive process. Existing methods of screening for cancer usually involve taking a whole lot of blood and running tests that cost thousands of dollars. But Toshiba has created a cancer-detecting machine that sounds like something straight out of science fiction.

The machine is about the size of a small office copier, and it looks like one, too. But this small machine can do some powerful tricks. Toshiba claims that the machine can detect 13 types of cancer from a single drop of blood with 99% accuracy. What’s more impressive is that it can do this under two hours, as opposed to days or weeks depending on laboratory backlog. Most importantly, they are aiming to do this entire battery of tests for about $180. Ideally, this machine will do everything that current blood cancer detection equipment does, just better, faster, and with fewer resources.

Some of the cancers the machine can test for have been previously difficult to detect, like ovarian, pancreatic, and esophageal cancer. But this machine can screen for all three of these  — great news for early detection of these ravaging cancers — as well as breast, prostate, gastric, colon, liver, biliary tract, bladder, lung, brain, and sarcoma. The only catch is that the machine can’t pinpoint which cancer exactly, it only knows if microRNA one or more of the 13 came up.

So, how does it work? Cancer cells secrete certain types of microRNA into the bloodstream that healthy cells don’t. The machine works by assessing the different types of microRNA that show up in the sample drop, and studying their concentrations. Their work builds on that of Toray Industries, who announced earlier this year that they had made a cancer-detection chip based on microRNA accumulation that is 95% accurate. Development of this chip follows on the heels of research that finds testing for microRNA in bloodwork has the potential to detect cancers in earlier stages, and in some cases like for bowel cancer, with a much less invasive testing procedure.

Toshiba, in partnership with the National Cancer Center Research Institute and Tokyo Medical University will conduct a trial of the machine next year. If the trial is successful, they hope to commercialize it soon after.

source https://hackaday.com/2019/12/17/this-machine-is-poised-to-join-the-fight-against-cancer/

We’ve seen some pretty big polymer 3D printers, but nothing quite as big as the University of Maine’s 3D printer with a 22,000 ft³  (623 m³) build volume. It holds the Guinness World Record for the largest polymer 3D printer, and with that size comes some interesting challenges and advantages.

You might have already seen the video of it printing an entire patrol boat hull in a single piece, and would have noticed how it printed at a 45° angle. Due to the sheer weight and thermal mass of the print bead, it cannot bridge more than an inch, since it’ll just sag. A 45° overhang angle is about all it can manage, but since the layers can be tilted at that angle, it ends up being able to print horizontal roofs with no support. A 10 mm nozzle is used and the extruded line ends up being 12.5 mm in diameter with a 5 mm layer height. The boat mentioned above was printed with carbon ABS, but it can reportedly use almost any thermoplastic. It looks like the extruder is a screw extruder from an injection moulding machine, and is likely fed with pellets, which is a lot more practical than filament at this scale. Check out the video below by [Paul Bussiere] who works in the Advanced Structures & Composites Center at the University. He also does a very interesting interview with his boss, [James M. Anderson].

The 45° layer angle is very similar to how some infinite build volume 3D printers work. For something more within the reach of the average hacker, check out the tool changing Jubilee.

 

source https://hackaday.com/2019/12/17/humongous-3d-printer-produces-boat-and-challenges/

We’re going to go out on a limb here and say that wherever you are now, a quick glance around will probably reveal at least one LED. They’re everywhere – we can spot a quick half dozen from our desk, mostly acting as pilot lights and room lighting. In those contexts, LEDs are pretty mundane. But what if a little more flash could be added to the LEDs of the world – literally?

That’s the idea behind LightAnchors, which bills itself as a “spatially-anchored augmented reality interface.” LightAnchors comes from work at [Chris Harrison]’s lab at Carnegie Mellon University which seeks new ways to interface with computers, and leverages the ubiquity of LED point sources and the high-speed cameras on today’s smartphones. LightAnchors are basically beacons of digitally encoded data that a smartphone can sense and decode. The target LED is modulated using amplitude-shift keying and each packet contains a data payload and parity bits along with a pre- and post-amble sequence. Software on the phone uses the camera to isolate the point source, track it, and pull the data out of it, which is used to create an overlay on the scene. The video below shows a number of applications, ranging from displaying guest login credentials through the pilot lights on a router to modulating the headlights of a rideshare vehicle so the next fare can find the right car.

An academic paper (PDF link) goes into greater depth on the protocol, and demo Arduino code for creating LightAnchors is thoughtfully provided. It strikes us that the two main hurdles to adoption of LightAnchors would be convincing device manufacturers to support them, and advertising the fact that what looks like a pilot light might actually be something more, but the idea sure beats fixed markers for AR tracking.

source https://hackaday.com/2019/12/17/modulated-pilot-lights-anchor-ar-to-real-world/

We admit that a hack enabling a 34-year-old video game peripheral to be controlled by a mobile app wasn’t something we were expecting to see today, but if controlling something with something else isn’t the definition of a classic hack, we don’t know what is. The folks at [Croxel Inc.] worked out a way to control R.O.B. using a phone app to demo out their expertise in building hardware and software prototypes, a service they offer at their website.

R.O.B. was a little robot with movable clamp arms bundled with the 1985 release of the NES, an effort by Nintendo of America to drive sales of the console after the gaming crash of 1983 by making it look less like a video game and more like a toy. The robot receives inputs from light sensors in its head, which would be pointed towards the TV playing one of the only two games released with support for it. [Croxel] used this to their advantage, and in order to control the robot without needing a whole NES, they fabricated a board using a BGM111 Bluetooth Low-Energy module which can receive outside inputs and translate them to the light commands the robot recognizes.

To avoid having to modify the rare toy itself and having to filter out any external light, the hack consists of a 3D printed “goggles” enclosure that fits over R.O.B.’s eyes, covering them entirely. The board is fitted inside it to shine the control light into its eyes, while also flashing “eye” indicators on the outside to give it an additional charming 80s look. The inputs, which are promptly obeyed, are then given by a phone paired to the module using a custom app skinned to look like a classic NES controller.

We’ve seen more intrusive hacks to this little robot here on Hackaday, such as this one which replaces the old sluggish motors entirely with modern servos and even plans to reconstruct it from scratch given the scarcity of the originals. It’s interesting to see the ways in which people are still hacking hardware from 35 years ago, and we’re excited to see what they’ll come up with around the 40 or 50 year marks!

[via Gizmodo, thanks Itay for the tip!]

source https://hackaday.com/2019/12/16/3d-printed-goggles-let-r-o-b-see-into-the-bluetooth-world/

In our opinion, the primary evidence of a properly lived childhood is an enormous box of every conceivable Lego piece, from simple bricks to girders and gears, all with a small town’s worth of minifigs swimming through it. It takes years of birthdays and Christmases to accumulate a Lego collection best measured by the pound, but like anything worth doing, it’s worth overdoing.

But what to do with such a collection? Digging through it to find Just the Right Piece can be frustrating, and bringing order to the chaos with manual sorting is just so impractical. How about putting some of those bricks to work with a machine-vision Lego sorter built from Lego?

[Daniel West]’s approach is hardly new – we’ve even featured brick-built Lego sorters before – but we’re impressed by its architecture. First, the mechanical system is amazing. It uses a series of conveyors to transport bricks from a hopper, winnowing the stream down as it goes. The final step is a vibratory feeder that places one piece on a conveyor at a time. Those pass under a camera attached to a Raspberry Pi, where OpenCV does background subtraction from the video stream, applies bounding boxes to the parts, and runs the images through a convolutional neural network (CNN) that’s been trained on a database of every Lego part. Servo-controlled gates then direct the parts into one of 18 bins. See it in action in the video below.

We must admit that we’re not sure what the sorting criteria are, as some bins seem nearly as chaotic as the input mix. Still, we appreciate the fine engineering, and award extra style points for all the Lego goodness.

[via The Verge]

Thanks to [my wife] for the tip.

source https://hackaday.com/2019/12/16/lego-machine-uses-machine-learning-to-sort-itself-out/

We would love to be a fly on the wall Christmas morning to see [Wilksyonreddit]’s kid tear the paper off of this adult-level busy box. Can you imagine the unbridled glee? It should certainly make the arduous six-month build worth the trouble. Here’s hoping the walls are sturdy, because we predict they will be bounced off of.

This gift that keeps on giving has an Arduino MEGA clone inside and a couple of shift registers to deal with all those buttons and switches. In addition to all the buttons, switches, and the number pad, there are two 3D-printed touch sensor pads that can detect little fingers up to four inches away. Although he’s already built a few games and activities for it, [Wilksy] posted this in r/duino looking for more ideas. There’s a lot to work with here on baby’s first nuclear missile launch console, both input- and output-wise. We humbly suggest 4D Simon, though we must admit to fantasizing about MIDI controllers.

Hidden inside this Christmas present is an Easter egg we think you’ll appreciate. Enter the right code, and the box becomes a treasure trove of Back to the Future sound effects and audio clips. Video’s after the break, McFly.

This box would make a great Kerbal Space Program controller, too, like this one.

 

 

source https://hackaday.com/2019/12/16/busy-box-beats-babys-boredom/

[Mark Omo] sends in his write up on the design of what should hopefully be a sub-$100 oscilloscope in a probe. 

Many problems in engineering can be solved simply by throwing money at the them. It’s really when you start to apply constraints that the real innovation happens. The Probe-Scope Team’s vision is of a USB oscilloscope with 60MHz bandwidth and 25Msps. The cool twist is that by adding another probe to a free USB port on your computer you’re essentially adding a channel. By the time you get to four you’re at the same price as a normal oscilloscope but with an arguably more flexible set-up.

The project is also open source. When compared to popular oscilloscopes such as a Rigol it has pretty comparable performance considering how many components each channel on a discount scope usually share due to clever switching circuitry.

The probe is based around an Analog Devices ADC whose data is handled by a tag team of a Lattice FPGA and a 32bit PIC micro controller. You can see all the code and design files on their github. Their write-up contains a very thorough explanation of the circuitry. We hope they keep the project momentum going!

source https://hackaday.com/2019/12/16/how-to-design-a-low-cost-probe-oscilloscope/

Digital electronics are all well and good, but it’s hard to ignore the organic, living qualities of the analog realm. It’s these circuits that Kelly Heaton spends her time with, building artistic creations that meld the fine arts with classic analog hardware to speak to the relationship between electronics and nature. During her talk at the 2019 Hackaday Superconference, Kelly shared the story of her journey toward what she calls Electronic Naturalism, and what the future might bring.

Kelly got her start like many in the maker scene. Hers was a journey that began by taking things apart, with the original Furby being a particular inspiration. After understanding the makeup of the device, she began to experiment, leading to the creation of the Reflection Loop sculpture in 2001, with the engineering assistance of Steven Grey. Featuring 400 reprogrammed Furbys, the device was just the beginning of Kelly’s artistic experimentation. With an interest in electronics that mimicked life, Kelly then moved on to the Tickle Me Elmo. Live Pelt (2003) put 64 of the shaking Muppets into a wearable coat, that no doubt became unnerving to wear for extended periods.

Analog electronics parallel living organisms while programmable logic merely simulates life.

—Forrest Mims

Wanting to create art with a strong relationship to organic processes, Kelly focused on working with discrete components and analog circuitry. Basic building blocks such as the astable multivibrator became key tools that were used in different combinations to produce the desired effects. Through chaining several oscillators together, along with analog sequencers, circuits could be created that mimicked the sound of crickets in a backyard, or a Carolina wren singing in a tree.

The work didn’t stop at a few sound effects, however. These circuits were woven into paintings, with individual components playing both a functional role and a visual role in the piece itself. What followed was a series of paintings featuring circuits to create the sounds of the animal depicted. Other projects were more sculptural, such as the transparent mylar constructions of Birds At My Feeder (2019), or the noisemaking worker bees of Pollination (2015). The electronics itself, from the oscillators to the analog sequencers used to drive them, becomes part of the artwork itself. Kelly refers to the hardware as beautiful, and it’s a feeling recognised by many who can recall their first time peering inside the mysterious innards of a disassembled radio or television set.

Coming from a fine arts background, rather than an electronic one, there was plenty of learning to be done along the way. Kelly spent plenty of time in the MIT Media Lab, picking up things at a fast pace as you’d expect at one of the world’s premier hacker universities. During the production of The Parallel Series (2012), Kelly realised she was struggling to keep track of how her experiments worked, leading to a note scrawled in the corner of one piece: “I need to document these circuits for my own sanity”. Any maker that’s come back to a mess of wires on a breadboard after a few weeks away can relate to this experience. Kelly’s process also developed over the years, becoming more analytical. The sounds of various creatures were analysed for pitch, timbre, and tempo, to help guide the work to recreate them in analog hardware.

Kelly’s work goes beyond simple analog oscillators. Through years of tinkering, she’s learned many tips and tricks to creating a pleasing and thought-provoking artwork. Repetitive sounds can be annoying, even if they are a decent facsimile of one of Mother Nature’s creations. To temper this, and add in a little realism, randomness is introduced into trigger circuits to make them sound more natural. Often achieved with something as simple as the base of a transistor left unconnected, when filtered, this can act as a great way to organically recreate the sound of a field of crickets chirping at each other in the night.

Much of the work is done on breadboards, making experimentation easy. As the components used are cheap and readily available, there’s little harm to be done, with the worst mistakes causing at maximum, a few dollars in damage. The stacking and reconfiguration of various analog oscillators in this work draws parallels to the world of modular synthesizers, a world we’re sure Kelly would also enjoy exploring.

Overall, it’s a great talk that covers the journey of creating artworks that blend the traditional and the electronic. Kelly’s art has been celebrated and displayed in a wide variety of locations, and it’s inspiring to get a look at the process behind the creations.

source https://hackaday.com/2019/12/16/kelly-heatons-artwork-blurs-the-line-between-traditional-and-electronic/