Create Your RTL Simulations With KiCAD

[Bob Alexander] is in the process of designing a homebrew discrete TTL CPU, and wanted a way to enter schematics for digital simulations via a Verilog RTL flow. Since KiCAD is pretty good at handling hierarchical schematics, why not use that? [Bob] created a KiCAD plugin, KiCadVerilog allowing one to instantiate and wire up the circuits under consideration, and then throw the resulting Verilog file at your logic simulator of choice.

KiCadVerilog doesn’t do all the hard work though, as it only provides the structure and the wiring of the circuit. The actual guts of each TTL instance needs to be provided, and a reference to it is manually added to the schematic object fields. That’s a one-time deal, as you can re-use the component library once generated. Since TTL logic has been around for a little while, locating a suitable Verilog library for this is easy. Here’s ice-chips-verilog by [TimRudy] on GitHub for starters. It’s intended as a collection for Icestudio (which is also worth a look). Still, the Verilog code for many TTL series devices is presented ready for the taking, complete with individual test benches in case you need them.

Check out the project GitHub page for the module source code, and some more documentation about the design process.

We’ve seen many RTL hacks over the years, here’s an interesting way to generate a PCB layout with discrete logic, direct from the RTL.

Building A Fake Printer To Grab Screenshots Off The Parallel Port

[Tom Verbeure] recently found himself lamenting the need to take screen grabs from an Advantest R3273 spectrum analyzer with a phone camera, as the older gear requires you to either grab tables of data over an expensive GPIB interface card, or print them to paper. Then he realized, why not make a simple printer port add-on that looks like a printer, but sends the data over USB as a serial stream?

On the hardware side, the custom PCB (KiCAD project) is based on the Raspberry Pi Pico. Obvious form factor issues aside ([Tom] did revise the PCB to make it smaller) this is a shrewd move, as this is not a critical-path gadget so using the Pico as a USB-to-thing solution is a cost-effective way to get something working with minimal risk. One interesting design point was the use of the 74LVC161284 special function bus interface that handles the 5 V tolerance that the RP2040 lacks, whilst making the project compliant with IEEE-1284 — useful for the fussier instruments.

Using the service manual of the Sharp AP-PK11 copier/printer as a reference, [Tom] again, shows how to correctly use the chip, minimizing the design effort and scope for error. The complete project, with preliminary firmware and everything needed to build this thing, can be found on the project GitHub page. [Tom] does add a warning however that this project is still being worked on so adopters might wish to bear that in mind.

If you don’t own such fancy bench instrumentation, but grabbing screenshots from devices that don’t normally support it, is more your thing, then how about a tool to grab Game Boy screenshots?

Generating PAL Video With A Heavily Overclocked Pi Pico

Barely a week goes by without another hack blessing the RP2040 with a further interfacing superpower. This time it’s the turn of the humble PAL standard composite video interface. As many of us of at least a certain vintage will be familiar with, the Phase Alternate Line (PAL to friends) standard was used mainly in Europe (not France, they used SECAM like Russia, China, and co) and Australasia, and is a little different from the much earlier NTSC standard those in the US may fondly recollect. Anyway, [Fred] stresses that this hack isn’t for the faint-hearted, as the RP2040 needs one heck of an overclock (up to 312 MHz, some 241% over stock) to be able to pull off the needed amount of processing grunt. This is much more than yet another PIO hack.

The dual cores of the RP2040 are really being pushed here. The software is split into high and low-level functions, with the first core running rendering the various still images and video demos into a framebuffer. The second core runs in parallel and deals with all the nitty-gritty of formatting the frame buffer into a PAL-encoded signal, which is then sucked out by the DMA and pushed to the outside world via the PIO. There may be a few opportunities for speeding the code up even more, but [Fred] has clearly already done a huge amount of work there, just to get it working at all. The PIO code itself is very simple but is instructive as a good example of how to use multiple chained DMA channels to push data through the PIO at the fastest possible rate.

Continue reading “Generating PAL Video With A Heavily Overclocked Pi Pico”

The Tale Of The Final EVGA GPU Overclocking Record

It’s not news that EVGA is getting out of the GPU card game, after a ‘little falling out’ with Nvidia. It’s sad news nonetheless, as this enthusiastic band of hardware hackers has a solid following in certain overclocking and custom PC circles. The Games Nexus gang decided to fly over to meet up with the EVGA team in Zhonghe, Taiwan, and follow them around a bit as they tried for one last overclocking record on the latest (unreleased, GTX4090-based) GPU card. As you will note early on in the video, things didn’t go smoothly, with their hand-lapped GPU burning out the PCB after a small setup error. Continue reading “The Tale Of The Final EVGA GPU Overclocking Record”

DIY capacitor leakage tester nestled among neighbours all mounted underneath a shelf

DIY Capacitor Leakage Tester With A Professional Finish

[Manuel Caldeira] has built a nice electronics work area that would be the envy of many, complete with an under-shelf rail of custom-built instruments that are specific to the needs of areas of electronics that [Manuel] is involved with. The highlighted project here is a capacitor leakage tester, which is very handy for sorting through piles of old parts looking for anything still within spec, or just verifying a part on a board is the culprit you suspect it is.

The thing is, certain types of capacitors have a limited life both in operation and in storage. Usually, we’re talking about electrolytics here, where the electrolyte solution can leak out or dry out, but also the passive oxide layer on the anode plate can deteriorate if the device is left unpowered for long periods — the oxide disintegrates, and the capacitor will start to leak current. Eventually, the breakdown can be bad enough for the capacitor to conduct so well that it overheats and the result can be a surprisingly violent experience. So, if you deal with capacitors a lot, especially electrolytics, then a leakage tester is a very good instrument to own.

We like [Manuel]’s construction method here, with custom PCBs nestled inside a simple bent aluminium enclosure. No need for a top or sides, as these, are intended to bolt underneath a shelf, and butt up against their neighbor. The front panel graphics are done in a simple but very effective manner, using printable sticker sheets, with a clear adhesive over-sheet. They certainly have a professional finish, and this is definitely a construction method worth considering.

For those a little unfamiliar with this important component, why not leap into some theory with this handy dive into the simple parallel plate capacitor? Next, may we suggest a little overview of the different capacitor types and how to best make use of them?

Continue reading “DIY Capacitor Leakage Tester With A Professional Finish”

open hardware textile spinning machine constructed from aluminium extrusions, arduino electronics and 3D printed parts

An Open Hardware Automatic Spinning Machine

The team at the Berlin-based Studio HILO has been working on ideas and tools around developing a more open approach to small-scale textile production environments. Leveraging open-source platforms and tools, the team has come up with a simple open hardware spinning machine that can be used for interactive yarn production, right on the desktop. The frame is built with 3030 profile aluminium extrusions, with a handful of 3D printed, and a smidge of laser cut parts. Motion is thanks to, you guessed it, NEMA 17 stepper motors and the once ubiquitous Arduino Mega 2560 plus RAMPS 1.4 combination that many people will be very familiar with.

The project really shines on the documentation side of things, with the project GitLab positively dripping with well-organised information. One minor niggle is that you’ll need access to a polyjet or very accurate multi-material 3D printer to run off the drive wheel and the associated trailing wheel. We’re sure there’s a simple enough way to do it without those tools, for those sufficiently motivated.

We liked the use of Arduino for the firmware, keeping things simple, and in the same vein, Processing for the user interface. That makes sending values from the on-screen slider controls over the USB a piece of cake. Processing doesn’t seem to pop up on these pages too often, which is a shame as it’s a great tool to have at one’s disposal. On the subject of the user interface, it looks like for now only basic parameters can be tweaked on the fly, with some more subtle parameters needing fixing at firmware compilation time. With a bit more time, we’re sure the project will flesh out a bit more, and that area will be improved.

Of course, if you only have raw fibers, that are not appropriately aligned, you need a carder, like this one maybe?

Continue reading “An Open Hardware Automatic Spinning Machine”

RP2040 DMA Hack Makes Another ‘CPU Core’

[Bruce Land] of Cornell University will be a familiar name to many Hackaday readers, searching the site for ‘ECE4760′ will bring up many interesting topics around embedded programming. Every year [Bruce] releases yet more of the students’ work out into the wild to our great delight. This RP2040-based project is a bit more abstract than some previous work and shows yet another implementation of an older hack to utilise the DMA hardware of the RP2040 as another CPU core. While the primary focus of the RP2040 DMA subsystem is moving data between memory spaces, with minimal CPU intervention, the DMA control blocks have some fairly complex behaviour. This allows for a Turing-complete CPU to be implemented purely with the DMA hardware and a sprinkling of memory.

The method ties up three of the twelve DMA channels, and is estimated to have a similar performance to ‘an Arduino’ but [Bruce] doesn’t specify which one of the varied models that could be. But who cares anyway? Programming the CPU is a matter of leveraging the behaviour of the hardware, which is all memory mapped and targetable by the DMA. For example, the CPU can waggle GPIO pins by using the DMA to write values to the peripheral address space. The basic flow can be seen in the image above. DMA0 is used as the program counter, which points DMA1 to an array of DMA control blocks, a sequence of which codes for some of the ‘opcodes’ of the CPU model. DMA0 chains to (hands over control to) DMA1 which reads the control blocks and configures itself accordingly. DMA1 performs whatever data move is programmed, chains to DMA2, which in turn reprograms the DMA0 program counter to point to the next block in the list to be executed by DMA1.

Continue reading “RP2040 DMA Hack Makes Another ‘CPU Core’”