When using an Arduino, at least once you’ve made it past blinking LEDs, you might start making use of the serial connection to send and receive information from the microcontroller. Communicating with the board while it’s interacting with its environment is a crucial way to get information in real-time. Usually, that’s as far as it goes, but [Pieter] wanted to take it a step farther than that with his command line interpreter (CLI) for the Arduino.
The CLI allows the user to run Unix-like commands directly on the Arduino. This means control of GPIO and the rest of the features of the microcontroller via command line. The CLI communicates between the microcontroller and the ANSI/VT100 terminal emulator of your choosing on your computer, enabling a wealth of new methods of interacting with an Arduino.
The CLI requires a hex file to be loaded onto the Arduino that you can find at a separate site, also maintained by [Pieter]. Once that’s running, you can get all of that sweet command line goodness out of your Arduino. [Pieter] also has some examples on his project page, as well as the complete how-to to get this all set up and running. There’s a lot going on in the command line world, in Linux as well as windows. So there’s plenty to explore there as well.
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”
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”
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”
[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”
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”
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”