Homo Ludens is a book originally published in Dutch in 1938 by Dutch historian and cultural theorist Johan Huizinga. Huizinga suggests that play is a necessary condition of the generation of culture. Homo is the Latin word for 'human'. Ludens refers to sport, play, school, and practice.
Every opportunity now to sport, play, school, practice, and spend time on hobbies! See below for some projects I am working on.
I have never tried that before, so I think I should definitely be able to do that.
Astrid Lindgren, Pippi Longstocking
Work in progress
Knowing about software and knowing nothing about hardware: it will always be Work in Progress!
The movie The Imitation Game is about cryptanalyst Alan Turing who invented a machine (the Bombe) which decrypted German intelligence messages for the British government during the Second World War.
After watching it for the second time I started to dig into the work of Alan Turing again.
During my study he was one of the heroes within IT history I got to know.
(Fun fact: did you know that the T in Captcha stands for Turing?)
And being a hard software guy from origin I delved again into issues like Turing Machines, Backus-Naur Form languages, Boolean algebra and CPU microcode.
Microcode is the closest thing approaching hardware I studied. While walking down memory lane and trying to understand the evolution from the abacus, mechanical calculators, computers with vacuum tubes, transistors, integrated circuits and modern CPUs, I encountered the video's from Ben Eater.
Ben Eater's 8-bit homemade breadboard computer
Ben Eater has made a fantastic series of video's about making an 8-bit homemade breadboard computer.
A breadboard is a construction base for prototyping of electronics.
8 Bits means it is basic, slow and primitive!
It can only calculate with 8 zeroes/ones at a time.
Knowing nothing about hardware but with the help of Ben Eater and having the quote from Pippi Longstocking in mind ("I have never tried that before, so I think I should definitely be able to do that."), I decided to make this computer too!
The Beeb2
The first computer I ever bought was the BBC B micro computer.
The computer was designed by Cambridge based Acorn Computers Ltd. and used by the BBC in England in their Computer Literacy Project.
Acorn was later called Arm Ltd. (known for their licensable chip architectures) which now stands for Advanced RISC Machines,
but in the past stood for Acorn RISC Machine.
BBC B owners loved their computer and nicknamed it "the Beeb".
I have very fond memories of my Beeb, so decided to call this Ben Eater inspired 8-bit homemade breadboard computer I am going to make the Beeb2.
Beeb 2 Components and roadmap
Beeb 2 Components
The properties of the Beeb2 (and probably the easiest order to build the components) are:
I am already working on an Assembler and a Compiler. The Beeb4 could be a PCB version... We'll see, it is al going to be very agile! 😇
Tower of Hanoi
Building the Beeb2
Clock
The first module!
Switch for manual or auto setting
Push button for use in manual mode to generate 1 clock tick
Rotary knob to adjust clock speed
Orange HALT line
Program Counter (PC)
4 bit (16 addresses)
3 control lines: PC-OUT, PC-IN (jump), PC++ (stop/resume PC)
Bus
8 bit
A and B registers
Two registers are enough.
8 bit
2 control lines per register: A-IN, A-OUT, B-IN, B-OUT
Orange HALT lines
Sum Register
Tedious work, but in progress.
Finished Sum Register.
8 bit
2 control lines: SUM-OUT, ADD (add or subtract).
Arduino Programmer
Time to build a digital display.
To be able to program an EEPROM as a decoder for the LED display, I had to build an Arduino EEPROM programmer.
An Arduino Nano is part of that programmer.
The first window below contains the Arduino code to write and read the EEPROM.
The second window below shows the Arduino IDE output during that proces.
eeprom_programmer.ino
/* This sketch is specifically for programming the EEPROM used in the 8-bit decimal display decoder described in https://youtu.be/dLh1n2dErzE */
#define SHIFT_DATA 2
#define SHIFT_CLK 3
#define SHIFT_LATCH 4
#define EEPROM_D0 5
#define EEPROM_D7 12
#define WRITE_EN 13
/* Output the address bits and outputEnable signal using shift registers. */
void setAddress(int address, bool outputEnable) {
shiftOut(SHIFT_DATA, SHIFT_CLK, MSBFIRST, (address >> 8) | (outputEnable ? 0x00 : 0x80));
shiftOut(SHIFT_DATA, SHIFT_CLK, MSBFIRST, address);
digitalWrite(SHIFT_LATCH, LOW);
digitalWrite(SHIFT_LATCH, HIGH);
digitalWrite(SHIFT_LATCH, LOW);
}
/* Read a byte from the EEPROM at the specified address. */
byte readEEPROM(int address) {
for (int pin = EEPROM_D0; pin <= EEPROM_D7; pin += 1) {
pinMode(pin, INPUT);
}
setAddress(address, /*outputEnable*/ true);
delayMicroseconds(5); // Geef de voltages op het breadboard tijd om te stabiliseren
byte data = 0;
for (int pin = EEPROM_D7; pin >= EEPROM_D0; pin -= 1) {
data = (data << 1) + digitalRead(pin);
}
return data;
}
/* Write a byte to the EEPROM at the specified address.*/
void writeEEPROM(int address, byte data) {
setAddress(address, /*outputEnable*/ false);
for (int pin = EEPROM_D0; pin <= EEPROM_D7; pin += 1) {
pinMode(pin, OUTPUT);
}
for (int pin = EEPROM_D0; pin <= EEPROM_D7; pin += 1) {
digitalWrite(pin, data & 1);
data = data >> 1;
}
delayMicroseconds(10); // toegevoegd
digitalWrite(WRITE_EN, LOW);
delayMicroseconds(5); // verhoogd van 1 naar 5
digitalWrite(WRITE_EN, HIGH);
delay(20); // verhoogd van 10 naar 20
}
/* Leest elk bit en print het */
void printBinary(byte inByte) {
for (int i = 7; i >= 0; i--) {
Serial.print(bitRead(inByte, i)); // bitRead is een standaard Arduino functie
}
}
/* Program EEPROM */
void programEEPROM() {
byte digits[] = { 0x7e, 0x30, 0x6d, 0x79, 0x33, 0x5b, 0x5f, 0x70, 0x7f, 0x7b };
Serial.println("Programming EEPROM");
Serial.print("Programming ones place. ");
for (int value = 0; value <= 255; value += 1) {
writeEEPROM(value, digits[value % 10]);
}
Serial.print("Programming tens place. ");
for (int value = 0; value <= 255; value += 1) {
writeEEPROM(value + 256, digits[(value / 10) % 10]);
}
Serial.print("Programming hundreds place. ");
for (int value = 0; value <= 255; value += 1) {
writeEEPROM(value + 512, digits[(value / 100) % 10]);
}
Serial.println("Programming sign.");
for (int value = 0; value <= 255; value += 1) {
writeEEPROM(value + 768, 0);
}
Serial.print("Programming ones place (twos complement). ");
for (int value = -128; value <= 127; value += 1) {
writeEEPROM((byte)value + 1024, digits[abs(value) % 10]);
}
Serial.print("Programming tens place (twos complement). ");
for (int value = -128; value <= 127; value += 1) {
writeEEPROM((byte)value + 1280, digits[abs(value / 10) % 10]);
}
Serial.print("Programming hundreds place (twos complement). ");
for (int value = -128; value <= 127; value += 1) {
writeEEPROM((byte)value + 1536, digits[abs(value / 100) % 10]);
}
Serial.println("Programming sign (twos complement). ");
for (int value = -128; value <= 127; value += 1) {
if (value < 0) {
writeEEPROM((byte)value + 1792, 0x01);
} else {
writeEEPROM((byte)value + 1792, 0);
}
}
}
/* led-segment code to decimal */
byte convert_to_led_char(byte regel_entry) {
switch (regel_entry) {
case 0x7e: return (0);
case 0x30: return (1);
case 0x6d: return (2);
case 0x79: return (3);
case 0x33: return (4);
case 0x5b: return (5);
case 0x5f: return (6);
case 0x70: return (7);
case 0x7f: return (8);
case 0x7b: return (9);
case 0x0: return (0); // space
case 0x1: return (1); // minus (-) teken
default:
{
char buf[80];
sprintf(buf, "**** Onbekende regel_entry: %02x", regel_entry);
Serial.println(buf);
return(regel_entry);
}
}
}
/* print a chunk of addresses */
void print_base(int start_base, int end_base) {
byte regel[20];
char buf[80];
sprintf(buf, "%04d-%04d", start_base, end_base);
Serial.println(buf);
Serial.println(" 0 1 2 3 4 5 6 7 8 9");
for (int address = start_base; address <= end_base; address += 10) {
for (int regel_offset = 0; regel_offset <= 9; regel_offset += 1) {
if (address + regel_offset <= end_base) {
regel[regel_offset] = readEEPROM(address + regel_offset);
regel[regel_offset + 10] = convert_to_led_char(regel[regel_offset]);
} else {
regel[regel_offset] = 0;
regel[regel_offset + 10] = 0;
}
}
sprintf(buf, "%04d-%04d: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x - %1x %1x %1x %1x %1x %1x %1x %1x %1x %1x",
address, address + 9, regel[0], regel[1], regel[2], regel[3], regel[4], regel[5], regel[6], regel[7], regel[8], regel[9], regel[10], regel[11], regel[12], regel[13], regel[14], regel[15], regel[16], regel[17], regel[18], regel[19]);
Serial.println(buf);
}
Serial.println("");
}
/* Read the contents of the EEPROM and print them to the serial monitor. */
void showContents_v2() {
int start_base;
int base_step = 256;
int end_base;
Serial.println("");
Serial.println("Reading contents EEPROM");
Serial.println("1's places.");
start_base = 0;
end_base = base_step - 1;
print_base(start_base, end_base);
Serial.println("10's places.");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
Serial.println("100's places.");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
Serial.println("sign places.");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
// 2-Complement
Serial.println("1's places. (2-complement)");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
Serial.println("10's places. (2-complement)");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
Serial.println("100's places. (2-complement)");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
Serial.println("sign places. (2-complement)");
start_base = start_base + base_step;
end_base = end_base + base_step;
print_base(start_base, end_base);
}
void setup() {
pinMode(SHIFT_DATA, OUTPUT);
pinMode(SHIFT_CLK, OUTPUT);
pinMode(SHIFT_LATCH, OUTPUT);
digitalWrite(WRITE_EN, HIGH);
pinMode(WRITE_EN, OUTPUT);
Serial.begin(9600);
Serial.println();
Serial.println("-------------------------------------------------------------");
Serial.println("Bit patterns for the digits 0..9");
Serial.print("Char : ");
Serial.println(" 0 1 2 3 4 5 6 7 8 9");
byte digits[] = { 0x7e, 0x30, 0x6d, 0x79, 0x33, 0x5b, 0x5f, 0x70, 0x7f, 0x7b };
char buf[80];
Serial.print("Led-code: ");
for (int offset = 0; offset <= 9; offset += 1) {
sprintf(buf, " %02x ", digits[offset]);
Serial.print(buf);
}
Serial.println();
Serial.print("Binary : ");
for (int offset = 0; offset <= 9; offset += 1) {
printBinary(digits[offset]);
Serial.print(" ");
}
Serial.println();
Serial.print("Decimal : ");
for (int offset = 0; offset <= 9; offset += 1) {
sprintf(buf, " %03d ", digits[offset]);
Serial.print(buf);
}
Serial.println();
programEEPROM();
showContents_v2();
}
void loop() {}
This table compares two foundational methods for representing negative numbers in binary logic:
1's Complement and 2's Complement.
In both systems, the leftmost bit (the Sign Bit) dictates the sign of the number: 0 means positive, and 1 means negative.
1's Complement (The Legacy Method): To make a number negative, you simply invert all the bits (turn 0s into 1s, and 1s into 0s).
The Flaw: Look at the highlighted row. If you invert 0000 (+0), you get 1111 (-0).
This means the computer has to process two completely different binary codes for the exact same value (zero),
which requires extra logic gates and slows down calculations.
2's Complement (The Modern Standard): To make a number negative, you invert all the bits and then add 1.
The Fix: If you invert 0000 to 1111 and add 1, the binary counter rolls over back to 0000 (the 5th bit falls off in a 4-bit system).
As shown in the right column, 2's complement elegantly eliminates the "-0" anomaly,
leaving the computer with one unified, mathematically sound representation for zero.
Decimal
1's Complement
2's Complement
+5
0101
0101
+4
0100
0100
+3
0011
0011
+2
0010
0010
+1
0001
0001
0
0000
0000
-0
1111
-1
1110
1111
-2
1101
1110
-3
1100
1101
-4
1011
1100
-5
1010
1011
XRed bit indicates the Sign Bit (0 = Positive, 1 = Negative).
v1.05 - gs6.06
THE GHOST OF NEGATIVE ZERO
Discover how the Apollo 11 spacecraft handled the 1's complement anomaly, and how John von Neumann solved it forever.
THE ANCIENT ROOTS
The underlying mathematical principle of complements wasn't actually invented for digital computers. The "method of complements" (specifically 10's and 9's complement) had been used for a long time in mechanical calculators and decimal adding machines (like the Pascaline, invented by Blaise Pascal in the 1600s).
It allowed these mechanical gears to perform subtraction simply by running the addition mechanism forward with a complement (a 'mirror' number that turns subtraction into addition), rather than having to build complex reversing gears.
THE APOLLO 11 QUIRK
The Apollo Guidance Computer (AGC) that landed Neil Armstrong on the moon in 1969 did not use the modern 2's Complement system. To save hardware complexity, NASA engineers built the AGC utilizing 1's Complement arithmetic.
Two Kinds of Nothing
This meant the AGC's software had to constantly deal with the "-0" anomaly. The computer possessed two entirely distinct binary states for the number zero: 000000000000000 (+0) and 111111111111111 (-0).
Software Acrobatics
If the guidance software compared +0 and -0 directly, the computer would rigidly conclude they were not equal. NASA's programmers had to code special mathematical safeguards into the lunar descent logic to ensure a rogue "-0" wouldn't cause the spacecraft to crash or miscalculate its trajectory.
THE VON NEUMANN MASTERSTROKE
The specific 2's Complement system for binary electronic computers was introduced by the brilliant mathematician John von Neumann in 1945. He formally proposed it in his legendary foundational paper, "First Draft of a Report on the EDVAC".
Simplifying the Hardware
Von Neumann explicitly argued that utilizing the 2's complement method would massively simplify the hardware needed for the computer's Arithmetic Logic Unit (ALU). The machine would no longer need separate, complex circuitry to handle subtraction.
The Global Standard
Because it elegantly eliminated the "-0" anomaly and streamlined calculations, von Neumann's 1945 proposal became the undisputed standard for integer mathematics in almost all modern microprocessors.
THE MODERN SURVIVOR
While integers strictly use 2's complement, modern computers handle decimal numbers using the IEEE 754 standard. This standard utilizes a dedicated sign bit separate from the number itself—almost exactly like the old 1's Complement logic!
Your CPU Still Has -0
Because of this architectural choice, your brand new 64-bit smartphone or gaming PC still has a hardwired representation for -0.0. In advanced programming and scientific calculations, dividing by +0.0 yields positive infinity, while dividing by -0.0 yields negative infinity.
The movie The Imitation Game is about cryptanalyst Alan Turing who invented a machine (the Bombe) which decrypted German intelligence messages for the British government during the Second World War.
After watching it for the second time I started to dig into the work of Alan Turing again.
During my study he was one of the heroes within IT history I got to know.
(Fun fact: did you know that the T in Captcha stands for Turing?)
And being a hard software guy from origin I delved again into issues like Turing Machines, Backus-Naur Form languages, Boolean algebra and CPU microcode.
Microcode is the closest thing approaching hardware I studied. While walking down memory lane and trying to understand the evolution from the abacus, mechanical calculators, computers with vacuum tubes, transistors, integrated circuits and modern CPUs, I encountered the video's from Ben Eater.
Ben Eater has made a fantastic series of video's about making an 8-bit homemade breadboard computer.
A breadboard is a construction base for prototyping of electronics.
8 Bits means it is basic, slow and primitive!
It can only calculate with 8 zeroes/ones at a time.
Knowing nothing about hardware but with the help of Ben Eater and having the quote from Pippi Longstocking in mind ("I have never tried that before, so I think I should definitely be able to do that."), I decided to make this computer too!
The first computer I ever bought was the BBC B micro computer.
The computer was designed by Cambridge based Acorn Computers Ltd. and used by the BBC in England in their Computer Literacy Project.
Acorn was later called Arm Ltd. (known for their licensable chip architectures) which now stands for Advanced RISC Machines,
but in the past stood for Acorn RISC Machine.
BBC B owners loved their computer and nicknamed it "the Beeb".
I have very fond memories of my Beeb, so decided to call this Ben Eater inspired 8-bit homemade breadboard computer I am going to make the Beeb2.
The properties of the Beeb2 (and probably the easiest order to build the components) are:
Finished Sum Register.
