Hackaday

Syndicate content Hackaday
Fresh hacks every day
ถูกปรับปรุง 4 hours 35 min ก่อน

A Lightgun For LCDs – Thanks To Maths!

ศุกร์, 06/29/2018 - 03:00

Light guns were a fun way to learn to shoot things on consoles, enjoying their heyday in the 80s and 90s. The original designs largely relied on the unique characteristics of CRT televisions and the timing involved in the drawing of their frames. Unfortunately, due to a variety of reasons (dependent on the exact techniques used), they typically do not work at all with modern LCD & plasma screens.

The light gun contains a camera, and reportedly works by using the distortion of the rectangular image of the screen to calculate the position of the light gun itself.

Recently, there has emerged a new project called the Sinden Lightgun. In the How It Works video, it seems to use a fairly standard 30fps camera inside the gun to image the television screen being used by the game. The display is then rendered in 4:3, letterboxed on a 16:9 aspect ratio display, within a rectangular bezel. The image from the camera is then processed, and the distortion of the game image is used to calculate the position of the gun and the direction of its aim. Processing is handled by the host computer running MAME and the requisite coordinates are fed back in to the game code.

The basic concept seems sound, though as always, there’s a healthy amount of skepticism around the project. We’d love to hear your take, on whether the concept is plausible, and whether the lag figures stated are cromulent. We’re always excited to see new developments in the lightgun space! Video after the break.

Our own [Will Sweatman] penned an excellent piece on a variety of ways one could resurrect the venerable game of Duck Hunt, too.

Simple Quadcopter Testbed Clears The Air For Easy Algorithm Development

ศุกร์, 06/29/2018 - 01:30

We don’t have to tell you that drones are all the rage. But while new commercial models are being released all the time, and new parts get released for the makers, the basic technology used in the hardware hasn’t changed in the last few years. Sure, we’ve added more sensors, increased computing power, and improved the efficiency, but the key developments come in the software: you only have to look at the latest models on the market, or the frequency of Git commits to Betaflight, Butterflight, Cleanflight, etc.

With this in mind, for a Hackaday prize entry [int-smart] is working on a quadcopter testbed for developing algorithms, specifically localization and mapping. The aim of the project is to eventually make it as easy as possible to get off the ground and start writing code, as well as to integrate mapping algorithms with Ardupilot through ROS.

The initial idea was to use a Beaglebone Blue and some cheap hobby hardware which is fairly standard for a drone of this size: 1250 kv motors and SimonK ESCs, mounted on an f450 flame wheel style frame. However, it looks like an off-the-shelf solution might be even simpler if it can be made to work with ROS. A Scanse Sweep LIDAR sensor provides point cloud data, which is then munched with some Iterative Closest Point (ICP) processing. If you like math then it’s definitely worth reading the project logs, as some of the algorithms are explained there.

It might be fun to add FPV to this system to see how the mapping algorithms are performing from the perspective of the drone. And just because it’s awesome. FPV is also a fertile area for hacking: we particularly love this FPV tracker which rotates itself to get the best signal, and this 3D FPV setup using two cameras.
The HackadayPrize2018 is Sponsored by:





Rachel Wong Keynote: Growing Eyeballs in the Lab and Building Wearables that Enhance Experience

ศุกร์, 06/29/2018 - 00:01

The keynote speaker at the Hackaday Belgrade conference was Rachel “Konichiwakitty” Wong presenting Jack of All Trades, Master of One. Her story is one that will be very familiar to anyone in the Hackaday community. A high achiever in her field of study, Rachel has learned the joy of limiting how much energy she allows herself to expend on work, rounding out her life with recreation in other fascinating areas.

There are two things Rachel is really passionate about in life. In her professional life she is working on her PhD as a stem cell researcher studying blindness and trying to understand the causes of genetic blindness. In her personal life she is exploring wearable technology in a way that makes sense to her and breaks out of what is often seen in practice these days.

Wearables That Create Experience

Rachel makes a really interesting observation about where we are right now with wearables. On the one hand you can find a lot of negativity out there about this branch of technological exploration. On the other hand, the commercial offerings that are available are closely related in design and function with little variety. You’ll more often than not find products that are black, and focused on health technology like counting your steps, or measuring your heart beat.

Wearable fashion is an opportunity to break out of these confines. Rachel sees it as adding purpose to what we wear in a way that enhances the user’s experience. Knowing the calories burned or your BPM are just magic numbers that don’t have an intuitive value to most of us. Focusing on things that enhance an experience gets out of this trap and it’s more approachable for everyone. Rachel makes the point that we’re all making fashion choices on a daily basis as we clothe ourselves and this just adds to that palette.

The demos for this part of her talk include a floral necklace and a headpiece that also leveraged her jewelry making skills. The necklace uses Neopixel rings and a Raspberry Pi zero to animate soft color changes to the flower petals. It’s not a screen you look at, but an enhancement to something you would already wear. The headpiece does include an LED matrix screen, clutched tightly by Hello Kitty which is an homage to her screen name Konichiwakitty, but keeps the pleasing effects of LED glow under the flowers that make up the majority of the piece.

Rachel’s work in wearables has been widely recognized. She wrote a tutorial for Make magazine about resin casting electronics called Curing Cuteness. Using this process she created Maker Gummi Bears which look fantastic — she was showing them off at the con and you can get a closer look on Hackaday.io and at her Etsy page. Rachel has also received a 2018 Bright Sparks award for her work.

Growing Eyeballs in the Lab

It’s always fascinating to hear how people find their path through life. Rachel shared a really interesting insight into becoming a stem cell scientist. Many of her friends were going off into specialties that focus on studying diseases in search of a groundbreaking cure but to Rachel that didn’t seem like the place where the biggest impact will be made. Even if you cure the disease the organs that were afflicted are often already damaged. Rachel wants to make it possible to create brand new organs that can be swapped out as needed — and that’s already happening. Her area of research involves growing eye tissue in the lab and its use is already in clinical testing.

Scaffold for a liver. All DNA and cells have been washed away.

Stem cells are biological building blocks. If you give them a structure as a guide — called a scaffold — you can build anything you want with them. Once in place, they know what to do and can even specialize. In her case this means becoming light sensitive cells or pigmented eye cells.

The scaffolds themselves are fascinating. They can come from cadavers, plants, or other animals. Before the growing process begins these scaffolds are flushed thoroughly with detergents and enzymes until no DNA or other cells remain. The stem cells are then introduced and begin to grow on the structure. Once transplanted, the patient’s body will dissolve and replace the scaffold. And since there was no DNA or cellular material, other than stem cells from the patient’s own body, the new organ will not be rejected.

There’s even 3D Bioprinting technology at work in this field. It’s much like FDM 3D printers you’re probably familiar with, but these operate in a sterile environments building custom scaffolds and adding stem cells as the printing progresses. Rachel isn’t using this printing technology in her research though. In fact she considers her team lucky as they are able to grow the optic cups without need of scaffold at all.

Bring Balance to Your Life

The closing remarks on this keynote are quite powerful. Rachel has had a laser focus on her goals as she worked her way through school. The research she’s doing feels incredibly important — think of the power thaat stem cell scientists have to make people’s lives better — but only if that breakthrough can be reached.

The problem is, without balance in her life this wasn’t sustainable. It’s refreshing to hear Rachel speak candidly about her story and about bringing a cycle of work and recreation into her routine. Now, after a day of rigorous research, she goes home and changes over to her life of making wearables. It’s exercise for her creative side and a different way to stretch her mind that lets her feel refreshed when it’s time to start things again the next day. Carry this advice with you and put it to use when you’re feeling like life has become a grind.

Next Weekend: Beginner Solar Workshop

พฤ, 06/28/2018 - 23:01

Next week, Hackaday is hosting a workshop for all you hackers ready to harness the power of the sun. We’re doing a Beginner Solar Workshop at Noisebridge in San Francisco. You’re invited to join us on July 7th, we’ll provide the soldering irons.

The instructor for this workshop will be [Matt Arcidy], avid Hackaday reader and member of Noisebridge. He’s contributed to the incredible Noisebridge Gaming Archivists Live Arcade Cabinet, given talks on electronic components for the Arduino ecosystem, and now he’s hosting a workshop on the basics of solar charging.

This workshop will cover the theory of solar charging, how solar cells convert light into electricity, when and where this technology is appropriate, and the safe handling of lithium-ion batteries. At the end of the workshop, every attendee will have built a system that captures power from the sun and charges a battery, ready to be used in any future projects.

This is a big deal. Right now, the Hackaday Prize is in the middle of its third challenge, the Power Harvesting Module Challenge. This is a big part of the prize, and already there are some fascinating projects which harvest electricity from stomach acid, and even the gravitational potential of the Earth. Of course, some of those are more practical than others, and we’re really interested to see where this Power Harvesting Challenge goes and what great projects will be created.

The HackadayPrize2018 is Sponsored by:





3D Printed Tourniquets are Not a Cinch

พฤ, 06/28/2018 - 22:30

Saying that something is a cinch is a way of saying that it is easy. Modeling a thin handle with a hole through the middle seems like it would be a simple task accomplishable in a single afternoon and that includes the time to print a copy or two. We are here to tell you that is only the first task when making tourniquets for gunshot victims. Content warning: there are real pictures of severe trauma. Below, is a video of a training session with the tourniquets in Hayat Center in Gaza and has a simulated wound on a mannequin.

On the first pass, many things are done correctly: the handle is the correct length and diameter, the strap hole fit the strap, and the part is well oriented on the platen. As with many first iterations, it looks good on a screen, but in the real world, we all live under Murphy’s law. In practice, some of the strap holes had sharp edges that cut into the strap, and one of the printed buckles broke unexpectedly.

On the whole, the low cost and availability of the open-source tourniquets outweigh the danger of operating without them. Open-source medical devices are not just for use in the field, they can help with training too. This tourniquet is saving people and proving that modeling skills can be a big help in the real world.

Move Aside Mercury: Measuring Temperature Accurately with an RTD

พฤ, 06/28/2018 - 21:01

Temperature is one of the most frequently measured physical quantities, and features prominently in many of our projects, from weather stations to 3D printers. Most commonly we’ll see thermistors, thermocouples, infrared sensors, or a dedicated IC used to measure temperature. It’s even possible to use only an ordinary diode, leading to some interesting techniques.

Often we only need to know the temperature within a degree Celsius or two, and any of these tools are fine. Until fairly recently, when we needed to know the temperature precisely, reliably, and over a wide range we used mercury thermometers. The devices themselves were marvels of instrumentation, but mercury is a hazardous substance, and since 2011 NIST will no longer calibrate mercury thermometers.

A typical Pt100 RTD probe

Luckily, resistance temperature detectors (RTDs) are an excellent alternative. These usually consist of very thin wires of pure platinum, and are identified by their resistance at 0 °C. For example, a Pt100 RTD has a resistance of 100 Ω at 0 °C.

An accuracy of +/- 0.15 °C at 0 °C is typical, but accuracies down to +/- 0.03 °C are available. The functional temperature range is typically quite high, with -70 °C to 200 °C being common, with some specialized probes working well over 900 °C.

It’s not uncommon for the lead wires on these probes to be a meter or more in length, and this can be a significant source of error. To account for this, you will see that RTD probes are sold in two, three, and four wire configurations. Two-wire configurations do not account for lead wire resistance, three-wire probes account for lead resistance but assume all lead wires have the same resistance, and four-wire configurations are most effective at eliminating this error.

In this article we’ll be using a 3-wire probe as it’s a good balance between cost, space, and accuracy. I found this detailed treatment of the differences between probe types useful in making this decision.

Circuits for Reading a Resistance Temperature Detector

Unfortunately, RTDs come with a few difficulties. Mainly, they are a resistive sensor and subject to self-heating with anything but the smallest of currents, requiring a constant-current supply. You might build this out of operational amplifiers and a wheatstone bridge.

Wheatstone bridge implementation of a 3 wire RTD probe. Source: Wikipedia

Not all of us enjoy analog circuit design, and there is a decent IC that will handle it for you: the MAX31865 RTD to digital converter. It works by comparing the RTD probe resistance to a reference resistor, and is fairly easy to design a board around (the chip is available in both SSOP and TQFN form factors). This chip is readily available in pre-assembled Arduino-compatible modules, and is supported by an Arduino library. However, that’s not for everyone, and today we will cover how to interact with this useful chip over SPI.

Regardless of your platform, most MAX31865 modules require some initial setup. Some areas of the board will have to be bridged or have traces cut to set what type of probe you are using.

A Test Run with ESP8266 and Lua SPI settings by mode. Source: Wikipedia

In this example, I’ll be using Lua on an ESP8266 microcontroller running NodeMCU, but similar steps should work on a platform of your choice. Our first step will be to configure SPI. The MAX31865 datasheet (PDF) states that only SPI modes 1 and 3 with 8 data bits, and a maximum clock of 5 MHz are supported. A quick search on Wikipedia returned a table with the SPI settings for each mode.

I chose SPI mode 1 and a hefty clock divider of 256. I also set up an output pin to use as the Chip Select pin. This pin needs to be driven low to initiate reads and writes, then driven high once the operation is completed. The resulting code is:

pin = 1 spi.setup(1, spi.MASTER, spi.CPOL_LOW, spi.CPHA_HIGH, 8, 256); gpio.mode(pin, gpio.OUTPUT)

Next we define sending and receiving functions based on the required behavior of the Chip Select pin. The returned integer after a read will always be between 0 and 255. The ESP8266 will interpret this as an ASCII character, so we use string.byte to convert it to a decimal value:

function spi_write(target, data) gpio.write(pin, gpio.LOW) tmr.delay(20) spi.send(1, target) tmr.delay(20) spi.send(1, data) gpio.write(pin, gpio.HIGH) tmr.delay(20) end function spi_read (target) gpio.write(pin, gpio.LOW) tmr.delay(20) spi.send(1, target) tmr.delay(20) x = spi.recv(1,1) print (string.byte (x, 1)) tmr.delay(20) gpio.write(pin, gpio.HIGH) tmr.delay(20) end Configuring MAX31865 Behavior

Using the SPI read and write functions, we can now use the MAX31865 chip. There are only 8 registers on the chip, each containing 8 bits of data. To read from a register we precede it with a ‘0’, and to write to it, an ‘8’. For example, to read from register 1 we would use spi_read(0x01), and to write the number 0xFF to it we would use spi_write(0x81,0xFF).

The main configuration register is register 0 and it works according to the following table:

Configuration register (address 0x00) bit functions on the MAX31865. Source: MAX31865 datasheet (PDF)

Since I want to automatically read every second, I need to turn on both Vbias and set conversion mode to Auto, so that’s ‘11’. I don’t want to use 1-shot, so that gets written ‘0’. I’m using a 3-wire probe, so that’s a ‘1’. I’ll clear fault detection for now, so that’s ‘00’. I want to start with fault status clear, so that’s a ‘1’, and the electrical frequency in my area is 50Hz so that’s a ‘1’ too. Concatenating that all together, we get ‘1101 0011’ or hexidecimal 0xD3.

spi_write(0x80, 0xD3)

The chip supports alert thresholds when the temperature goes above or below a value. I won’t be using these, so I’ll set them to extreme values.

spi_write(0x83, 0x7f) spi_write(0x84, 0xff) spi_write(0x85, 0x00) spi_write(0x86, 0x00) Reading Temperature Data Pt100 RTD nonlinearity error vs. Temperature. Source: hardwarebook.info

Now that it’s set up, we can finally read data. The data are 15-bit ratios between the reference resistor (in my case 427 Ω) and the RTD probe. As the temperature of the probe increases, its resistance increases in a nearly linear fashion.

According to the datasheet, the temperature can be approximated from this with the formula:

However, there’s a good reason not to do this: the error is up to 1.75 °C in the range of +/- 100 °C. Also it assumes a 400 Ω reference resistor, so you’ll likely need to correct for that. This level of accuracy is not significantly better than cheaper, easier-to-use devices, but is useful to determine if your probe is more or less reading correctly.

To improve accuracy, we have to consider the slight nonlinearity of the relationship between probe resistance and temperature. There are a few ways to do this, but the most commonly used is the Callendar-Van Dusen equation. This is typically a second-order polynomial of the form that predicts the resistance at a given temperature as:

This is accurate up to about 660 °C (more complex functions can handle higher temperatures). The probe specification states that the values for a and b are 3.90830 x 10-3 and -5.77500 x 10-7 respectively. With those constants, we can write an implementation as follows:

#Read high ADC register (8 bits) gpio.write(pin, gpio.LOW) tmr.delay(20) spi.send(1, 0x01) tmr.delay(20) x = spi.recv(1,1) x = (string.byte (x, 1)) tmr.delay(20) gpio.write(pin, gpio.HIGH) tmr.delay(20) #Read low ADC register (7 bits) gpio.write(pin, gpio.LOW) tmr.delay(20) spi.send(1, 0x02) tmr.delay(20) y = spi.recv(1,2) y = (string.byte (y, 1)) tmr.delay(20) gpio.write(pin, gpio.HIGH) #print out approximation of temperature from function in datasheet, accounting for our resistor being 427 Ω, not 400 Ω. Note that the ADC value is 15 bits long, not 16. z = tonumber(x)*127+tonumber(y) z = z*(1.0675) z = (z/32) - 256 print (z) #implement Callendar-Van Dusen equation to provide more accurate result a = 0.00390830 b = -0.0000005775 z = tonumber(x)*127+tonumber(y) z = (z/(2^15))*427 z = (-100*a+((10000*(a)^2) - 400*b*(100-z))^0.5)/(200*b) print (z)

This worked quite well, with the Callendar-Van Dusen equation providing a result of about 0.15 °C higher than the approximation at 30 °C.

If you’re still holding out and have a mercury thermometer, it might be time to take a deep breath (assuming it is intact), put aside the nostalgia, have it recycled, and move on.

Tiny Printers Get Color Mixing

พฤ, 06/28/2018 - 18:00

Last weekend was the inaugural East Coast RepRap Festival in beautiful Bel Air, Maryland. Like it’s related con, the Midwest RepRap Festival, ERRF is held in the middle of nowhere, surrounded by farms, and is filled with only people who want to be there. It is the anti-Maker Faire; only the people who have cool stuff to show off, awesome prints, and the latest technology come to these RepRap Fests. This was the first ERRF, and we’re looking forward to next year, where it will surely be bigger and better.

One of the stand-out presenters at ERRF didn’t have a big printer. It didn’t have normal stepper motors. There weren’t Benchies or Marvins or whatever the standard test print is these days. [James] is showing off tiny printers. Half-scale printers. What’s half the size of a NEMA 17 stepper motor? A NEMA 8, apparently, something that isn’t actually a NEMA spec, and the two companies that make NEMA 8s have different bolt hole patterns. This is fun.

If these printers look familiar, you’re right. A few years ago at the New York Maker Faire, we checked out these tiny little printers, and they do, surprisingly, print. There are a lot of tricks to make a half-size printer, but the most impressive by far is the tiny control board. This tiny little board is just 2.5 by 1.5 inches — much smaller than the standard RAMPS or RAMBO you’d expect on a DIY printer. On the board are five stepper drivers, support for two heaters, headers for OLEDs and Graphic LCDs, and a switching regulator. It’s a feat of microelectronics that’s impressive and necessary for a half-size printer.

Since we last saw these tiny printers, [James] has been hard at work expanding what is possible with tiny printers. The most impressive feat from this year’s ERRF was a color-mixing printer built around the same electronics as the tiny printers. The setup uses normal-size stepper motors (can’t blame him) and a diamond-style hotend to theoretically print in three colors. If you’ve ever wanted a tiny printer, this is how you do it, and I assure you, they’re very, very cute.

Sunny Custom Keyboard Illuminates the Past

พฤ, 06/28/2018 - 15:00

Ever wonder why keyboard number pads and telephone dials have reversed layouts? Theories abound, but the most plausible one is that, shrug, it just happened that way. And now we’re stuck with it.

Well, that answer’s not good enough for [Jesse], so he punched up his own keyboard design that combines the golden years of function-rich Sun and IBM keyboards with Ma Bell’s DTMF number arrangement. That’s right, Sundial has 24 function keys total, and the number pad matches Ma Bell’s all the way down to the asterisk/zero/octothorpe pattern on the bottom row. How do we know what the unlabeled ones are, you ask? It’s all mapped out in this layout editor. We love that it has all the key lock indicator lights, because that practice should’ve never faded out in the first place.

Though inspired by this beautiful unicorn of an Arduino keyboard we covered a few months ago, the Sundial uses a Teensy 2.0 to translate [Jesse]’s Cherry MX clone-driven wishes into software commands. It’s also painstakingly hand-wired, so here’s the build log for you to drool over. Just cover up your keyboard first.

Raspberry Pi Tracks Starter Fermentation For Optimized Sourdough

พฤ, 06/28/2018 - 12:00

Those of you who’ve never had a real sourdough have never had real bread. Good food fights back a little when you eat it, and a proper sourdough, with its crispy crust and tangy center, certainly fits the bill. Sourdough aficionados, your humble writer included, all have recipes that we pretend are ancient family secrets while in reality we’re all just guessing. Sourdough is partly science, partly art, but mostly delicious black magic.

In an effort to demystify his sourdough process, [Justin Lam] has gone digital with this image processing sourdough starter monitor. Sourdough breads are leavened not by the addition of brewers yeast (Saccharomyces cerevisiae), but by the inclusion of a starter,  a vibrant ecosystem of wild yeasts that is carefully nurtured, sometimes for years. Like any other living thing, it needs to be fed, a task that should happen at the point of maximum fermentation. Rather than guess when this might be, [Justin] used a Raspberry Pi Zero and PiCam to capture a time-lapse video of the starter as the beasties within give off their CO₂, thus expanding it up inside its container. A little Python does the work of thresholding and finding the top of the starter as it rises, allowing [Justin] to plot height of the starter over time. He found that peak height, and therefore peak fermentation, occurs about six hours after feeding. He has used his data to better inform his feeding schedule and to learn how best to revive neglected starters.

Surprisingly, this isn’t the first time we’ve discussed sourdough here. It seems that someone uses Git for iterative sourdough recipe development, and we once featured a foundry made from a pyrolyzed loaf of sourdough.

Literary Camouflage For Your Router

พฤ, 06/28/2018 - 09:00

What is suspicious about the books in the image above? Is it that there is no bookend? How about the radio waves pouring out of them? [Clay Weiland] does not like the way a bare router looks in the living room, but he appreciates the coverage gained by putting it in the middle of his house. He added a layer of home decorating camouflage in the form of some second-hand book covers to hide the unsightly bit of tech.

There isn’t a blog post or video about this particular build anywhere. The photos were submitted to our tip line as-is with the note that a table-saw is involved. We can safely infer that book covers are stripped of their pages and filled with wooden blanks painted white and stuck together to look like a cluster of literature. The takeaway from this example is that our tech does not have to be hidden away like a secret, or disrupt the decor, it can be placed as functionally as possible without sacrificing Feng Shui.

If hiding behind books piques your interest, try a full-fledged version, or this smooth operator.

Thank you, [George Graves], for encouraging people to use our tip line.

A Different Use For Microwave Oven: Melting Aluminum

พฤ, 06/28/2018 - 06:00

Microwave ovens are a treasure trove of useful parts: transformers, an HV capacitor, a piezo speaker, and a high torque motor, to name just a few. In a new twist, [Rulof Maker] strips all that out and uses just the metal case to make a furnace for melting aluminum, copper and bronze.

His heat source is a quartet of 110 volt, 450 watt quartz heating elements which he mounts inside in the back. To reduce heat loss, he lines the walls with ceramic fiber insulation. Unfortunately, that includes covering the inside of the window, so there’s no pressing your nose against the glass while you watch the aluminum pieces turn to liquid. If you’re going to try making one of these yourself then you may want to consider adding a fuse.

It does the job though. In around nine minutes he melts enough scrap aluminum in a stainless steel bowl to pour into a mold for a test piece. But don’t take our word for it, see for yourself in the video below.

If want more information on what useful parts are inside then check out this primer. Or you can leave the parts in and use the oven as is for melting lead, but keep a fire extinguisher handy.

Pool Ball Return System Chalked Up To Ingenuity

พฤ, 06/28/2018 - 03:00

Do you play pool? If so, you probably take the automatic ball return systems in bar and billiard hall tables for granted. [Roger Makes] was tired of walking around his home table to collect the balls every time he wanted to play, so he designed a time-saving ball return system.

Instead of falling into the little netted baskets that came with the table, the balls now drop into 3D-printed pockets and ride along dowel rod rails into a central collection box, which is suspended by straps beneath the rack-em-up end of the table. The rails themselves are fortified with ABS ribs that keep the balls from falling through.

Pool is all about geometry, and this really hit home when [Roger] was trying to merge the funnel part of the pocket with the exit chute in the design phase. He covered all the angles with a modular design that lets the chute rotate freely, which takes a lot of stress away from the dowel rods. We’ve got the video cued up after the break, so don’t bother with getting out your film canister full of quarters.

We can’t wait to see what [Roger Makes] next. Maybe it’ll be something like this OpenCV score-keeping system.

Via [r/functionalprint]

Improving Indoor Navigation of Robots With IR

พฤ, 06/28/2018 - 01:30

If the booths at CES are to be believed, the future is full of home robots: everything from humanoid robots on wheels to Alexas duct taped to a Roomba. Back in reality, home robots really aren’t a thing yet. There’s an obvious reason for this: getting around a house is hard. A robot might actually need legs to get up and down stairs, and GPS simply doesn’t exist indoors, at least to the accuracy needed. How on Earth does a robot even navigate indoors?

This project for the Hackaday Prize solves the problem of indoor navigation, and it does it in an amazingly clever way. This is using QR codes for navigation, but not just any QR codes. They’re QR codes read by an infrared camera, and painted on the walls and ceilings with a special IR sensitive paint that’s invisible to the human eye. It’s navigation for robotic vision, and it’s a fantastic idea.

The basic idea behind this project is to use an IR camera — or basically any webcam with the IR blocking filter removed — and a massive amount of IR LEDs to illuminate any target. So far, the proof of concept works. A computer can easily read QR codes, and if paint is invisible to the human eye but visible to an IR camera, the entire project is merely a matter of implementation.

There have been a number of projects that try to add indoor navigation to robots. Some of them use LIDAR, some use computer vision and SLAM. These are computationally expensive. Some even use wireless beacons to navigate indoors like the SubPos Ranger from the 2016 Hackaday Prize. Using IR and QR codes is just so simple and hacker-friendly, and we think it’s fantastic.

The HackadayPrize2018 is Sponsored by:





After The Sun Set On San Mateo, LED Takes Over Hackaday’s BAMF Meetup

พฤ, 06/28/2018 - 00:01

After this Spring’s Bay Area Maker Faire closed down for Saturday night and kicked everybody out, the fun moved on to O’Neill’s Irish Pub where Hackaday and Tindie held our fifth annual meetup for fellow Maker Faire attendees. How do we find like-minded hackers in a crowded bar? It’s easy: look for tables lit by LEDs and say hello. It was impossible to see everything people had brought, but here are a few interesting samples.

The team from Misty Robotics brought their namesake product to the meetup and carried Misty when there wasn’t enough room to let the robot run. Here [Ben Edwards] is answering questions about Misty’s capabilities. The team wants their product to appeal to a wide spectrum of budding roboticists: from beginners who need a gentle on-ramp to seasoned veterans interested in modifying Misty for their own needs.

Since those who would attend a Hackaday + Tindie meetup trend towards the latter, Misty arrived with a demonstration of hackability: a 3D-printed beer glass holder has replaced the standard left arm, fitting in with the meetup’s location. It was fun to see the robot’s personality as Misty looked around and occasionally reacted to being patted on top of the touch-sensitive head.

Longtime Hackaday.io participant Joshua Snyder brought his projects RGB LED matrix and Neopixel pocket watch, giving people who have only read about his projects an opportunity to play with them in person. The Neopixel pocket watch seen below is quite the stealthy transformer — when closed and inactive, it blends in with wardrobe of another era. But when active, it is very definitely a 21st century timepiece.The RGB LED matrix also shown was pressed into service as an impromptu bar arcade.

Some of the attendees had problem finding enough table space in a crowded bar to set up, but the crew of TinyCircuits had no such worry. They were able to put their entire product line on a little round bar table and still leave plenty of room for everyone’s beer. If you’ve only seen these creations in pictures, it’s hard to appreciate how tiny they actually are. It takes some hands-on time for the size to really sink in, and this table is always crowded with people clicking tiny buttons with their fingernails.

Hackaday’s own Kerry Scharfglass is local and brought his sympetrum boards to show during the evening. Based on Neal Stephenson’s book The Diamond Age, these badges will synchronize their colors when in the same room together. Kerry built version 2 of the badge for last year’s DEF CON but what is show here is the work-in-progress version 3. And we also got to see a bit of behind-the-scenes of building blinky LED badges as Kerry brought a development tool featuring 3D-printed jig holding pogo pins to interface with his v3 board.

We invited Hackaday Prize participants to bring their entries, and Michael Graham is among those who answered the call. His Mug-O-Matic is a demonstration piece for his linear actuator module, one of twenty winners of our Robotics Module challenge! Sadly we didn’t get a chance to see Mug-O-Matic in action as Michael’s beverage came in a small plastic cup instead of a suitable mug. But the cup was enough to fuel the main purpose of the night: chatting about hacks and hacking.

The further back you go into the room, the more crowded and louder it got, but the effort will be rewarded with projects plugged into power outlets on the back wall. A spectacular example was the Volumetric POV Display by Jamal Davis. His project has everything — custom LED circuit boards, wires to power them, motor to spin them, micro controller to orchestrate everything, all housed inside a 3D-printed enclosure.

It was impressive enough to look at even before it was turned on. Once it started spinning, the light show stole all the attention.

The above are just a sample of creations lighting up tables at this year’s Hackaday x Tindie BAMF meetup. The projects get more amazing every year. Join us next year to see what wonderful creations show up!

ESP8266 Home Computer Hides Unexpected Gems

พุธ, 06/27/2018 - 22:30

With a BASIC interpreter and free run throughout their hardware, home computers like the ZX Spectrum and Commodore 64 used to be a pervasive way to light that hacker fire. With the advent of cheap single board computers like the Raspberry Pi, devices purpose built to emulate these classic systems have become fairly commonplace. [uli] built a device in this vein called the BASIC Engine which is driven by a microcontroller and a handful of hardware peripherals. Like other examples it can be attached to a keyboard, programmed in a BASIC, play video and sound, etc. But digging into the BASIC Engine reveals that it’s similarity to other devices is only skin deep.

The current version of the BASIC Engine (“rev2”) lives in a Raspberry Pi 3 case for convenience. It has RCA connectors for NTSC or PAL video output and mono audio, plus a bank of headers to tap into GPIOs, connectors for a keyboard, and more. [uli] wanted to aim for extreme low cost so a relatively beefy board like a Raspberry Pi didn’t fit the bill, and we expect it was an enjoyable challenge. Instead its interpreter runs atop an ESP8266 but with the networking stack removed. [uli] was disheartened by how bloated even a “Hello world” program was and ripped it out, discovering that hidden beneath was a very powerful and disproportionately inexpensive general purpose microcontroller. The video is driven by a VS23S010, sold as a 1 Mbit parallel SRAM with a neat trick; it also includes a composite video controller!

The real treat here is [uli]’s history writeup of how the BASIC Engine came to be. We’d recommend brewing a cup of coffee and sitting down for a full read-through. The first version was inspired by the PlayPower project, which was repurposing clones of Nintendo’s Famicom (NES to Americans) game console to make low cost home computers, complete with keyboard and gamepad input. [uli] started out by building a custom cartridge for a particular Famicom clone that ran a BASIC interpreter but after showing it to disinterested adults the project was left fallow. Years later, [uli] was encouraged to pick up the project again, leading down a twisted rabbit hole to where we are today.

If you want to build a BASIC Engine for yourself, Gerbers and build instructions are available on the pages linked above.

Thanks for the tip [antibyte]!

Keep it Close: A Private Git Server Crash Course

พุธ, 06/27/2018 - 21:01

At this point, everyone has already heard that Microsoft is buying GitHub. Acquisitions of this scale take time, but most expect everything to be official by 2019. The general opinion online seems to be one of unease, and rightfully so. Even if we ignore Microsoft’s history of shady practices, there’s always an element of unease when somebody new takes over something you love. Sometimes it ends up being beneficial, the beginning of a new and better era. But sometimes…

Let’s not dwell on what might become of GitHub. While GitHub is the most popular web-based interface for Git, it’s not the only one. For example GitLab, a fully open source competitor to GitHub, is reporting record numbers of new repositories being created after word of the Microsoft buyout was confirmed. But even GitLab, while certainly worth checking out in these uncertain times, might be more than you strictly need.

Let’s be realistic. Most of the software projects hackers work on don’t need even half the features that GitHub/GitLab offer. Whether you’ve simply got a private project you want to maintain revisions of, or you’re working with a small group collaboratively in a hackerspace setting, you don’t need anything that isn’t already provided by the core Git software.

Let’s take a look at how quickly and easily you can setup a private Git server for you and your colleagues without having to worry about Microsoft (or anyone else) having their fingers around your code.

A Word on Remotes

The first thing to understand is that Git doesn’t strictly use the traditional client-server kind of arrangement. There’s no Git server in the sense that we have SSH and HTTP servers, for example. In Git, you have what’s known as the remote, which is a location where code is copied to and retrieved from. Most of us are familiar with supplying a URL as the remote (pointing to GitHub or otherwise), but it could just as easily be another directory on the local system, or a directory on another machine that’s been shared over the network. It could even be the mount point of a USB flash drive, which you could then physically move to other machines to keep them all synchronized in a modernized version of the classic “Sneakernet

So with that in mind, a basic “Git Server” could be as simple as mounting a directory on another machine with NFS and defining that as the remote in your local Git repo. While that would certainly work in a pinch, the commonly accepted approach is to use SSH as the protocol between your local machine and remote repository. This gives you all the advantages of SSH (compression, security, Internet routability, etc) while still being simple to configure and widely compatible with different operating systems.

Git over SSH

I’ll be doing this on a stock Raspbian install running on the Raspberry Pi 3, but the distribution of Linux you chose and even the device don’t really matter. You could just as easily do this on an old PC you have lying around in the junk pile, but the system requirements for this task are so light that it’s really an excellent application for the Pi.

The general idea here is that we are going to create a specific user for Git, and make it so they don’t have any shell access. We want an account that SSH can use, but we don’t want to give it the ability to actually do anything on the system; as anyone who uses the Git server will by necessity have access to this account. As it so happens, Git includes its own minimal shell to do just that called git-shell.

We’ll then prepare a place for our Git repositories to live, create a basic empty repository, and verify it’s working as expected from a client machine. Keep in mind this is going to be a very bare-bones setup, and I’m not suggesting you follow what I’m doing here exactly. This is simply to give you an idea of how quickly you can spool up a simple distributed control system for yourself or a small group using nothing but what’s included with the basic Git package.

Preparing the User Account

So let’s say you’ve already created the user “git” with a command like:

sudo adduser git

The next step is to see if git-shell is an enabled shell on your system, and if not (it probably isn’t), add it to the list of valid options.

That last line is the one that actually changes the default shell for the user. If you try to log in as “git” now, you’ll be presented with an error. So far, so good.

Except we already have a problem. Since the “git” user can no longer log into the system, we can’t use that account for any of the next steps. To make things easier on yourself, you should add your own account to the “git” group. As you’ll see shortly, that will make the server a bit easier to maintain.

The command to add a user to an existing “git” group will look something like this:

sudo usermod -a -G git USERNAME

A Place to Call Home

You might be inclined to just drop your repositories in the home directory of the “git” user. But for safety reasons it’s an account that can’t do anything, so it doesn’t make a whole lot of sense to put anything in its home directory.

To make things easier on yourself, you should create a directory in a globally accessible location like /opt, and then change its permissions so the group “git” has full access. That way, any account on the system that is in the “git” group will be able to add new repositories to the server.

If you want to skip this step, just keep in mind you’ll need to use sudo to add more repositories to the server. If this is a one-off box that’s not really a problem, but if you want to open this up to a few other people it’s helpful to have a more granular control over permissions.

At any rate, once you have the directory created where you want to store your repositories, it’s time to create a blank repository to use. This is as simple as creating a new directory and running a single Git command in it.

Pay special attention to that last line. You need to make sure the owner of the repository you just created is the “git” user, or else you’ll get permission errors when you try to push code up to the server from your clients.

The First Push

We now have a Git server that’s ready to have code pushed into it. From a client device, you would either create a new project to upload or else set this server up as a new remote for an existing Git repository. For the sake of clarity, here’s what it would look like to create a new local Git repository, add a file to it, and then push it to our new server.

Notice in the git remote add command that the username and hostname are from our server system. If you don’t have DNS setup for name resolution on your network, you could simply use the IP address here. Of course that path should look familiar, as it’s where we created the example repository previously.

Assuming no errors, you’re now up and running. You can git clone this repository from another computer, pushing and pulling to your heart’s content. New repositories will need to be manually added before code can be pushed to them, but beyond that, the workflow is the same as what you’re used to.

A Simple Start

That’s all it takes to create your own Git server, and in fact, we actually did a fair bit more than was strictly required. If you’re on a secure network and the server is only for one person, you could really skip the new user creation and shell replacement. Just make the bare repository in your home directory and use your normal SSH credentials. Conversely, if you wanted to open this up to a group of trusted collaborators, the next logical step would be to setup SSH public key authentication and add their keys to the system.

But what if you want something a bit closer to the admittedly snazzy GitHub experience? Well, as it so happens there are a number of packages available that can provide a similar experience on a self-hosted server. There’s even a build of GitLab that you can run on a private box. Now that we’ve got the basics out of the way, we’ll be taking a look at some of these more advanced self-hosted Git options in the near future.

A Sneak Peek At The TS100 Soldering Iron’s Younger Sibling

พุธ, 06/27/2018 - 18:00

Many readers will be familiar with the TS100 soldering iron, a lightweight and powerful tool with an integrated temperature controller in its handle based upon an STM32 microcontroller. As an iron it’s a joy to use, it has hackable code, and it has become a firm favourite within our community. There have been rumours of a TS100 stablemate for some time now, with the model number being touted as a TS200 and with it being said to be USB-C powered. But beyond those tidbits, until now there has been not a lot to go on.

So [Marco Reps]’ video that we’ve placed below the break is a particularly interesting one, featuring as it does a prototype of the iron in question. It’s called the TS80 but there is evidence on its PCB that it has held the TS200 moniker in the past, it’s USB-C powered, and it features a new integrated heating element and bit with a Weller-style 3.5mm jack connector.

He runs it through a battery of tests and finds it to perform very well indeed, sometimes better than the TS100 despite his not having a USB-C power source capable of supplying the same voltage that his TS100 gets through its DC jack. To be clear, the TS100 is still a very good iron indeed, this one is simply a little bit better. Inside a sturdier metal barrel is a PCB with the STM32 on board as well as an OLED display that looks a little smaller than the one on the TS100. The shorter element receives praise, while the TS100 is hardly a long iron it is always good to get as close to the action as possible.

There is a concern over the lack of a DC jack and its reliance on USB-C, though he points out that with the appropriate cables and increasing USB-C adoption this should not remain a problem for long. We’d be interested to ensure that it can be powered through the USB-C socket from a simple DC power source such as a battery though, as that flexibility is such a bonus with the TS100.

So then, the TS80 is coming, but the TS100 is still a very good iron indeed so there’s no need to throw yours away any time soon. It’s an iron we look forward to seeing when it arrives though, and no doubt we’ll give you our verdict.

You can see our TS100 review if that takes your fancy, and while you’re at it take a look at one of the community’s most awesome TS100 hacks. [Marco] muses on how long it’ll be before someone has their TS80 playing audio through that 3.5mm jack.

Ken Shirriff Found Butterflies In His Op-Amp

พุธ, 06/27/2018 - 15:00

In 1976, Texas Instruments came out with the TL084, a four JFET op-amp IC each with similar circuitry to Fairchild’s very popular single op-amp 741. But even though the 741 has been covered in detailed, when [Ken Shirriff] focused his microscope on a TL084, he found some very interesting things.

To avoid using acid to get at the die, he instead found a ceramic packaged TL084 and pried off the cover. The first things he saw were four stabilizing capacitors, by far the largest structures on the die and visible to the naked eye.

When he peered into his microscope he next saw butterfly shapes which turned out to be pairs of input JFETs. The wide strips are the gates and the narrower strip surrounded by each gate is the source. The drain is the narrow strip surrounding each gate. Why arrange four JFETs like this? It’s possible to have temperature gradients in the IC, one side being hotter than the other. These gradients can affect the JFET’s characteristics, unbalancing the inputs. Look closely at the way the JFETs are connected and you’ll see that the top-left one is connected to the bottom-right one, and similarly for the other two. This diagonal cross-connecting cancels out any negative effects.

[Ken’s] analysis in his article doesn’t stop there though. Not only does he talk more about these JFETs but he goes over the rest of the die too. It’s well worth the read, as is his write-up about the 741 which we’ve also covered.

Never Go To The Office Breakroom Again

พุธ, 06/27/2018 - 12:00

If you’re tired of having to make small talk with random people in the office break room every time you need a cup of coffee, or simply don’t have the time to get up to pour yourself some more, it would be nice if there was a way you could have your cup filled for you, right at your desk. With this new drink dispenser, you won’t have to get up or even pour your drinks yourself!

We’ve certainly seen plenty of automatic drink makers, but those are more suited to parties and complicated drink mixing. This beverage dispenser is more for the person who knows their tastes and simply wants to save some time. It’s also much simpler, using a peristaltic pump for serving a single liquid from a large bottle into a glass, and using a load cell to know when to stop filling. The peristaltic pump is a little slow though, so it’s best to set the glass back in the dispenser and let it top you off each time.

We’re a big fan of time savers around here, especially when it comes to improving workflow. Of course, the best time saver is a clean, well-organized shop which will help you out whether you’re building a drink dispenser or anything else.

Wired and IBM Explain Quantum Computing to Students from Grade School to Grad School

พุธ, 06/27/2018 - 09:00

Have you ever heard the old axiom that if you want to design a simple system, ask yourself if your grandmother could use it? Maybe that was on Wired’s mind because they asked a quantum computing expert — particularly IBM’s [Dr. Talia Gershon] — to explain what exactly quantum computing is at 5 levels. In the video they shot, which you can see below, [Dr. Gershon] talks to a younger child, a teenager, an undergraduate computer science student, a graduate student, and then a physicist.

We enjoyed some of the analogies of spinning pennies and the way she was able to bring the topic to an appropriate level for each of the participants. Truthfully, the final segment with the physicist ([Dr. Steven Girvin] was more of a conversation than an explanation, but it was interesting to hear his views on fault tolerance and how likely certain things were to occur in the near future.

If you understand spin, superposition, and entanglement, you might not get a lot out of this video. However, we find putting things in basic terms — or in this case, hearing someone else do it — sometimes gives you a new insight. It would also be really helpful to watch if you plan to try to explain quantum computing to students.

There are a few comments about how quantum computers work that would have been better stated as “how IBM quantum computers work” but we can overlook that. But there are several competing architectures out there.

IBM has made a few smaller quantum machines available on the Web and we talked about how to use them and some simulators in a series last year. The simulators can be more fun because they are much more capable than the real things available today. However, there’s something visceral about working on real hardware, even if it is in the cloud.