hyperdramatik - Benutzerbeiträge [de]

Kalte Ecken im Koffer

2021-03-10T22:08:27Z

AKrause: /* Project Description */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informant of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Center of the story is the novel “Ich” written by Wolgang Hilbig. Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 mechanical keyswitches from [https://en.wikipedia.org/wiki/Cherry_(company) cherry keys]
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The briefcase was built to resemble a fictional device the Ministry of State Security (MfS) could have had in use. Therefore robust switches known for their military use were installed to enter the codes. The enclosed walkie-talkie is a modded version of an original model often used by the [https://en.wikipedia.org/wiki/Stasi Stasi]. Aiming to merge authenticity and fiction, the present-day tech, e.g. the touchscreen and Lattepanda, was covered with an outworn skin from an old Russian mobile television. Retrofitted cherry keys provide for a certain kind of old school feeling by their mechanical feedback and the specifically added yellowish lacquer.

All documents given in the briefcase are additionally weathered, e.g. using soy sauce, and drafted using an old typewriter. Pen and paper are original witnesses of the Soviet era. Seven several kinds of paper were used, resembling GDR documents, e.g. a train ticket was printed on a different kind of paper than a permit to enter West-Berlin. The former was additionally flexed and folded due to its imaginary use as a commodity item. Whereas the latter depicts a rare document of singular value.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T22:07:02Z

AKrause: /* Project Description */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informant of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Center of the story is the novel “Ich” written by Wolgang Hilbig. Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered. Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 mechanical keyswitches from [https://en.wikipedia.org/wiki/Cherry_(company) cherry keys]
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The briefcase was built to resemble a fictional device the Ministry of State Security (MfS) could have had in use. Therefore robust switches known for their military use were installed to enter the codes. The enclosed walkie-talkie is a modded version of an original model often used by the [https://en.wikipedia.org/wiki/Stasi Stasi]. Aiming to merge authenticity and fiction, the present-day tech, e.g. the touchscreen and Lattepanda, was covered with an outworn skin from an old Russian mobile television. Retrofitted cherry keys provide for a certain kind of old school feeling by their mechanical feedback and the specifically added yellowish lacquer.

All documents given in the briefcase are additionally weathered, e.g. using soy sauce, and drafted using an old typewriter. Pen and paper are original witnesses of the Soviet era. Seven several kinds of paper were used, resembling GDR documents, e.g. a train ticket was printed on a different kind of paper than a permit to enter West-Berlin. The former was additionally flexed and folded due to its imaginary use as a commodity item. Whereas the latter depicts a rare document of singular value.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T22:04:47Z

AKrause: /* Project Description */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Center of the story is the novel “Ich” written by Wolgang Hilbig. Following the voice of M.W., the person playing the briefcase steers the on-screen cursor to receive information via sound snippets and thus sets the order in which those are discovered. Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 mechanical keyswitches from [https://en.wikipedia.org/wiki/Cherry_(company) cherry keys]
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The briefcase was built to resemble a fictional device the Ministry of State Security (MfS) could have had in use. Therefore robust switches known for their military use were installed to enter the codes. The enclosed walkie-talkie is a modded version of an original model often used by the [https://en.wikipedia.org/wiki/Stasi Stasi]. Aiming to merge authenticity and fiction, the present-day tech, e.g. the touchscreen and Lattepanda, was covered with an outworn skin from an old Russian mobile television. Retrofitted cherry keys provide for a certain kind of old school feeling by their mechanical feedback and the specifically added yellowish lacquer.

All documents given in the briefcase are additionally weathered, e.g. using soy sauce, and drafted using an old typewriter. Pen and paper are original witnesses of the Soviet era. Seven several kinds of paper were used, resembling GDR documents, e.g. a train ticket was printed on a different kind of paper than a permit to enter West-Berlin. The former was additionally flexed and folded due to its imaginary use as a commodity item. Whereas the latter depicts a rare document of singular value.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T22:01:27Z

AKrause: /* Thought about the haptics of the project */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 mechanical keyswitches from [https://en.wikipedia.org/wiki/Cherry_(company) cherry keys]
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The briefcase was built to resemble a fictional device the Ministry of State Security (MfS) could have had in use. Therefore robust switches known for their military use were installed to enter the codes. The enclosed walkie-talkie is a modded version of an original model often used by the [https://en.wikipedia.org/wiki/Stasi Stasi]. Aiming to merge authenticity and fiction, the present-day tech, e.g. the touchscreen and Lattepanda, was covered with an outworn skin from an old Russian mobile television. Retrofitted cherry keys provide for a certain kind of old school feeling by their mechanical feedback and the specifically added yellowish lacquer.

All documents given in the briefcase are additionally weathered, e.g. using soy sauce, and drafted using an old typewriter. Pen and paper are original witnesses of the Soviet era. Seven several kinds of paper were used, resembling GDR documents, e.g. a train ticket was printed on a different kind of paper than a permit to enter West-Berlin. The former was additionally flexed and folded due to its imaginary use as a commodity item. Whereas the latter depicts a rare document of singular value.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

How to connect old tech with speakers to bluetooth?

2021-03-10T15:24:36Z

AKrause: /* How does it work? */

[[Datei:Kalte_Ecken_Funke2.jpg|200px|thumb|right|Foto by Laura Alapfy]]
The technique is called case modding. So you took a device and built it into a cool case.
== What do you need? ==
* soldering iron and stuff to solder

* pliers and screwdrivers

* a bluetooth board (I ordered this [https://www.ebay.de/itm/BT201-MP3-Player-Decoder-Bluetooth-5-0-Modul-TF-Card-Reader-UDisk-USB-3-3-5V-/284105739580?var=&hash=item4226058d3c, one])

* a battery according to your needs (for me this [https://www.ebay.de/itm/2-x-LG-INR-18650HG2-Li-Ion-Akku-3-6V-3-7V-3000mAh-20A-einzeln-Trimax/293447981910?epid=18031293334&hash=item4452dcdb56:g:a5gAAOSwA75eMCR0 ,one] worked)

* A [https://www.ebay.de/itm/Ladegerat-Ladestation-universal-Charger-18650-14500-Akku-Batterie-3-7V-AA-AAA/112109635119?hash=item1a1a41462f:g:S90AAOSwtZJY~3L1, charger] for your batteries

== How does it work? ==
First the vintage piece of technology has to be disassembled and the speaker must be located. Furthermore the two wires exiting the speaker need to be disconnected.
Next, solder those wires directly to the speaker input solder pads on the Bluetooth board.

Finding a good place for the battery is essential, maybe you could reuse the old battery compartment. Test the Bluetooth board by connecting the battery, that allows the LED to flash.

As soon as the LED is lighting up, the Bluetooth board can be connected to a phone or computer in order to play a song chosen on your device.

The board I used has a microphone suitable for Bluetooth headset mode. In case you would additionally wish to add a microphone, you could simply solder it to the microphone leads and the signal will be transmitted.

Kalte Ecken im Koffer

2021-03-10T15:17:41Z

AKrause: /* What's in the suitcase? */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 mechanical keyswitches from [https://en.wikipedia.org/wiki/Cherry_(company) cherry keys]
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The briefcase was built to resemble a fictional device the Ministry of State Security (MfS) could have had in use. Therefore robust switches known for their military use were installed to enter the codes. The enclosed walkie-talkie is a modded version of an original model often used by the Stasi. Aiming to merge authenticity and fiction, the present-day tech, e.g. the touchscreen and Lattepanda, was covered with an outworn skin from an old Russian mobile television. Retrofitted cherry keys provide for a certain kind of old school feeling by their mechanical feedback and the specifically added yellowish lacquer.

All documents given in the briefcase are additionally weathered, e.g. using soy sauce, and drafted using an old typewriter. Pen and paper are original witnesses of the Soviet era. Seven several kinds of paper were used, resembling GDR documents, e.g. a train ticket was printed on a different kind of paper than a permit to enter West-Berlin. The former was additionally flexed and folded due to its imaginary use as a commodity item. Whereas the latter depicts a rare document of singular value.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

How to work with BCD(binary-coded decimal) switch?

2021-03-10T15:11:16Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

Shift-in registers are a common piece of electronics. They combine transistors so you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the Arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin four and pin six. So switch four and six are on and all others are off. Due to its mode of operation, it transforms the parallel incoming signals into a serial signal. The clue here is to use time as a reference to transform the eight parallel signals of the independent “ones” and “zeros” into a sequence of “ones” and “zeros”. This is a very basic principle of computing. But now you ask how the Arduino knows it gets eight bits (one byte) – and not just four or three. How does the Arduino know which bit is the first and the last one? The shift register has a so-called latch pin. If you activate the latch pin, the Arduino gives the signal to send data. So the shift register locks the state of the input pins and starts to send the bits. We are now sure to get the first bit by latching the register. To actually transmit the data, we need a clock pulse for each bit we want to get. Repeat this procedure eight times. Afterwards we repeat the whole cycle through the loop function in the Arduino sketch.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
The good thing about the shift registers is that you could chain them up, because the bit values, bit by bit, are going down the lane of the serial signal. In order to get two shift registers, we have to read out the data twice after latching the registers. This allows the concept of using just three pins on the Arduino to control many input pins. Like a button matrix
If you need a lot of output pins like an LED Cube or projects alike, you could use a shift-out register. It transforms the serial data into parallel data and switches the output pins according to the bit array it gets.

[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0; //the five BCD-switches
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);
}

void loop() {

digitalWrite(latchPin,1); //locking the data

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin); //get the data
switchVar2 = shiftIn(dataPin, clockPin);
switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask; //use mask
Digit2 = switchVar1>>4; //push four bits to the right
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){ //just print if the value changed
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}else {

pinState = 0;

}
digitalWrite(myClockPin, 1);
}
return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]
The good thing about the shift registers is that you could chain them up, because the bit values are going down the lane of the serial signal. In order to get two shift registers we have to read out the date twice after latching the registers. This is the concept of using just three pins on the arduino to control many input pins. If you have a lot of output pins like a LED cube or something like this you could use a shift-out register. It transforms the serial data into parallel data and switches the output pins according to the bit array it gets.

How to work with BCD(binary-coded decimal) switch?

2021-03-10T15:09:08Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

Shift-in registers are a common piece of electronics. They combine transistors so you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the Arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin four and pin six. So switch four and six are on and all others are off. Due to its mode of operation, it transforms the parallel incoming signals into a serial signal. The clue here is to use time as a reference to transform the eight parallel signals of the independent “ones” and “zeros” into a sequence of “ones” and “zeros”. This is a very basic principle of computing. But now you ask how the Arduino knows it gets eight bits (one byte) – and not just four or three. How does the Arduino know which bit is the first and the last one? The shift register has a so-called latch pin. If you activate the latch pin, the Arduino gives the signal to send data. So the shift register locks the state of the input pins and starts to send the bits. We are now sure to get the first bit by latching the register. To actually transmit the data, we need a clock pulse for each bit we want to get. Repeat this procedure eight times. Afterwards we repeat the whole cycle through the loop function in the Arduino sketch.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
One BCD Switch contains fourfour switches, so one shift register could match two switches. Luckily the BCD Switch transforms the numbers, as described earlier, in four binary bits. Therefore we could read our incoming byte with the help of a bit mask, which allows us to take the first four bits to get our first value. Then shift the byte four places to the right and take these to determine the second value.

[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0; //the five BCD-switches
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);
}

void loop() {

digitalWrite(latchPin,1); //locking the data

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin); //get the data
switchVar2 = shiftIn(dataPin, clockPin);
switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask; //use mask
Digit2 = switchVar1>>4; //push four bits to the right
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){ //just print if the value changed
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}else {

pinState = 0;

}
digitalWrite(myClockPin, 1);
}
return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]
The good thing about the shift registers is that you could chain them up, because the bit values are going down the lane of the serial signal. In order to get two shift registers we have to read out the date twice after latching the registers. This is the concept of using just three pins on the arduino to control many input pins. If you have a lot of output pins like a LED cube or something like this you could use a shift-out register. It transforms the serial data into parallel data and switches the output pins according to the bit array it gets.

How to work with BCD(binary-coded decimal) switch?

2021-03-10T15:06:35Z

AKrause: /* How does it work? */

[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

Shift-in registers are a common piece of electronics. They combine transistors so you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the Arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin four and pin six. So switch four and six are on and all others are off. Due to its mode of operation, it transforms the parallel incoming signals into a serial signal. The clue here is to use time as a reference to transform the eight parallel signals of the independent “ones” and “zeros” into a sequence of “ones” and “zeros”. This is a very basic principle of computing. But now you ask how the Arduino knows it gets eight bits (one byte) – and not just four or three. How does the Arduino know which bit is the first and the last one? The shift register has a so-called latch pin. If you activate the latch pin, the Arduino gives the signal to send data. So the shift register locks the state of the input pins and starts to send the bits. We are now sure to get the first bit by latching the register. To actually transmit the data, we need a clock pulse for each bit we want to get. Repeat this procedure eight times. Afterwards we repeat the whole cycle through the loop function in the Arduino sketch.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
One BCD switch contains 4 switches, so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits. So we could read our incoming byte and with the help of the bit mask just take the first four bits to get our first value and then shift the byte 4 places to the right and take these to determine the second value.

[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0; //the five BCD-switches
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);
}

void loop() {

digitalWrite(latchPin,1); //locking the data

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin); //get the data
switchVar2 = shiftIn(dataPin, clockPin);
switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask; //use mask
Digit2 = switchVar1>>4; //push four bits to the right
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){ //just print if the value changed
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}else {

pinState = 0;

}
digitalWrite(myClockPin, 1);
}
return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]
The good thing about the shift registers is that you could chain them up, because the bit values are going down the lane of the serial signal. In order to get two shift registers we have to read out the date twice after latching the registers. This is the concept of using just three pins on the arduino to control many input pins. If you have a lot of output pins like a LED cube or something like this you could use a shift-out register. It transforms the serial data into parallel data and switches the output pins according to the bit array it gets.

Kalte Ecken im Koffer

2021-03-10T15:00:51Z

AKrause: /* Thought about the haptics of the project */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 cherry keys
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The briefcase was built to resemble a fictional device the Ministry of State Security (MfS) could have had in use. Therefore robust switches known for their military use were installed to enter the codes. The enclosed walkie-talkie is a modded version of an original model often used by the Stasi. Aiming to merge authenticity and fiction, the present-day tech, e.g. the touchscreen and Lattepanda, was covered with an outworn skin from an old Russian mobile television. Retrofitted cherry keys provide for a certain kind of old school feeling by their mechanical feedback and the specifically added yellowish lacquer.

All documents given in the briefcase are additionally weathered, e.g. using soy sauce, and drafted using an old typewriter. Pen and paper are original witnesses of the Soviet era. Seven several kinds of paper were used, resembling GDR documents, e.g. a train ticket was printed on a different kind of paper than a permit to enter West-Berlin. The former was additionally flexed and folded due to its imaginary use as a commodity item. Whereas the latter depicts a rare document of singular value.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T15:00:16Z

AKrause: /* What's in the suitcase? */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 cherry keys
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an Arduino sketch running on the Lattepanda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The suitcase should resemble a fictional device the Ministry of State Security(MfS) could have had. Therefore, I actually built in switches used by the military to dial in the codes. The walkie-talkie I used is a modded version of an original one often used by the Stasi. The goal I aimed for was a mix between authenticity and fiction. So I covered the newer tech like the touchscreen and Lattepanda with an old cover from an old Russian mobile television. The keys are cherry keys that have a certain kind of old school feeling by their mechanical feedback and their yellowish lacquer. All the files are weathered too and the pen and paper are original witnesses of the Soviet era.
The object itself is the protagonist of the story and I tried to design it to trigger memories through details, textures and appearance in general. I often remember the situation in my childhood where I found specific objects of the GDR and showed them to my parents asking what is that, and they said: it's old GDR stuff. These objects are kind of charged with their long gone past.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T14:59:48Z

AKrause: /* What's in the suitcase? */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 cherry keys
* 1 single board computer (Lattepanda)
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an arduino sketch running on the panda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The suitcase should resemble a fictional device the Ministry of State Security(MfS) could have had. Therefore, I actually built in switches used by the military to dial in the codes. The walkie-talkie I used is a modded version of an original one often used by the Stasi. The goal I aimed for was a mix between authenticity and fiction. So I covered the newer tech like the touchscreen and Lattepanda with an old cover from an old Russian mobile television. The keys are cherry keys that have a certain kind of old school feeling by their mechanical feedback and their yellowish lacquer. All the files are weathered too and the pen and paper are original witnesses of the Soviet era.
The object itself is the protagonist of the story and I tried to design it to trigger memories through details, textures and appearance in general. I often remember the situation in my childhood where I found specific objects of the GDR and showed them to my parents asking what is that, and they said: it's old GDR stuff. These objects are kind of charged with their long gone past.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T14:58:43Z

AKrause: /* Project Description */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.

Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?

With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?

With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.

As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 cherry keys
* 1 Latte Panda
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an arduino sketch running on the panda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The suitcase should resemble a fictional device the Ministry of State Security(MfS) could have had. Therefore, I actually built in switches used by the military to dial in the codes. The walkie-talkie I used is a modded version of an original one often used by the Stasi. The goal I aimed for was a mix between authenticity and fiction. So I covered the newer tech like the touchscreen and Lattepanda with an old cover from an old Russian mobile television. The keys are cherry keys that have a certain kind of old school feeling by their mechanical feedback and their yellowish lacquer. All the files are weathered too and the pen and paper are original witnesses of the Soviet era.
The object itself is the protagonist of the story and I tried to design it to trigger memories through details, textures and appearance in general. I often remember the situation in my childhood where I found specific objects of the GDR and showed them to my parents asking what is that, and they said: it's old GDR stuff. These objects are kind of charged with their long gone past.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-10T14:58:26Z

AKrause: /* Project Description */

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, the participant plays a virtual audio walk through the streets of Berlin, that takes place during GDR times. It can be played anywhere, since all the equipment one needs is to be found in the prepared briefcase, which displays – amongst other things – a digital map on a screen. Like a time capsule, the briefcase invites to immerse oneself in the story of M.W., an informat of the Stasi, who gathered information on three suspects in former East-Berlin, some decades ago.
Following the voice of M.W., the person playing the briefcase steers the onscreen cursor to receive information via sound snippets and thus sets the order in which those are discovered.
Each snippet poses a question. How is the participant going to proceed? Telling the truth or lying? Being a spy or rather being spied on? Which storyline will be followed? Focusing on M.W.’s own fateful actions or rather zooming in on the assumed dissident S.R. (codename “Reader”)?
With all the information one receives over time, the question continuously arises: How credible is the gathered intel? Or is it just imaginary stories that “Reader” writes? Looking at the documents through M.W.’s eyes, are the observations manipulated by the Stasi? May “Reader” himself even be an informant to the secret police, spying on M.W.?
With its wethered haptics and interior decoration, the briefcase seems to derive from a parallel universe in which the Stasi possesses today’s technology.
As part of the game “Kalte Ecken im Koffer”, the briefcase is given to the participant in a secret meeting that appears to be a hand-off by an “agent”. Afterwards, the participant has to bring the briefcase back in order to complete the mission successfully.

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 cherry keys
* 1 Latte Panda
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an arduino sketch running on the panda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The suitcase should resemble a fictional device the Ministry of State Security(MfS) could have had. Therefore, I actually built in switches used by the military to dial in the codes. The walkie-talkie I used is a modded version of an original one often used by the Stasi. The goal I aimed for was a mix between authenticity and fiction. So I covered the newer tech like the touchscreen and Lattepanda with an old cover from an old Russian mobile television. The keys are cherry keys that have a certain kind of old school feeling by their mechanical feedback and their yellowish lacquer. All the files are weathered too and the pen and paper are original witnesses of the Soviet era.
The object itself is the protagonist of the story and I tried to design it to trigger memories through details, textures and appearance in general. I often remember the situation in my childhood where I found specific objects of the GDR and showed them to my parents asking what is that, and they said: it's old GDR stuff. These objects are kind of charged with their long gone past.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-08T20:16:19Z

AKrause: Änderung 1627 von AKrause (Diskussion) rückgängig gemacht.

[[Datei:Kalte_Ecken_tutti.gif|200px|thumb|right|Foto by Laura Alapfy]]

== Project Description ==
Within 45 to 60 minutes, a participant plays through a virtual audio walk through Berlin in a suitcase. They take on the role of M.W. and have to decide whether they want to denounce readers in order to get ahead themselves or stall their superiors in order to get more inspiration from the readings. The participants receive information through sound snippets that they have to collect. The suitcase seems to come from a parallel universe in which the Stasi has the technology of today. The participants receive the suitcase via a classic agent handover and then have to bring it back after completing the mission in order to complete the mission successfully. With all the information one receives over time, the question always arises: How credible is the information? Is it just stories that Reader writes? Are the observations that one makes as M.W. manipulated by the Stasi? Is Reader himself an IM?

== What's in the suitcase? ==
[[Datei:Kalte_Ecken_Funke.jpg|200px|thumb|right|Foto by Laura Alapfy]]
'''Hardware'''
* five BCD switches
* three CD4021B shift-in register
* 7” Monitor from waveshare
* 4 cherry keys
* 1 Latte Panda
* anker power bank 26500 mAh
* an old hacked GDR Walkie-Talkie
* files, a city map of Berlin, a pen, some blank paper for notes

'''Software'''
* Unity based self made windows app for x86_64 environment
* an arduino sketch running on the panda to send the input via serial to the Unity app

== Thought about the haptics of the project ==
The suitcase should resemble a fictional device the Ministry of State Security(MfS) could have had. Therefore, I actually built in switches used by the military to dial in the codes. The walkie-talkie I used is a modded version of an original one often used by the Stasi. The goal I aimed for was a mix between authenticity and fiction. So I covered the newer tech like the touchscreen and Lattepanda with an old cover from an old Russian mobile television. The keys are cherry keys that have a certain kind of old school feeling by their mechanical feedback and their yellowish lacquer. All the files are weathered too and the pen and paper are original witnesses of the Soviet era.
The object itself is the protagonist of the story and I tried to design it to trigger memories through details, textures and appearance in general. I often remember the situation in my childhood where I found specific objects of the GDR and showed them to my parents asking what is that, and they said: it's old GDR stuff. These objects are kind of charged with their long gone past.

== Tutorials ==

[[How to work with BCD(binary-coded decimal) switch?]]

[[How to connect old tech with speakers to bluetooth?]]

Kalte Ecken im Koffer

2021-03-08T20:15:15Z

AKrause:

How to connect old tech with speakers to bluetooth?

2021-03-08T20:14:44Z

AKrause: /* How does it work? */

[[Datei:Kalte_Ecken_Funke2.jpg|200px|thumb|right|Foto by Laura Alapfy]]
The technique is called case modding. So you took a device and built it into a cool case.
== What do you need? ==
* soldering iron and stuff to solder

* pliers and screwdrivers

* a bluetooth board (I ordered this [https://www.ebay.de/itm/BT201-MP3-Player-Decoder-Bluetooth-5-0-Modul-TF-Card-Reader-UDisk-USB-3-3-5V-/284105739580?var=&hash=item4226058d3c, one])

* a battery according to your needs (for me this [https://www.ebay.de/itm/2-x-LG-INR-18650HG2-Li-Ion-Akku-3-6V-3-7V-3000mAh-20A-einzeln-Trimax/293447981910?epid=18031293334&hash=item4452dcdb56:g:a5gAAOSwA75eMCR0 ,one] worked)

* A [https://www.ebay.de/itm/Ladegerat-Ladestation-universal-Charger-18650-14500-Akku-Batterie-3-7V-AA-AAA/112109635119?hash=item1a1a41462f:g:S90AAOSwtZJY~3L1, charger] for your batteries

== How does it work? ==
First you disassemble your old piece of tech and find the speaker. You need to disconnect the two wires that are coming from your speaker and solder them to your board to the speaker input solder pads.

Second try to find a good space for your battery. I was lucky and could reuse the old battery compartment.

Test it. Try to connect to your phone or computer via Bluetooth and play a song. The board I used has a SD card slot for mp3 and a microphone for Bluetooth headset mode. If you have a microphone you could just solder it to the microphone leads and the signal will be transmitted.

Kalte Ecken im Koffer

2021-03-08T20:13:38Z

AKrause: /* Thought about the haptics of the project */

How to work with BCD(binary-coded decimal) switch?

2021-03-08T20:02:10Z

AKrause:

[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuits at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero, because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. The rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted. Therefore, the fourth switch determines the least significant bit. I will now give you a table, so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
One BCD switch contains 4 switches, so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits. So we could read our incoming byte and with the help of the bit mask just take the first four bits to get our first value and then shift the byte 4 places to the right and take these to determine the second value.

[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0; //the five BCD-switches
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);
}

void loop() {

digitalWrite(latchPin,1); //locking the data

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin); //get the data
switchVar2 = shiftIn(dataPin, clockPin);
switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask; //use mask
Digit2 = switchVar1>>4; //push four bits to the right
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){ //just print if the value changed
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}else {

pinState = 0;

}
digitalWrite(myClockPin, 1);
}
return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]
The good thing about the shift registers is that you could chain them up, because the bit values are going down the lane of the serial signal. In order to get two shift registers we have to read out the date twice after latching the registers. This is the concept of using just three pins on the arduino to control many input pins. If you have a lot of output pins like a LED cube or something like this you could use a shift-out register. It transforms the serial data into parallel data and switches the output pins according to the bit array it gets.

How to work with BCD(binary-coded decimal) switch?

2021-03-08T19:57:23Z

AKrause: /* How to connect multiple BCD switches? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
One BCD switch contains 4 switches, so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits. So we could read our incoming byte and with the help of the bit mask just take the first four bits to get our first value and then shift the byte 4 places to the right and take these to determine the second value.

[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0; //the five BCD-switches
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);
}

void loop() {

digitalWrite(latchPin,1); //locking the data

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin); //get the data
switchVar2 = shiftIn(dataPin, clockPin);
switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask; //use mask
Digit2 = switchVar1>>4; //push four bits to the right
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){ //just print if the value changed
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}else {

pinState = 0;

}
digitalWrite(myClockPin, 1);
}
return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]
The good thing about the shift registers is that you could chain them up, because the bit values are going down the lane of the serial signal. In order to get two shift registers we have to read out the date twice after latching the registers. This is the concept of using just three pins on the arduino to control many input pins. If you have a lot of output pins like a LED cube or something like this you could use a shift-out register. It transforms the serial data into parallel data and switches the output pins according to the bit array it gets.

How to work with BCD(binary-coded decimal) switch?

2021-03-08T19:56:19Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

How to work with BCD(binary-coded decimal) switch?

2021-03-08T19:52:06Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
One BCD switch contains 4 switches, so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits. So we could read our incoming byte and with the help of the bit mask just take the first four bits to get our first value and then shift the byte 4 places to the right and take these to determine the second value.

[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);
}

void loop() {

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);
switchVar2 = shiftIn(dataPin, clockPin);
switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}else {

pinState = 0;

}
digitalWrite(myClockPin, 1);
}
return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-08T19:48:19Z

AKrause: /* How to connect a shift register with an Arduino? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte.

If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal.

The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data.
So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-08T19:47:41Z

AKrause: /* How to connect a shift register with an Arduino? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift-In registers are a common piece of electronics. They combine transistors in that way that you could survey eight input pins in that way that one shift register sends a so-called bit array of eight bits called a byte. If the arduino receives a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. It could do it like this because it transforms the parallel incoming signals into a serial signal. The clue here is to use time as a reference to transform the 8 parallel signals of the independent ones and zeros into a sequence of ones and zeros. This is a very basic principle of computing. But now you ask how the arduino knows it gets 8 bits(1 byte) and not just four or three. How does the arduino know which bit is the first and the last one. Therefore, the shift register has a so-called latch pin. If you activate the latch the arduino says: please send me data. So the shift register locks the state of the input pins and starts to send the bits. We are now sure we get the first bit by latching the register, now to actually transmit the data we need a clock pulse for each bit we want to get. So we do that eight times. And after that we repeat the cycle through the loop function in our arduino sketch.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:07:29Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|right|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:06:56Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:06:38Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:05:10Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:04:05Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:03:39Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:02:50Z

AKrause:

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T22:01:36Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:58:24Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:57:38Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

--entry is still in work--
[[Datei:Kalte_Ecken_BCD.gif|200px|thumb|right|Foto by Laura Alapfy]]
== How does it work? ==

A BCD-Switch is actually not one switch, it contains basically four switching circuit at once. There is a wheel which closes depending on the number the switch shows in the front. The picture on the right are 5 BCD switches stacked sideways together. The four switches translating the number into its binary form. So if you see a 5 in the front the second and the fourth switch are on and resembling the one the others are off and resembling the zero. Because 5 in binary is 0101. The tricky part is that you read binary from left to right in computing because you have the most significant bit always on the left side. So the rightest bit stands for 2 to the power of zero which is 1 if it is 1 if it is zero its value will not be counted so it is zero. So the fourth switch determines the least significant bit. So I will now give you a table so you don't have to remember and calculate.

{| class="wikitable"
!colspan="6"|BCD Switch
|-
|Number in Front
|BitArray
|Switch 1
|Switch 2
|Switch 3
|Switch 4
|-
|1
|0001
|off
|off
|off
|on
|-
|2
|0010
|off
|off
|on
|off
|-
|3
|0011
|off
|off
|on
|on
|-
|4
|0100
|off
|on
|off
|off
|-
|5
|0101
|off
|on
|off
|on
|-
|6
|0110
|off
|on
|on
|off
|-
|7
|0111
|off
|on
|on
|on
|-
|8
|1000
|on
|off
|off
|off
|-
|9
|1001
|on
|off
|off
|on
|-
|0
|0000
|off
|off
|off
|off
|}

== What will you need? ==
*an Arduino (every typ will do)
*a BCD-Switch
*a shift register (CD4021)
*jumperwires
*a breadboard

== How to connect a shift register with an Arduino? ==
Shift registers are a common piece of electronic and it combines transistors in that way that you could survey eight input pins in that way that one shift register sends a so called bit array of eight bits called a byte. So if you receive a bit array looking like this [0,0,1,0,1,0,0,0] it means you have an input voltage on pin 4 and pin 6. So switch 4 and 6 are on and all others are off. One BCD switch contains 4 switches so one shift register could match two switches. Luckily the BCD switch transforms the numbers as described earlier in four binary bits.

== How to read the BCD switch with an Arduino and a shift register? ==
[[Datei:BCD_One_Switch.png|200px|thumb|left|one row of switches resambles one BCD Switch]]

const int buttonUpPin = 8;
const int buttonRightPin = 11;
const int buttonDownPin = 10;
const int buttonLeftPin = 9;

int buttonUpState = 0;
int buttonRightState = 0;
int buttonDownState = 0;
int buttonLeftState = 0;

int latchPin = 5;
int dataPin = 4;
int clockPin = 6;

byte switchVar1 = 72; //01001000
byte switchVar2 = 159; //10011111
byte switchVar3 = 201; //10011111

byte mask = 15; //00001111

byte Digit1 = 0;
byte Digit2 = 0;
byte Digit3 = 0;
byte Digit4 = 0;
byte Digit5 = 0;

byte oldValue = 6;

void setup() {
Serial.begin(9600);

pinMode(buttonUpPin, INPUT_PULLUP);
pinMode(buttonRightPin, INPUT_PULLUP);
pinMode(buttonDownPin, INPUT_PULLUP);
pinMode(buttonLeftPin, INPUT_PULLUP);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);

pinMode(dataPin, INPUT);
}

void loop() {

buttonUpState = digitalRead(buttonUpPin);
buttonRightState = digitalRead(buttonRightPin);
buttonDownState = digitalRead(buttonDownPin);
buttonLeftState = digitalRead(buttonLeftPin);

if (buttonUpState == LOW) {
Serial.println("UP");
delay(100);
}

if (buttonRightState == LOW) {
Serial.println("RIGHT");
delay(100);
}

if (buttonDownState == LOW) {
Serial.println("DOWN");
delay(100);
}

if (buttonLeftState == LOW) {
Serial.println("LEFT");
delay(100);
}
if (buttonLeftState == LOW && buttonRightState == LOW) {
Serial.println("START");
delay(100);
}

digitalWrite(latchPin,1);

delayMicroseconds(20);

digitalWrite(latchPin,0);

switchVar1 = shiftIn(dataPin, clockPin);

switchVar2 = shiftIn(dataPin, clockPin);

switchVar3 = shiftIn(dataPin, clockPin);

Digit1 = switchVar1 & mask;
Digit2 = switchVar1>>4;
Digit3 = switchVar2 & mask;
Digit4 = switchVar2>>4;
Digit5 = switchVar3 & mask;

if(oldValue != Digit1 + Digit2 + Digit3 + Digit4 + Digit5){
Serial.print(Digit5, DEC);
Serial.print(Digit4, DEC);
Serial.print(Digit3, DEC);
Serial.print(Digit2, DEC);
Serial.println(Digit1, DEC);
oldValue = Digit1 + Digit2 + Digit3 + Digit4 + Digit5;
}

delay(100);

}

byte shiftIn(int myDataPin, int myClockPin) {

int i;

int temp = 0;

int pinState;

byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);

pinMode(myDataPin, INPUT);

for (i = 7; i >= 0; i--)

{

digitalWrite(myClockPin, 0);

delayMicroseconds(2);

temp = digitalRead(myDataPin);

if (temp) {

pinState = 1;

myDataIn = myDataIn | (1 << i);

}

else {

pinState = 0;

}

digitalWrite(myClockPin, 1);

}

return myDataIn;
}

== How to connect multiple BCD switches? ==
[[Datei:BCD_2_switches.png|200px|thumb|left|two switches]]
[[Datei:BCD_4_switches.png|200px|thumb|right|four switches with two registers]]

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:45:08Z

AKrause: /* How to read the BCD switch with an Arduino and a shift register? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:43:55Z

AKrause: /* How to connect a shift register with an Arduino? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:43:24Z

AKrause:

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:42:47Z

AKrause: /* How to connect multiple BCD switches? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T21:42:03Z

AKrause: /* How to connect multiple BCD switches? */

Datei:BCD 4 switches.png

2021-03-06T21:40:23Z

AKrause:

Datei:BCD 2 switches.png

2021-03-06T21:39:47Z

AKrause:

Datei:BCD One Switch.png

2021-03-06T21:39:33Z

AKrause:

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:34:56Z

AKrause: /* How to connect a shift register with an Arduino? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:34:30Z

AKrause: /* How to connect a shift register with an Arduino? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:33:41Z

AKrause: /* How does it work? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:33:06Z

AKrause: /* How does it work? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:32:28Z

AKrause: /* How does it work? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:31:45Z

AKrause: /* How does it work? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:31:19Z

AKrause: /* How does it work? */

How to work with BCD(binary-coded decimal) switch?

2021-03-06T20:30:56Z

AKrause: /* How does it work? */