Procedural generation is a big part of game design these days. Usually you generate your map, and [Fractal Philosophy] has decided to go one step further: using a procedurally-generated world from an older video, he is procedurally generating history by simulating the rise and fall of empires on that map in a video embedded below.
Now, lacking a proper theory of Psychohistory, [Fractal Philosophy] has chosen to go with what he admits is the simplest model he could find, one centered on the concept of “solidarity” and based on the work of [Peter Turchin], a Russian-American thinker. “Solidarity” in the population holds the Empire together; external pressures increase it, and internal pressures decrease it. This leads to an obvious cellular automation type system (like Conway’s Game of Life), where cells are evaluated based on their nearest neighbors: the number of nearest neighbors in the empire goes into a function that gives the probability of increasing or decreasing the solidarity score each “turn”. (Probability, in order to preserve some randomness.) The “strength” of the Empire is given by the sum of the solidarity scores in every cell. Continue reading “Simulating Empires With Procedurally Generated History”→
LTSpice is a tool that every electronics nerd should have at least a basic knowledge of. Those of us who work professionally in the analog and power worlds rely heavily on the validity of our simulations. It’s one of the basic skills taught at college, and essential to truly understand how a circuit behaves. [Mano] has quite a collection of videos about the tool, and here is a great video explanation of how a bootstrap circuit works, enabling a high-side driver to work in the context of driving a simple buck converter. However, before understanding what a bootstrap is, we need to talk a little theory.
Bootstrap circuits are very common when NMOS (or NPN) devices are used on the high side of a switching circuit, such as a half-bridge (and by extension, a full bridge) used to drive a motor or pump current into a power supply.
A simple half-bridge driving illustrates the high-side NMOS driving problem.
From a simplistic viewpoint, due to the apparent symmetry, you’d want to have an NMOS device at the bottom and expect a PMOS device to be at the top. However, PMOS and PNP devices are weaker, rarer and more expensive than NMOS, which is all down to the device physics; simply put, the hole mobility in silicon and most other semiconductors is much lower than the electron mobility, which results in much less current. Hence, NMOS and NPN are predominant in power circuits.
As some will be aware, to drive a high-side switching transistor, such as an NPN bipolar or an NMOS device, the source end will not be at ground, but will be tied to the switching node, which for a power supply is the output voltage. You need a way to drive the gate voltage in excess of the source or emitter end by at least the threshold voltage. This is necessary to get the device to fully turn on, to give the lowest resistance, and to cause the least power dissipation. But how do you get from the logic-level PWM control waveform to what the gate needs to switch correctly?
The answer is to use a so-called bootstrap capacitor. The idea is simple enough: during one half of the driving waveform, the capacitor is charged to some fixed voltage with respect to ground, since one end of the capacitor will be grounded periodically. On the other half cycle, the previously grounded end, jumps up to the output voltage (the source end of the high side transistor) which boosts the other side of the capacitor in excess of the source (because it got charged already) providing a temporary high-voltage floating supply than can be used to drive the high-side gate, and reliably switch on the transistor. [Mano] explains it much better in a practical scenario in the video below, but now you get the why and how of the technique.
If you’ve ever fumbled through circuit simulation and ended up with a flatline instead of a sine wave, this video from [saisri] might just be the fix. In this walkthrough she demonstrates simulating a Colpitts oscillator using NI Multisim 14.3 – a deceptively simple analog circuit known for generating stable sine waves. Her video not only shows how to place and wire components, but it demonstrates why precision matters, even in virtual space.
You’ll notice the emphasis on wiring accuracy at multi-node junctions, something many tutorials skim over. [saisri] points out that a single misconnected node in Multisim can cause the circuit to output zilch. She guides viewers step-by-step, starting with component selection via the “Place > Components” dialog, through to running the simulation and interpreting the sine wave output on Channel A. The manual included at the end of the video is a neat bonus, bundling theory, waveform visuals, and circuit diagrams into one handy PDF.
If you’re into precision hacking, retro analogue joy, or just love watching a sine wave bloom onscreen, this is worth your time. You can watch the original video here.
Fluid simulations are a key tool in fields from aerospace to motorsports and even civil engineering. They can be three-dimensional and complicated and often run on supercomputer clusters bigger than your house. However, you can also do simple two-dimensional fluid simulations on very simple hardware, as [mircemk] demonstrates.
This build is almost like a simple toy that displays particles rolling around and tumbling as you turn it one way or the other. Behind the scenes, an ESP32 is running the show, simulating a group of particles responding to gravity in a fluid-like manner. The microcontroller is hooked up with an 3-axis gyroscope and accelerometer, which it uses to track motion and influence the motion of the particles in turn. The results of the simple fluid simulation are displayed on a screen made up of a 16 x 16 matrix of WS2812B addressable RGB LEDs, which add enough color to make the build suitably mesmerizing.
There’s something compelling about turning the display and watching the particles tumble and flow, particularly when they’re all set to different colors. [mircemk] also gave the build the ability to operate in several different modes, running “sand,” “liquid” and “gas” simulations and with dynamic coloring to boot.
Some projects seem to take on a life of their own. You get an idea, design and prototype it, finally build the thing and — it’s good, but it’s not quite right. Back to the drawing board, version 2, still not perfect, lather, rinse, repeat. Pretty soon you look around to discover that you’ve built ten of them. Oops.
That seems to be the arc followed by [mitxela] with this very cool fluid simulation pendant. The idea is simple enough; create a piece of jewelry with a matrix of tiny LEDs that act like the pendant is full of liquid, sloshing about with the slightest movement. In practice, though, this project was filled with challenges. Surprisingly, [mitxela] doesn’t seem to number getting a fluid dynamics simulation running on a microcontroller among those problems, at least not to a great degree. Rather, the LED matrix seemed to cause the most problems, both in terms of laying it out on the 25-mm diameter PCB and how to address the LEDs with relatively limited GPIO on the STM32 microcontroller. The solution to both was diagonal charlieplexing, which reduces the number of vias needed for the 216-LED matrix and allows the 0402 to be densely packed, along with providing some tolerance for solder bridging.
And then there’s the metalworking heroics, which no [mitxela] project would be complete without. This seems to be where a lot of the revisions come from, as the gold-plated brass case kept not quite living up to expectations. The final version is a brass cup containing the LiR2450 rechargeable battery, a magnetic charging connector, and the main PCB, all sealed by a watch crystal. The fluid simulation is quite realistic and very responsive to the pendant’s position. The video below shows it in action along with a summary of the build.
Although largely relegated to retrocomputing enthusiasts and embedded systems or microcontrollers now, there was a time when there were no other computers available other than those with 8-bit processors. The late 70s and early 80s would have seen computers with processors like the Motorola 6800 or Intel 8080 as the top-of-the-line equipment and, while underpowered by modern standards, these machines can do quite a bit of useful work even today. Mathematician [Jean Michel Sellier] wanted to demonstrate this so he set up a Commodore 64 to study some concepts like simulating a quantum computer.
The computer programs he’s written to do this work are in BASIC, a common high-level language of the era designed for ease of use. To simulate the quantum computer he sets up a matrix-vector multiplication but simplifies it using conditional logic. Everything is shown using the LIST command so those with access to older hardware like this can follow along. From there this quantum computer even goes as far as demonstrating a quantum full adder.
We received belated word this week of the passage of Ward Christensen, who died unexpectedly back in October at the age of 78. If the name doesn’t ring a bell, that’s understandable, because the man behind the first computer BBS wasn’t much for the spotlight. Along with Randy Suess and in response to the Blizzard of ’78, which kept their Chicago computer club from meeting in person, Christensen created an electronic version of a community corkboard. Suess worked on the hardware while Christensen provided the software, leveraging his XMODEM file-sharing protocol. They dubbed their creation a “bulletin board system” and when the idea caught on, they happily shared their work so that other enthusiasts could build their own systems.
