Circuit VR: Starting An Amplifier Design

August 10, 2018 by Al Williams 11 Comments

Sometimes I wish FETs had become practical before bipolar transistors. A FET is a lot more like a tube and amplifies voltages. Bipolar transistors amplify current and that makes them a bit harder to use. Recently, [Jenny List] did a series on transistor amplifiers including the topic of this Circuit VR, the common emitter amplifier. [Jenny] talked about biasing. I’ll start with biasing too, but in the next installment, I want to talk about how to use capacitors in this design and how to blend two amplifiers together and why you’d want to do that.

But before you can dive into capacitors and cascades, we need a good feel for how to get the transistor biased to start with. As always, there’s good news and bad news. The bad news it that transistors vary quite a bit from device to device. The good news is that we’ll use some design tricks to keep that from being a problem and that will also give us a pretty wide tolerance on component values. The resulting amplifier won’t necessarily be precise, but it will be fine for most uses. As usual, you can find all the design files on GitHub, and we’ll be using the LT Spice simulator.

Continue reading “Circuit VR: Starting An Amplifier Design” →

Learn FPGA Fast With Hackaday’s FPGA Boot Camp

August 6, 2018 by Al Williams 39 Comments

FPGAs have gone from being a niche product for people with big budgets to something that every electronics experimenter ought to have in their toolbox. I am always surprised at how many people I meet who tell me they are interested in using FPGAs but they haven’t started. If you’ve been looking for an easy way to get started with FPGAs, Hackaday’s FPGA boot camp is for you. There’s even a Hackaday.io chat in the group specifically for FPGA talk for questions and general discussion!

While it is true FPGAs aren’t for everything, when you need them you really need them. Using FPGAs you can build logic circuits — not software simulations, but real circuits — and reap major performance benefits compared to a CPU. For digital signal processing, neural networks, or computer vision applications, being able to do everything essentially in parallel is a great benefit. Sometimes you just need the raw speed of a few logic gates compared to a CPU plodding methodically through code. We expect to see a lot more FPGA activity now that Arduino is in the game.

These boot camps gather together some of the material you seen spread over many articles here before, plus new material to flesh it out. It’s designed for you to work through more like a training class than just some text to read. There’s plenty of screenshots and even animations to help you see what you are supposed to be doing. You’ll be able to work with simulations to see how the circuits we talk about work, make changes, and see the results. We’ll focus on Verilog — at least for now — as it is close to C and easier for people who know C to pick up. Still not convinced? Let’s run though the gist of the boot camp series.

Continue reading “Learn FPGA Fast With Hackaday’s FPGA Boot Camp” →

Beginning BLE Experiments And Making Everything Better

August 3, 2018 by Inderpreet Singh 15 Comments

Successfully connecting things without physical wires has a profound effect on the maker brain. Machines talking to each other without any cables is as amazing today as it was a decade ago. When Bluetooth came out, it was a breakthrough since it offered a wireless way to connect cellphones to a PC. But Bluetooth is a complicated, high-bandwidth power hog, and it didn’t make sense for battery-powered devices with less demanding throughput requirements to pay the energy price. Enter Bluetooth LE (BLE), with power requirements modest enough to enable a multitude of applications including low power sensor nodes and beacons.

Over the years, a number of gadgets with BLE have popped up such as the LightBlue Bean, BLE Beacons as well as quadcopters like the FlexBot that rely on BLE for communication. Android or iOS apps are the predominant method of talking to these wonderful gadgets though there are alternatives.

This is the first in a two part series on building with BLE devices. First, I’ll survey some BLE devices and how to get started with BLE from the Linux command line. Later, we will go into describing the process of making a NodeJS cross-platform app that will leverage the BLE capabilities and connect it to the Internet.
Lets get started.
Continue reading “Beginning BLE Experiments And Making Everything Better” →

A Custom Keyboard At Maximum Effort

July 31, 2018 by Brian McEvoy 16 Comments

No one loves hacked keyboards more than Hackaday. We spend most of our workday pressing different combinations of the same 104 buttons. Investing time in that tool is time well spent. [Max] feels the same and wants some personality in his input device.

In the first of three videos, he steps us through the design and materials, starting with a layer to hold the keys. FR4 is the layer of fiberglass substrate used for most circuit boards. Protoboards with no copper are just bare FR4 with holes. Homemade CNC machines can glide through FR4, achieving clean lines, and the material comes in different mask colors so customizing an already custom piece is simple. We see a couple of useful online tools for making a homemade keyboard throughout the videos. The first is a keypad layout tool which allows you to start with popular configurations and tweak them to suit your weirdest desires. Missing finger? Forget one key column. Extra digit? Add a new key column. Huge hands? More spaces between the keys. [Max] copied the Iris keyboard design but named his Arke, after the fraternal sister to Iris which is fitting since his wrist rests are removable. Continue reading “A Custom Keyboard At Maximum Effort” →

Beverage Holder Of Science

July 17, 2018 by Brian McEvoy 8 Comments

The folks at [K&J Magnetics] have access to precise magnetometers, a wealth of knowledge from years of experience but when it comes to playing around with a silly project like a magnetic koozie, they go right to trial and error rather than simulations and calculations. Granted, this is the opposite of mission-critical.

Once the experimentation was over, they got down to explaining their results so we can learn more than just how to hold our beer on the side of a toolbox. They describe three factors related to magnetic holding in clear terms that are the meat and bones of this experiment. The first is that anything which comes between the magnet and surface should be thin. The second factor is that it should be grippy, not slippy. The final element is to account for the leverage of the beverage being suspended. Say that three times fast.

Magnets are so cool for anything from helping visualize gas atoms, machinists’ tools, and circumventing firearm security features.

Continue reading “Beverage Holder Of Science” →

It’s All In The Libs – Building A Plugin System Using Dynamic Loading

July 12, 2018 by Sven Gregori 17 Comments

Shared libraries are our best friends to extend the functionality of C programs without reinventing the wheel. They offer a collection of exported functions, variables, and other symbols that we can use inside our own program as if the content of the shared library was a direct part of our code. The usual way to use such libraries is to simply link against them at compile time, and let the linker resolve all external symbols and make sure everything is in place when creating our executable file. Whenever we then run our executable, the loader, a part of the operating system, will try to resolve again all the symbols, and load every required library into memory, along with our executable itself.

But what if we didn’t want to add libraries at compile time, but instead load them ourselves as needed during runtime? Instead of a predefined dependency on a library, we could make its presence optional and adjust our program’s functionality accordingly. Well, we can do just that with the concept of dynamic loading. In this article, we will look into dynamic loading, how to use it, and what to do with it — including building our own plugin system. But first, we will have a closer look at shared libraries and create one ourselves.

Continue reading “It’s All In The Libs – Building A Plugin System Using Dynamic Loading” →

The Magic That Goes Into Magnets

July 9, 2018 by Brian McEvoy 16 Comments

Every person who reads these pages is likely to have encountered a neodymium magnet. Most of us interact with them on a daily basis, so it is easy to assume that the process for their manufacture must be simple since they are everywhere. That is not the case, and there is value in knowing how the magnets are manufactured so that the next time you pick one up or put a reminder on the fridge you can appreciate the labor that goes into one.

[Michael Brand] writes the Super Magnet Man blog and he walks us through the high-level steps of neodymium magnet production. It would be a flat-out lie to say it was easy, but you’ll learn what goes into them and why you don’t want to lick a broken hard-drive magnet and why it will turn to powder in your mouth. Neodymium magnets are probably unlikely to be produced at this level in a garage lab, but we would love to be proved wrong.

We see these magnets everywhere, from homemade encoder disks, cartesian coordinate tables, to a super low-power motor.