Adding 3D Printer Power and Light Control to OctoPrint

OctoPrint is a great way to monitor your printer, especially with the addition of a webcam. Using a tablet or mobile phone, you can keep an eye on what the printer is doing from anywhere in the house (or world, if you take the proper precautions), saving you from having to sit with the printer as if it’s an infant. But simply watching your printer do its thing is only a small slice of the functionality offered by OctoPrint’s vast plugin community.

As [Jeremy S Cook] demonstrates, it’s fairly easy to add power control for the printer and auxiliary lighting to your OctoPrint setup. Being able to flick the lights on over the print bed is obviously a big help when monitoring it via webcam, and the ability to turn the printer off can provide some peace of mind after the print has completed. If you’re particularly brave it also means you could power on the printer and start a print completely remotely, but good luck if that first layer doesn’t go down perfectly.

In terms of hardware, you only need some 3.3V relays for the Raspberry Pi running OctoPrint to trigger, and an enclosure to put the wiring in. [Jeremy] uses only one relay in this setup to power the printer and lights at once, but with some adjustment to the software, you could get independent control if that’s something you’re after.

On the software side [Jeremy] is using an OctoPrint plugin called “PSU Control”, which is actually intended for controlling an ATX PSU from the Pi’s GPIO pins, but the principle is close enough to throw a relay. Other plugins exist which allow for controlling a wider away of devices and GPIO pins if you want to make a fully remote controlled enclosure. Plus you can always whip up your own OctoPrint plugin if you don’t find anything that quite meets your switching needs.

[Jeremy] previously documented his unique mount to keep his Raspberry Pi and camera pointed at his printer, which is naturally important if you want to create some cool videos with Octolapse.

Continue reading “Adding 3D Printer Power and Light Control to OctoPrint”

Save Some Steps with this Arduino Rapid Design Board

We’re all familiar with the wide variety of Arduino development boards available these days, and we see project after project wired up on a Nano or an Uno. Not that there’s anything wrong with that, of course, but there comes a point where some hobbyists want to move beyond plugging wires into header sockets and build the microcontroller right into their project. That’s when one generally learns that development boards do a lot more than break the microcontroller lines out to headers, and that rolling your own design means including all that supporting circuitry.

To make that transition easier, [Sean Hodgins] has come up with a simple Arduino-compatible module that can be soldered right to a PCB. Dubbed the “HCC Mod” for the plated half-circle castellations that allows for easy soldering, the module is based on the Atmel SAMD21 microcontroller. With 16 GPIO lines, six ADCs, an onboard 3.3 V regulator, and a reset button, the module has everything needed to get started — just design a PCB with the right pad layout, solder it on, and surround it with your circuitry. Programming is done in the familiar Arduino IDE so you can get up and running quickly. [Sean] has a Kickstarter going for the modules, but he’s also releasing it as open source so you’re free to solder up your own like he does in the video below.

It’s certainly not the first dev module that can be directly soldered to a PCB, but we like the design and can see how it would simplify designs. [Sean] as shown us a lot of builds before, like this army of neural net robots, so he’ll no doubt put these modules to good use.

Continue reading “Save Some Steps with this Arduino Rapid Design Board”

General Purpose I/O: How to get more

The first program anyone writes for a microcontroller is the blinking LED which involves toggling a general-purpose input/output (GPIO) on and off. Consequently, the same GPIO can be used to read digital bits as well. A traditional microcontroller like the 8051 is available in DIP packages ranging from 20 pins to 40 pins. Some trade the number of GPIOs for compactness while other devices offer a larger number of GPIOs at the cost of complexity in fitting the part into your design. In this article, we take a quick look at applications that require a larger number of GPIOs and traditional solutions for the problem.

A GPIO is a generic pin on an integrated circuit or computer board whose behavior, including whether it is an input or output pin, is controllable by the user at runtime. See the internal diagram of the GPIO circuit for the ATmega328 for reference.

Simply put, each GPIO has a latch connected to a drive circuit with transistors for the output part and another latch for the input part. In the case of the ATmega328, there is a direction register as well, whereas, in the case of the 8051, the output register serves as the direction register where writing a 1 to it sets it in output mode.

The important thing to note here is that since all the circuits are on the same piece of silicon, the operations are relatively fast. Having all the latches and registers on the same bus means it takes just one instruction to write or read a byte from any GPIO register.
Continue reading “General Purpose I/O: How to get more”

Pocket-size Pi Zero Desktop features e-paper Display

[Ramin Assadollahi] uses his Raspberry Pi Zero W as a self-contained mobile desktop, connecting to it over VNC from another computer when he wants to hack away at some code or work on a new project. But he often found himself wishing there was some convenient way of displaying pertinent into right on the device, such as what IP address the Pi Zero had pulled. Then he found the 2.13 inch e-Paper HAT for the Pi Zero from Waveshare, and it all clicked into place.

The final device, which he refers to as the StickPi, combines a Pi Zero W, the Waveshare e-Paper display, and a strip of protoboard featuring a few tactile buttons, all inside of a 3D printed case. To really get the most out of the internal volume of his case, [Ramin] soldered the header pins to the Pi Zero in the middle, allowing him to create a space-saving “sandwich” out of all the components.

With the e-Paper display, [Ramin] now has a way to show information on the device itself without having to connect to it over the network. But thanks to the tactile switches on the back connected to the Pi’s GPIO, he also has six programmable buttons that could do anything he wants.

In the most basic implementation, each button could execute a command or script on the Pi. But [Ramin] has something a little more advanced in mind. In the video after the break, he explains that his next step is going to be working on an actual user interface for the Pi’s e-Paper screen, making use of the roughly gamepad style layout of the rear buttons. A “paged” interface with scrolling options would allow the user to perform all sorts of functions quickly and easily, and we’re looking forward to seeing what he comes up with.

This isn’t the first time we’ve seen somebody try to turn the Pi Zero into a more mobile-friendly platform, and the construction method here actually reminds us of a much smaller version of the Zero Phone.

Continue reading “Pocket-size Pi Zero Desktop features e-paper Display”

Linux Adds CH341 GPIO

There was a time when USB to serial hardware meant one company: FTDI. But today there are quite a few to choose from and one of the most common ones is the WCH CH341. There’s been support for these chips in Linux for a while, but only for use as a communication port. The device actually has RS232, I2C, SPI, and 8 general purpose I/O (GPIO) pins. [ZooBaB] took an out-of-tree driver that exposes the GPIO, and got it working with some frightening-looking CH341 boards.

He had to make a slight mod to the driver to get six GPIOs in /sys/class/gpio. Once there though, it is easy to manipulate the pins using a shell script or anything that can write to the virtual files corresponding to the GPIO pins.

Continue reading “Linux Adds CH341 GPIO”

Blast From the Past with Space Station PROM Reader

The Ursa Major Space Station SST282 is a dinosaur of a digital reverb.  Okay, so maybe 1978 isn’t ancient yet, but it is getting to the point where one has to worry about the possibility of component failure.  At least that’s what [Obsoletetechnology] thought when they created a backup of its memory contents.

As can be seen from some of Hackaday’s previous articles, a part does not have to be an older one to fail.  However, there is no such thing as being too paranoid when it comes to older parts reaching their lifetime.  Especially when there is valuable memory involved.  Each bit of PROM memory is locked by a fuse on its location grid to store permanent data.  To be able to read this and collect the respective data, a Raspberry Pi 3 PROM reader was created.

The SST282 uses 3 TTL-level 74xx series Schottky PROM memories on board that hold RAM lookup tables.  In the case that these failed, all of the subsequent information would be lost since there are no surviving memory dumps online.  Fortunately we are interested only in gathering their contents, so the PROM reader schematic is fairly rudimentary.  The chip’s address and data buses connect to a Pi’s GPIO header, and the only other thing to note is a 74LS541 TTL level shifter that converts the Pi’s 3.3V output to the PROM’s 5V TTL level.

Continue reading “Blast From the Past with Space Station PROM Reader”

Know the Load with this Simple Microcontroller CPU Meter

How do you tell how much load is on a CPU? On a desktop or laptop, the OS usually has some kind of gadget to display the basics. On a microcontroller, though, you’ll have to roll your own CPU load meter with a few parts, some code, and a voltmeter.

We like [Dave Marples]’s simple approach to quantifying something as complex as CPU load. His technique relies on the fact that most embedded controllers are just looping endlessly waiting for something to do. By strategically placing commands that latch an output on while the CPU is busy and then turn it off again when idle, a PWM signal with a duty cycle proportional to the CPU load is created. A voltage divider then scales the maximum output to 1.0 volt, and a capacitor smooths out the signal so the load is represented by a value between 0 and 1 volt. How you display the load is your own choice; [Dave] just used a voltmeter, but anything from an LED strip to some kind of audio feedback would work too.

Still just looking for a load meter for your desktop? Take your pick: an LED matrixold-time meters, or even Dekatrons.