Displaying Incoming Server Attacks By Giving Server Logs A Scoreboard

September 23, 2020 by Bryan Cockfield 9 Comments

In the server world, it’s a foregone conclusion that ports shouldn’t be exposed to the greater Internet if they don’t need to be. There are malicious bots everywhere that will try and randomly access anything connected to a network, and it’s best just to shut them off completely. If you have to have a port open, like 22 for SSH, it’ll need to be secured properly and monitored so that the administrator can keep track of it. Usually this is done in a system log and put to the side, but [Nick] wanted a more up-front reminder of just how many attempts were being made to log into his systems.

This build actively monitors attempts to log into his server on port 22 and notifies him via a numerical display and series of LEDs. It’s based on a Raspberry Pi Zero W housed in a 3D-printed case, and works by interfacing with a program called fail2ban running on the server. fail2ban‘s primary job is to block IP addresses that fail a certain number of login attempts on a server, but being FOSS it can be modified for situations like this. With some Python code running on the Pi, it is able to gather data fed to it from fail2ban and display it.

[Nick] was able to see immediate results too. Within 24 hours he saw 1633 login attempts on a server with normal login enabled, which was promptly shown on the display. A video of the counter in action is linked below. You don’t always need a secondary display if you need real-time information on your server, though. This Pi server has its own display built right in to its case.

Continue reading “Displaying Incoming Server Attacks By Giving Server Logs A Scoreboard” →

A Motorcycle Dashboard Straight From The ECU

September 21, 2020 by Bryan Cockfield 12 Comments

Classic motorcycles are the wild west of information displays. Often lacking even basic instrumentation such as a fuel gauge and sometimes even a speedometer, motorcycles have come a long way in instrument cluster design from even 20 years ago. There’s still some room for improvement, though, and luckily a lot of modern bikes have an ECU module that can be tapped into for some extra information as [Sophie Wheeler] illustrates with her auxiliary motorcycle dashboard.

This display is built for a modern Honda enduro, and is based upon an ESP32 module. The ESP32 is tied directly into the ECU via a diagnostic socket, unlike other similar builds that interface with a CAN bus specifically. It can monitor all of the bike’s activity including engine temperature, throttle position, intake air temperature, and whether or not the bike is in neutral. [Sophie] also added an external GPS sensor so the new display can also show GPS speed and location information within the same unit.

[Sophie] credits a few others for making headway into the Honda ECU. [Gonzo] created a similar build using a Raspberry Pi and more rudimentary screen but was instrumental in gathering the information for this build. If you’re looking for a display of any kind for your antique motorcycle which is lacking an ECU, though, we would suggest a speedometer made with nixie tubes.

Playing The Pixelflut

August 1, 2020 by Kerry Scharfglass 7 Comments

Every hacker gathering needs as many pixels as its hackers can get their hands on. Get a group together and you’ll be blinded by the amount of light on display. (We propose “a blinkenlights” as the taxonomic name for such a group.) At a large gathering, what better way to show of your elite hacking ability than a “competition” over who can paint an LED canvas the best? Enter Pixelflut, the multiplayer drawing canvas.

Pixelflut has been around since at least 2012, but it came to this author’s attention after editor [Jenny List] noted it in her review of SHA 2017. What was that beguiling display behind the central bar? It turns out it was a display driven by a server running Pixelflut. A Pixelflut server exposes a display which can be drawn on by sending commands over the network in an extremely simple protocol. There are just four ASCII commands supported by every server — essentially get pixel, set pixel, screen size, and help — so implementing either a client or server is a snap, and that’s sort of the point.

While the original implementations appear to be written by [defnull] at the link at the top, in some sense Pixelflut is more of a common protocol than an implementation. In a sense, one “plays” one of a variety of Pixelflut minigames. When there is a display in a shared space the game is who can control the most area by drawing the fastest, either by being clever or by consuming as much bandwidth as possible.

Then there is the game of who can write the fastest more battle-hardened server possible in order to handle all that traffic without collapsing. To give a sense of scale, one installation at 36c3 reported that a truly gargantuan 0.5 petabytes of data were spent at a peak of rate of more than 30 gigabits/second, just painting pixels! That’s bound to bog down all but the most lithe server implementation. (“Flut” is “flood” in German.)

While hacker camps may be on pause for the foreseeable future, writing a performant Pixelflut client or server seems like an excellent way to sharpen one’s skills while we wait for their return. For a video example check out the embed after the break. Have a favorite implementation? Tell us about it in the comments!

Continue reading “Playing The Pixelflut” →

Mechanical Seven-Segment Display Really Sticks Out From The Pack

July 27, 2020 by Dan Maloney 20 Comments

We’ve been displaying numbers using segmented displays for almost 120 years now, an invention that predates the LEDs that usually power the ubiquitous devices by a half-dozen decades or so. But LEDs are far from the only way to run a seven-segment display — check out this mechanical seven-segment display for proof of that.

We’ve been seeing a lot of mechanical seven-segment displays lately, and when we first spotted [indoorgeek]’s build, we thought it would be a variation on the common “flip-dot” mechanism. But this one is different; to form each numeral, the necessary segments protrude from the face of the display slightly. Everything is 3D-printed from white filament, yielding a clean look when the retracted but casting a sharp shadow when extended. Each segment carries a small magnet on the back which snuggles up against the steel core of a custom-wound electromagnet, which repels the magnet when energized and extends the segment. We thought for sure it would be loud, but the video below shows that it’s really quiet.

While we like the subtle contrast of the display, it might not be enough for some users, especially where side-lighting is impractical. In that case, they might want to look at this earlier similar display and try contrasting colors on the sides of each segment.

Continue reading “Mechanical Seven-Segment Display Really Sticks Out From The Pack” →

Watch Conway’s Game Of Life Flutter Across A Flip-Dot Display

July 2, 2020 by Donald Papp 21 Comments

Like many of us, [John Whittington] was saddened with the news that John Horton Conway passed away a little earlier this year, and in honor of his work, he added the Game of Life to a flip-dot display that he has been working on. The physicality of an electromechanical display seems particularly fitting for cellular automata.

Like what you see? If you’re curious about what makes it all tick, the display shown is an Alfa-Zeta XY5 28×14 but [John] is currently working on building them into a much larger 256 x 56 display. GitHub hosts the flip-dot simulator and driver software [John] is using, and the Game of Life functions are here.

If you’re new to the Game of Life and are not really sure what you’re looking at, [Elliot Williams] tells you all you need to know in his writeup celebrating its profound impact and lasting legacy. Watch the flip-dot display in action in the video embedded below.

Continue reading “Watch Conway’s Game Of Life Flutter Across A Flip-Dot Display” →

Mini Computer Brings Starfleet To Your Desk

June 14, 2020 by Jenny List 20 Comments

It could be said that there are two types of people: those for whom the actor LeVar Burton is the host of Reading Rainbow, and those for whom he is Geordi LaForge, Chief Engineer of Star Trek TNG‘s Enterprise NCC1701-D. For those of us engineers who lie in the second camp, we can at least feel a little closer to the action thanks to a project from [Darian Johnson], a Star Trek TNG mini-computer which functions as a desktop information display.

Inside the 3D-printed case is an ESP32 version of the Adafruit Feather, talking to cloud services to pull in and aggregate the information on the TFT screen. It combines weather data, environmental sensor readings, his fitness tracker readings, and his schedule, with two useful applications. There’s a resistor colour code chart, and an LED series resistor calculator. He’s made a video showing it in operation which we’ve placed below the break, and in it, he’s captured the aesthetic of the LCARS interface perfectly. We can’t speak for a fictional future spacecraft officer, but we suspect that Geordi would be right at home with it.

We may not be able to bring you Geordi LaForge, but we can bring you a real Starfleet officer. She even shares something with LeVar Burton, in that she’s (much more) famous for something else.

Continue reading “Mini Computer Brings Starfleet To Your Desk” →

Stealing RAM For A Microcontroller From A TFT Display

May 21, 2020 by Jenny List 12 Comments

PC users with long memories will recall the days when the one-megabyte barrier was a significant problem, and the various tricks of extended and expanded memory used to mitigate it. One of them was to install a driver that mapped surplus graphics card memory as system memory when the display was in DOS text mode, and it was this that was brought to mind when we read about [Frank D]’s microcontroller implementation of Conway’s Game Of Life.

The components were those he had to hand; an STM32F030F4P6 and an RM68130 176 × 220 TFT board. The STM is not the most powerful of chips, with only 16 kB of Flash and 4 kB of RAM. The display has enough on-board memory to support 18 bits of colour information, but when it is running in eight-colour mode it only uses three of them. The 15 bits that remain are thus available to be used for other purposes, and though the arcane format in which they are read required some understanding they could be used to provide a very useful extra 38720 bytes of RAM for the microcontroller just as once happened with those DOS PC graphics cards of old. Interestingly, the same technique should work with other similar displays.

Though this isn’t a new technique by any means we can’t recall seeing it used in a microcontroller project such as this one before. We’ve brought you many Games of Life though, as well as marking John Conway’s passing earlier this year.

Continue reading “Stealing RAM For A Microcontroller From A TFT Display” →