There’s an old saying that the cobbler’s children have no shoes. Sometimes we feel that way because we stay busy designing things for other people or for demos that we don’t have time to just build something we want. [Blue Blade Fish] wanted to build an Arduino-based aquarium controller. He’s detailed the system in (so far) 14 videos and it looks solid.

This isn’t just a simple controller, either. It is a modular design with an Arduino Mega and a lot of I/O for a serious fish tank. There are controls for heaters, fans, lights, wave makers and even top-off valves. The system can simulate moonlight at night and has an LCD display and keys. There’s also an Ethernet port and a Raspberry Pi component that creates a web interface, data storage, and configures the system. Even fail safes have been designed into the system, so you don’t boil or freeze expensive fishes. No wonder it took 14 videos!

We really liked the moonlight which has 32 LEDs with custom switching and a shift register. In front of the LEDs is — surprise — a picture of the moon. We wondered how it would be with a 3D-printed lilthophane which might diffuse the LEDs more. Because of the shift register, it is simple to control all the lights with just a few pins.

Apparently, giving fish an idea of the ambient lighting outside is important to people who keep fish. Because of the safeguards, a bad software bug isn’t going to boil his fish. Despite the looks, apparently neither will this upcycled fish tank.

What do you program the Arduino in? C? Actually, the Arduino’s byzantine build processes uses C++. All the features you get from the normal libraries are actually C++ classes. The problem is many people write C and ignore the C++ features other than using object already made for them. Just like traders often used pidgin English as a simplified language to talk to non-English speakers, many Arduino coders use pidgin C++ to effectively code C in a C++ environment. [Bert Hubert] has a two-part post that isn’t about the Arduino in particular, but is about moving from C to a more modern C++.

Even those of us who use C++ often use what we think of as “classic” C++. More or less the C++ that started life as a preprocessor in front of the C compiler. C++ has changed a lot since then, though. [Bert] looks mostly at useful features from the C++ 2014 standard which is widely available in compilers now. He only talks a little about some 2017 features. He doesn’t, however, talk about super new features or very specialized features that probably won’t be your first stop in a transition from C.

In particular, [Bert] doesn’t cover multiple inheritance, template metaprogramming, a big chunk of iostreams, C++ locales, user-defined literals, or exotics. Just to motivate you, he shows an example where calling the C library to sort a large array is slower than the code using C++ templates that take advantage of parallelism. While this is a special case, it does show that C++ isn’t just “another way to write the same thing.” You could write a faster sort in C, but you’d be writing a lot of code, not just pulling in a library.

What he does cover is strings, namespaces, classes, smart pointers, threads and error handling. Some of these will be more useful on the Arduino than others, but if you are writing for other platforms like a PC or a Raspberry Pi you could use all of them. He’s planning on adding more items in future installments of the series.

Meanwhile, we had our own story about modern C++ and the Arduino last year. If you want to know more about templates, we’ve talked about that, too.

Housing exotic plants or animals offer a great opportunity to get into the world of electronic automation. When temperature, light, and humidity ranges are crucial, sensors are your best friend. And if woodworking and other types of crafts are your thing on top, why not build it all from scratch. [MagicManu] did so with his Jurassic Park themed octagonal dome built from MDF and transparent polystyrene.

With the intention to house some exotic plants of his own, [MagicManu] equipped the dome with an Arduino powered control system that regulates the temperature and light, and displays the current sensor states on a LCD, including the humidity. For reasons of simplicity regarding wiring and isolation, the humidity itself is not automated for the time being. A fan salvaged from an old PC power supply provides proper ventilation, and in case the temperature inside the dome ever gets too high, a servo controlled set of doors that match the Jurassic Park theme, will automatically open up.

[MagicManu] documented the whole build process in a video, which you can watch after the break — in French only though. We’ve seen a similar DIY indoor gardening project earlier this year, and considering its simple yet practical application to learn about sensors, plus a growing interest in indoor gardening itself (pun fully intended), this certainly won’t be the last one.

We’ve talked about the Sinclair scientific calculator before many times, and for some of us it was our first scientific calculator. If you can’t find yours or you never had one, now you can build your own using — what else — an Arduino thanks to [Arduino Enigma]. There’s a video, below and the project’s homepage on Hackaday.io describes it all perfectly:

The original chip inside the Sinclair Scientific Calculator was reverse engineered by Ken Shirriff, its 320 instruction program extracted and an online emulator written. This project ports that emulator, written in Javascript, to the Arduino Nano and interfaces it to a custom PCB. The result is an object that behaves like the original calculator, with its idiosyncrasies and problems. Calculating PI as arctan(1)*4 yields a value of 3.1440.

Special care was taken in the design of the emulator to match the execution speed of the
original calculator, which varies from acceptable to atrocious for trigonometric functions involving small angles.

Oddly, the calculator started life as a hack on the KIM-1 UNO. However, six board revisions changed the layout quite a bit and made the emulation more and more accurate both software-wise and physically. If you fancy a close look at an original Sinclair we subjected one to a teardown.

The KIM-1 UNO board has had a lot of life poured into it. We used it as a clock and an 1802 emulator. Oscar even built off of the 1802 code to add video output.

Ever find yourself with nineteen nameless robot vacuums lying around? No? Well, [Aaron Christophel] likes to live a different life, filled with zebra print robots (translated). After tearing a couple down, only ten vacuums remain — casualties are to be expected. Through their sacrifice, he found a STM32F101VBT6 processor acting as the brains for the survivors. Coincidentally, there’s a project called STM32duino designed to get those processors working with the Arduino IDE we either love or hate. [Aaron Christophel] quickly added a variant board through the project and buckled down.

Of course, he simply had to get BLINK up and running, using the back-light of the LCD screen on top of the robots. From there, the STM32 processors gave him a whole 80 GPIO pins to play with. With a considerable amount of tinkering, he had every sensor, motor, and light under his control. Considering how each of them came with a remote control, several infra-red sensors, and wheels, [Aaron Christophel] now has a small robotic fleet at his beck and call. His workshop must be immaculate by now. Maybe he’ll add a way for the vacuums to communicate with each other next. One robot gets the job done, but a whole team gets the job done in style, especially with a zebra print cleaner at the forefront.

If you want to see more of his work, he has quite a few videos on his website demonstrating the before and after of the project — just make sure to bring a translator. He even has a handy pinout for those looking to replicate his work. If you want to dive right in to STM32 programming, we have a nice article on how to get it up and debugged. Otherwise, enjoy [Aaron Christophel]’s demonstration of the eight infra-red range sensors and the custom firmware running them.

With the June solstice right around the corner, it’s a perfect time to witness first hand the effects of Earth’s axial tilt on the day’s length above and beyond 60 degrees latitude. But if you can’t make it there, or otherwise prefer a more regular, less deprived sleep pattern, you can always resort to simulations to demonstrate the phenomenon. [SimonRob] for example built a clock with a real time rotating model of Earth to visualize its exposure to the sun over the year.

The daily rotating cycle, as well as Earth’s rotation within one year, are simulated with a hand painted plastic ball attached to a rotating axis and mounted on a rotating plate. The hand painting was done with a neat trick; placing printed slivers of an atlas inside the transparent orb to serve as guides. Movement for both axes are driven by a pair of stepper motors and a ring of LEDs in the same diameter as the Earth model is used to represent the Sun. You can of course wait a whole year to observe it all in real time, or then make use of a set of buttons that lets you fast forward and reverse time.

Earth’s rotation, and especially countering it, is a regular concept in astrophotography, so it’s a nice change of perspective to use it to look onto Earth itself from the outside. And who knows, if [SimonRob] ever feels like extending his clock with an aurora borealis simulation, he might find inspiration in this northern lights tracking light show.

This is a spectacular showpiece and a great project you can do with common tools already in your workshop. Once you’ve mastered earth, put on your machinists hat and give the solar system a try.

It’s probably fair to say that anyone reading these words understands conceptually how physically connected devices communicate with each other. In the most basic configuration, one wire establishes a common ground as a shared reference point and then the “signal” is sent over a second wire. But what actually is a signal, how do the devices stay synchronized, and what happens when a dodgy link causes some data to go missing?

All of these questions, and more, are addressed by [Ben Eater] in his fascinating series on data transmission. He takes a very low-level approach to explaining the basics of communication, starting with the concept of non-return-to-zero encoding and working his way to a shared clock signal to make sure all of the devices in the network are in step. Most of us are familiar with the data and clock wires used in serial communications protocols like I2C, but rarely do you get to see such a clear and detailed explanation of how it all works.

He demonstrates the challenge of getting two independent devices to communicate, trying in vain to adjust the delays on the receiving and transmitting Arduinos to try to establish a reliable link at a leisurely five bits per second. But even at this digital snail’s pace, errors pop up within a few seconds. [Ben] goes on to show that the oscillators used in consumer electronics simply aren’t consistent enough between devices to stay synchronized for more than a few hundred bits. Until atomic clocks come standard on the Arduino, it’s just not an option.

[Ben] then explains the concept of a dedicated clock signal, and how it can be used to make sure the devices are in sync even if their local clocks drift around. As he shows, as long as the data signal and the clock signal are hitting at the same time, the actual timing doesn’t matter much. Even within the confines of this basic demo, some drift in the clock signal is observed, but it has no detrimental effect on communication.

In the next part of the series, [Ben] will tackle error correction techniques. Until then, you might want to check out the fantastic piece [Elliot Williams] put together on I2C.

[Thanks to George Graves for the tip.]

We’d wager that most people reading these words have never used a loom before. Nor have most of you churned butter, or ridden in a horse-drawn wagon. Despite these things being state of the art technology at one point, today the average person is only dimly aware of their existence. In the developed world, life has moved on. We don’t make our own clothes or grow our own crops. We consume, but the where and how of production has become nebulous to us.

[David Heisserer] and his wife [Danielle Everine], believe this modern separation between consumption and production is a mistake. How can we appreciate where our clothing comes from, much less the people who make it, without understanding the domestic labor that was once required to produce even a simple garment? In an effort to educate the public on textile production in a fun and meaningful way, they’ve created a poetry printing loom called Meme Weaver.

The Meme Weaver will be cranking out words of woolen wisdom at the Northern Spark Festival taking place June 15th and 16th in downtown Minneapolis. If any Hackaday readers in the area get a chance to check out the machine, we’d love to hear about it in the comments. Take photos! Just don’t blame us if you have a sudden urge to make all of your clothing afterwards.

Equal parts Guitar Hero and Little House on the Prairie, the Meme Weaver merely instructs the user on how to weave the fabric, it doesn’t do it for them. Lights and sounds provided by an Arduino Mega and Adafruit FX board indicate which levers to pull, with the end goal being the creation of a two-inch wide strip of hand-woven fabric that contains a poem or quote. The act of weaving the fabric by hand combined with the personalized nature of the text is intended to create a meaningful link between the finished product and the labor used to create it.

But how does it work? The operation of the machine seems mysterious to modern eyes, which arguably reinforces the point [David] and [Danielle] are trying to make in the first place. The levers on the front are moving heddles on the opposite side of the machine, which control the path the yarn takes through the loom.

By raising and lowering the white yarn, it’s possible to print text in what is essentially an ultra-low-resolution dot matrix. When the heddle levers are locked into place (thanks to electromagnets triggered by microswitches), the user then passes the shuttle through the loom, and finally pulls the lever that tightens up the completed line with what’s known as the beater. If that seems complex to your modern mind, imagine trying to explain an Arduino to somebody in the 1800’s.

If all this talk of weaving has caught your interest, you could always 3D print yourself a loom of your own. Then when you get tired of doing it by hand, you can upgrade to a Raspberry Pi powered version and start the whole cycle over again.

[Andreas] may have created the ultimate lazy hacker accessory: automatic sunglasses, or “Selfblending sunglasses” as he creatively titled his video. If you can’t tell from the name, these are glasses that you never have to take off. If the light is dim, they move away from your eyes. Going back outside to bright light? The glasses move to protect your eyes.

The glasses consist of a couple of micro servos which move tinted lenses toward or away from the user’s eyes. A side-mounted Arduino Uno reads a CdS cell light sensor and drives the servos.  Why an Uno rather than a much more wearable Arduino Nano? It’s what [Andreas] had lying around.

Yes, a good portion of the fun of this build is [Andreas’] comedy. But the best part comes when he tests the glasses out — in an actual car on the highway. The glasses work better than expected — moving the lenses into and out of [Andreas] field of view as he drives through tunnels. You can actually see how surprised [Andreas] is that it works so well.

These aren’t the first automatic sunglasses we’ve seen, nor are they the most peril-sensitive. Still, it’s a fun project and the video gave us a few chuckles.

There was a time when having a blinking blue LED on a project was all you needed to be one of the cool kids. But now you need something more complex. LEDs should not just snap on, they should fade in and out. And blinking? Today’s hotness is breathing LEDs. If that’s the kind of project you want, you should check out [jandelgado’s] jled library.

At first glance, an Arduino library for LED control might seem superfluous, but if you are interested in nice effects, the coding for them can be a bit onerous. If you don’t mind stopping everything while you fade an LED on (or off) then sure, you just write a loop and it is a few lines of code. But if you want to have it happen while other things continue to execute, it is a little different. The library makes it very simple and it is also nicely documented.

Obviously, to create a special effect LED, you need to create a JLed object. Then you can use modifier methods on that object to get certain effects. The only overhead is that you need to call the update method on the LED periodically. Here is one of the examples from the project:

#include <jled.h>

// connect LED to pin 13 (PWM capable). LED will breathe with period of
// 2000ms and a delay of 1000ms after each period.
JLed led = JLed(13).Breathe(2000).DelayAfter(1000).Forever();

void setup() { }

void loop() {
   led.Update();
}

Pretty easy and readable. Just remember that some Arduinos can’t do PWM on pin 13, so you might have to adjust. Our only complaint is that you have to update each LED. It would be nice if the JLed constructor kept a linked list of all LED objects so you could have a class method that updates all of them with one call. In the examples, the author keeps all the LEDs in an array and steps through that. However, that would be easy to fork and add. Oh wait, we did it for you. The library does do a lot of work, including taking advantage of higher PWM resolution available on the ESP8266, for example.

The library can turn an LED on or off (including delays), blink or breathe an LED forever or for a certain number of times, or fade an LED on or off. In addition to the presets, you can provide your own brightness function if you want to do some kind of custom pattern. You can modify most actions by specifying a delay before or after, a repeat count (which can be forever) and you can also tell the library that your LED is active low, so you don’t have to mentally remember to flip everything around in your code.

Rocket science? No. But we like it. Blocking for an LED effect is bad and this makes fancy asynchronous LEDs simple. Why not use it? Recent IDEs can install it from the manage library dialog, so it takes just a second.

Really, libraries are a key to building systems simple. Why not stand on the backs of others? Some of our favorites handle SPI and proportional integral derivative (PID) control.