YRabbit's notes

Programmer's Calculator

2025-10-19T16:07:00+10:00

Finished look

Programmer's Calculator

2025-10-19T16:07:00+10:00

Finished look

Programmer's calculator (buzzer)

2025-05-01T21:46:00+10:00

A new peripheral for the calculator - a passive buzzer.

Calculation

Buzzer connection diagram

A passive buzzer with a coil resistance of 16 from an Arduino kit is used. Here’s how it looks with a soldered diode. The diode is necessary because this is an electromagnetic buzzer, not a piezo one - though even piezo buzzers might need one since they generate electricity when deformed (think of piezo lighters).

Close-up of the buzzer with a soldered diode

Let’s take a look at the buzzer’s specifications from TZT:

First part of the buzzer description

Buzzer parameter table

Determining the value of . The allowable current is , Assuming the average voltage across the buzzer coil is zero, we get

Let’s check the parameters of the 2N3904 transistor:

2N3904 transistor parameters

Assuming , we calculate:

Since the collector current is already limited, it’s fine even if we take the minimum . Thus, the base current .

From this, we derive:

As for , it's pull-down resistor with a sufficiently high value. Alternatively, such a resistor could simply be enabled on the CH32V003 pin.

Programmer's calculator

2023-04-15T15:15:00+10:00

This is a very simple thing - a desktop calculator for operations in different number systems.

It is imagined as having a few lines of display, a lithium battery, and a keyboard with a small number of keys.

Keyboard

I will use Rue Mohr's scanless keyboard design http://ruemohr.org/~ircjunk/tutorials/elex/scanlessKeyboard/scanlessKeyboard.html .

Here is draft of the schematics:

The calculator keyboard diagram

I use the highlighted fragment to determine the resistor ratings.

Fragment of the keypad circuit.

Let me speculate: the CE current of transistor Q1 is determined by the resistance of the 45k pull-down resistor of the controller pin (not shown in the schematic):

Based on the datasheet chart, I determine that to go into saturation mode, it is enough to provide 0.6V voltage at the base. The same applies to transistor Q2.

Graph from the 2n2222 datasheet

Graph from the 2n2907 datasheet

Hence the voltage drop across resistor R1:

As can be seen from the same graphs, the base-emitter saturation current is 10 times less than the :

I choose the resistor R2 arbitrarily 10k - anyway the voltage drop on it equals .

You cannot move higher because of the danger of getting too little current, on the other hand a high current will have no effect. So I choose the value of 20k.

The current through resistor R1 is actually the same as predicted

current

Rue Mohr's <https://twitter.com/RueNahcMohr> told me to change the circuit so as to get a "keystroke detection circuit":

Modification of the keyboard circuit

Programmer's calculator

2023-04-15T15:15:00+10:00

This is a very simple thing - a desktop calculator for operations in different number systems.

It is imagined as having a few lines of display, a lithium battery, and a keyboard with a small number of keys.

Keyboard

I will use Rue Mohr's scanless keyboard design http://ruemohr.org/~ircjunk/tutorials/elex/scanlessKeyboard/scanlessKeyboard.html .

Here is draft of the schematics:

The calculator keyboard diagram

I use the highlighted fragment to determine the resistor ratings.

Fragment of the keypad circuit.

Let me speculate: the CE current of transistor Q1 is determined by the resistance of the 45k pull-down resistor of the controller pin (not shown in the schematic):

Based on the datasheet chart, I determine that to go into saturation mode, it is enough to provide 0.6V voltage at the base. The same applies to transistor Q2.

Graph from the 2n2222 datasheet

Graph from the 2n2907 datasheet

Hence the voltage drop across resistor R1:

As can be seen from the same graphs, the base-emitter saturation current is 10 times less than the :

I choose the resistor R2 arbitrarily 10k - anyway the voltage drop on it equals .

You cannot move higher because of the danger of getting too little current, on the other hand a high current will have no effect. So I choose the value of 20k.

The current through resistor R1 is actually the same as predicted

current

Rue Mohr's <https://twitter.com/RueNahcMohr> told me to change the circuit so as to get a "keystroke detection circuit":

Modification of the keyboard circuit

Making an antenna for a 4G modem

2020-07-29T12:55:00+10:00

After calculation, I proceed to the manufacture of antenna parts. Special care is needed when bending the antenna wire itself and making the balun.

Bending the wire

I never doubted for a second that I couldn't just take and bend the wire in compliance with all radii and distances, so on my CNC3018 I made a template where the finished antenna wire should go without effort:

Antenna template

Practice has shown that this thing is useful for the final alignment of the antenna, but it does little to help bend it. It made sense to make one separate corner to bend the wire only on it, but now this is no longer relevant to me :)

I'll see how long the copper wire I need:

octave:2> quad_size*8
ans =  224.38

I'll mark this distance in a notepad and put a simple 22AWG into the template:

22AWG in antenna template

The mark must match the drawing in the notebook:

Notepad segment

22AWG next to segment in notebook

Bend the copper wire carefully:

Bending copper wire

Almost finished antenna

I solder the antenna straight away.

Antenna solder

Balun

The RG174 cable will be connected directly to the antenna (the diameter of the first shield is 1.98mm, the diameter of the jacket is 2.79mm). I considered using a bazooka balun, but two considerations made me abandon this idea:

I do not have a tube with a diameter of mm, namely with this ratio of diameters this type of balun becomes effective;
the bazooka balun is connected around the circumference of the coaxial cable screen at a certain distance ( or less if the balun is folded) from the vibrator, I very much doubt that I can do this accurately and evenly around the entire circumference of such a small wire. I have seen and read about options when the balun is connected directly to the vibrator, but I think that with such a connection the balun turns into an additional vibrator, and I really do not want to repeat the calculation of the antenna taking into account this vibrator surface.

So I decided to implement a less efficient, but easier to manufacture balun from a piece of wire.

In addition to careful manipulation of the outer sheath of the coaxial cable, it is advisable not to overheat the shield: the internal dielectric may melt and the characteristics of the cable may deteriorate.

Remove only minimum isolation from the end

Isolation removed

Finished balun

Reflector

Now I can move on to other structural details. This is what the antenna looks like in FreeCAD:

Video

The two vibrators are positioned at an angle of to each other and at to the horizon.

The antenna was conceived as hanged from the ceiling on a wire loop - two triangular combs at the top of the reflector allow you to choose the antenna angle in the horizontal plane. The modem cradle has a cutout for the USB cable and there are also two hooks to gently secure the top of the modem.

Few details should be placed on the face of the reflector to minimize disturbance to the reflective surface, which, by the way, is an ordinary foil for baking all sorts of delicious things.

The most important part of the reflector is the vibrator posts. They perform an important function of maintaining the calculated shape of the vibrators and the distance between the vibrators and the reflective surface of the reflector.

Now I will say about the material of the posts. While all other parts of the antenna can be made from almost anything, the vibrator posts must be radio transparent at the antenna frequency. My frequency is close to the radiation inside the microwave, so heating a piece of plastic for a couple of minutes showed its suitability (there is no charring and other unpleasant manifestations of interaction with radiation). It is believed that at the points of zero potential, you can use any material for the posts, up to metal, sometimes the posts are even soldered to the reflector. I don't do this for the following reasons:

I doubt that I will ideally make vibrators, so the point of zero potential will not be such;
I calculated the antenna based on the air insulation between the vibrators and the reflector. If you use metal posts, then you need to calculate and simulate with these additional vibrators.

I don't have a 3D printer, so making posts is a fun task. I had to make an auxiliary clamp to accurately cut the grooves on the ends of the posts:smile: Here's the first clamp, unsuccessful:

Bad version of the auxiliary clamp

Second clamp with reinforced rigidity:

Second clamp

The reflector is much larger than my CNC3018, but this can be solved:

Large reflector sheet on CNC

Soldering cables and baluns to vibrators, the last step before exciting antenna testing:

Soldering cables to vibrators

Testing

Rear view will not receive design awards :)

Build and function test

Huawei modems have a convenient mechanism for assessing signal quality on the page at http://192.168.8.1/html/antennapointing.html

So just a modem without an antenna:

Signal parameters without antenna

Modem with antenna:

Signal parameters with antenna connected

Excellent! The receiving conditions changed and went into a completely green area. LTE Signal Parameters Reference.

Antenna for 4G Modem

2020-06-29T13:02:00+10:00

Current reading: SINR/RSRP: 20 dB / -95 dBm. Do I need an antenna? Not sure. Would it be fun to make an antenna? Certainly! So let's get started:)

Simulation accuracy

First, I want to make sure that openEMS (the modeling system I plan to use) is calculating correctly. Let's take the antenna impedance data from the book 1.

Impedance versus antenna perimeter

I am interested in the graph on the right, namely the fact that with the perimeter of one square equal to , the reactance .

Let's draw only the top square of the antenna, the feed gap is on the left:

Top half of the antenna

The antenna is a square wire with a side of , effective radius, the length of the full side of the square is , the feed gap is equal to . Thus, the perimeter of the antenna is .

After simulation EndCriteria = 1.e-6, OverSampling = 10 I get the resonant frequency :

directivity: Dmax = 3.0867 dBi
Minimum SWR frequency:
 2840000000
Resonant frequency (jX=0):
 2865000000
Impedance at minimum SWR:
 129.502 -  13.569i
Impedance at resonant frequency:
 133.07147 -   0.41565i
Minimum SWR:
 2.6234

From the frequency I find the wavelength: and the theoretical perimeter: .

Hence the discrepancy between theory and simulation: . The source code of the simulation can be downloaded here.

Given the artisanal nature of production, this accuracy suits me:)

Antenna geometry

In theory, an antenna is two squares connected by "vertices", where the connection point is the feed point of the antenna. But I will be dealing with a real copper wire (there is a height and thickness), which bends with a certain radius, as well as with a real soldering iron, so that the geometric model will look like this:

Graphic model of Kharchenko antenna

The dotted lines are auxiliary geometry, the red curve is the center of the wire from which the antenna is made, the radii of all arcs are equal to (here means the center).

At this point, I will need the characteristics of my copper wire. It just so happened that I had a lot of rectangular copper wire at hand, so I will be guided by this type of wire.

My copper wire

The rectangular cross-section of the wire is described by the width and the height , , hence it is clear how the wire will bend --- I can ignore in the geometric model, but will play an important role in describing the feed gap.

Feedpoint model

Here is the radius of the inner surface of the wire, is the radius of the outer surface of the wire. As you know, the angle between the radius of the circle and the tangent to the circle at this point is equal to , all angles in the models are equal to or .

I took the gap between the wires for powering equal to 1mm, from here:

Because of the need to have the feed gap, I slightly moved the "squares" apart, the measure of the "extension" is 2:

All arcs have length . The choice of a name for the variable is not really appropriate, but as it is :) Let's compose a system of equations describing the relationship between the elements of the structure:

The first equation of the system reflects the fact that the perimeter of one "square" should be related to the "quarters" of the wavelength. The second equation introduces the relationship between the lengths of the sides of the "square", it is not as obvious as the first equation, but it is derived quite simply.

I solve the system in Maxima:

(%i1) eq0:2*delta_port + quad_small + quad_big = 2*quad_size;
(%o1)         quad_small + quad_big + 2 delta_port = 2 quad_size
(%i2) eq1:quad_small = quad_big - dR*sqrt(2);
(%o2)                 quad_small = quad_big - sqrt(2) dR
(%i3) solve([eq0, eq1], [quad_small, quad_big]);
                     2 quad_size - 2 delta_port - sqrt(2) dR
(%o3) [[quad_small = ---------------------------------------,
                                        2
                         2 quad_size - 2 delta_port + sqrt(2) dR
              quad_big = ---------------------------------------]]
                                            2

The and unambiguously set the antenna model (as a function of wire parameters, radius of curvature and wavelength), now I can proceed to simulation.

Simulation

After I got my hands on modeling simple dipole antennas and a simple loop antennas, creating a model for Kharchenko's antenna was not too difficult (full text of the model). The mathematical model was described above, I chose the parameters based on common sense and materials available:

, - my wire,
Ohm - coaxial wire resistance,
- I think this is a more or less normal rounding radius,
- must be at least wavelength.

But the size of the side of the "square" I selected by running the simulation and achieving the minimum at my frequency of 2.6 GHz. And after that, I selected the distance from the middle of the wire to the reflector , achieving a resistance of 50Ohm (, ).

To reduce the calculation time while maintaining accuracy, I took advantage of the ability to specify an uneven mesh:

Mesh for antenna calculation

I tried to do so that as many surfaces as possible coincided with the grid lines: these are the wire planes along the axis, the reflector plane and the antenna feed gap.

Here are some more snapshots of the mesh and model:

General view of the model

Antenna close-up

Feed line

1.: ^ Antenna Theory and Design. Warren L. Stutzman, Gary A. Thiele
2.: ^ These appear due to the aspect ratio in a right triangle with angles of : and

The actual simulation results:

Input impedance of Zin_real antenna

Input impedance of Zin_imag antenna

S11

Antenna directivity simulation video

directivity: Dmax = 10.6344 dBi I will count on this result.

FPGA and a rotary encoder

2020-03-22T12:17:00+10:00

How to program an FPGA to work with such simple input / output devices as a rotation angle sensor and LED indicator.

When I studied FPGA in the begining, I really wanted to have some kind of visible response to my program. The built-in RGB LED became old quickly, in particular due to my poor sense of color :wink:, so the 17-segment indicator was the first external device.

Indicator

I found an indicator with a common cathode, 17 resistors of 100 Ohms each based on the fact that on the green LED segment the voltage drops is about 2.4 Volts, the FPGA output has 3.3 Volts, so the current is .

So even all segments lighted will not lead to overcurrent.

Here is a simple indicator module. A1, A2, ... - symbolic names of indicator segments according to the documentation.

/*****************/
/* 0-15 on 17led */
/*****************/
module Display16(
    input wire [3:0] i_x,
    output reg [16:0] o_led);

    localparam A1 =  1 << 4;
    localparam A2 =  1 << 5;
    localparam B  =  1 << 6;
    localparam C  =  1 << 7;
    localparam D1 =  1 << 1;
    localparam D2 =  1 << 0;
    localparam E  =  1 << 2;
    localparam F  =  1 << 3;
    localparam G1 =  1 << 11;
    localparam G2 =  1 << 15;
    localparam H  =  1 << 12;
    localparam J  =  1 << 13;
    localparam K  =  1 << 14;
    localparam L  =  1 <<  8;
    localparam M  =  1 <<  9;
    localparam N  =  1 << 10;
    localparam DP =  1 << 16;


    always @(i_x) begin
      case (i_x)
        4'h0 : o_led = A1 + A2 + B + C + D2 + D1 + E + F; // 0
        4'h1 : o_led = K + B + C; // 1
        4'h2 : o_led = A1 + A2 + B + G2 + N + D1 + D2; // 2
        4'h3 : o_led = A1 + A2 + B + G2 + C + D2 + D1; // 3
        4'h4 : o_led = F + G1 + G2 + B + C; // 4
        4'h5 : o_led = A1 + A2 + F + G1 + G2 + C + D1 + D2; // 5
        4'h6 : o_led = A1 + A2 + F + G1 + G2 + C + D2 + D1 + E; // 6
        4'h7 : o_led = A1 + A2 + K + M; // 7
        4'h8 : o_led = A1 + A2 + B + C + D2 + D1 + E + F + G1 + G2; // 8
        4'h9 : o_led = A1 + A2 + B + C + D2 + D1 + F + G1 + G2; // 9
        4'ha : o_led = A1 + A2 + B + C + E + F + G1 + G2; // A
        4'hb : o_led = A1 + J + G2 + C + D2 + D1 + E + F + G1; // B
        4'hc : o_led = D2 + D1 + E + F + A1 + A2; // C
        4'hd : o_led = A1 + A2 + B + C + D2 + D1 + M + J; // D
        4'he : o_led = A1 + A2 + G1 + D2 + D1 + E + F; // E
        4'hf : o_led = E + F + A1 + A2 + G1; // F
      endcase
    end

endmodule
// vim: expandtab:sw=4:ts=4:

Combinatorial circuit and non-clocked output register. This was my very first module on Verilog:)

This is what it turns into after compilation:

13 LUT4 of 1152 were spent.

Contact bounce

My rotary encoder has a very noisy electrical design:

The rotary encoder inside

First, we eliminate the metastability at the inputs, two flipflops are enough.

`default_nettype none
 module metastab(
     input wire i_clk,
     input wire i_in,
     output wire o_out);

     reg r_stage0;
     reg r_stage1;

     always @(posedge i_clk) begin
         {r_stage1, r_stage0} = {r_stage0, i_in};
     end

     assign o_out = r_stage1;
 endmodule
 // vim: expandtab:sw=4 ts=4

And the code really turns into two flip flops:)

Implementing anti-metastability

We got rid of metastability, but this only guarantees us that the signal will be stable during the clock pulse and does not relieve spurious responses of the contacts.

The contact bouncing on oscilloscope

One of the options for suppressing contact bounce is to use an RC filter in combination with a Schmitt trigger:

RC filter and Schmitt trigger

A low-pass filter smooths out high-frequency noise, and Schmitt's trigger is needed in order to correctly process the input signal in the range from 0.8 to 2 Volts. However, as noted by Rue:

Rue's post

He also suggested using a software implementation of the RC filter and Schmitt trigger:

Rue's method

Almost all of this migrated to code I eventually used. Some notes:

I did not change the integration frequency, but used the standard 24 MHz;
the integration period was chosen to be 5ms since I achieved values close to this by very quickly rotating the handle of the sensor observing the signal on the oscilloscope screen;
I did not see the point of counting to 254 and to 1 (if (v1 < 254) v1++) and then compare with 250 and 5;
due to the desire to save LUTs, I rather roughly adjusted all constants to powers of two;
since I have LUT4, then w_isLow, for example, will consist of two cascaded LUT4s, the output of the first of which will be one of the inputs of the second, therefore only 7 input bits can be used. This explains the constant 7 in localparam IGNORE_BITS

`default_nettype none
 module Debounce5ms(
         input wire i_clk,
         input wire i_btn,
         output wire o_btn);
     /* 24MHz ~ 42e-9s, for 5ms we need *1e5 ~ 2^16
      * for Schmitt part we can ignore lower ~2^9 */
     localparam TOTAL_BITS = 16;
     localparam HI_BIT = TOTAL_BITS - 1;
     localparam IGNORE_BITS = TOTAL_BITS - 7;

     // test bounds
     reg [HI_BIT:0]r_counter;
     wire w_isLow;
     wire w_isHigh;
     assign w_isLow = !(|r_counter[HI_BIT:IGNORE_BITS]);
     assign w_isHigh = &r_counter[HI_BIT:IGNORE_BITS];

     // Capacitor
     always @(posedge i_clk) begin
         if (i_btn) begin
             if (!w_isHigh) begin
                 r_counter <= r_counter + 1'b1;
             end
         end else begin
             if (!w_isLow) begin
                 r_counter <= r_counter - 1'b1;
             end
         end
     end

     // Schmitt
     reg r_debouncedBtn;
     always @(posedge i_clk) begin
         if (w_isLow) begin
             r_debouncedBtn <= 0;
         end
         if (w_isHigh) begin
             r_debouncedBtn <= 1;
         end
     end
     assign o_btn = r_debouncedBtn;
 endmodule
 // vim: expandtab:ts=4 sw=4

You can make sure that the generated elements are connected in exactly this way:

LUT4 form the 7 input element

By this moment, we have reached the stage when the complexity of the generated circuit has grown so much that it makes no sense to show it here.

Decimal counter

This is a very simple module, for some reason I even provided the carry, although for this system with just one indicator, this is not necessary. In addition, the boundary conditions and are checked loosely, this helps to get rid of the impossible states of the decimal counter, which is important in the absence of a RESET signal.

I did not bother with RESET because:

in my board it is connected to one of the two buttons, which greatly interferes with debugging;
I still have the ambiguity of which is more correct: synchronous or asynchronous RESET with the possible presence of a special dedicated line to each flipflop.

`default_nettype none
 module DecadeCounter(
         input wire i_clk,
         input wire i_inc,
         input wire i_dec,
         output wire [3:0]o_cnt,
         output wire o_carry);
     reg [3:0]r_cnt;
     reg r_carry;

     always @(posedge i_clk) begin
         if (i_inc) begin
             if (r_cnt >= 'd9) begin
                 r_cnt <= 0;
                 r_carry <= ~r_carry;
             end else begin
                 r_cnt <= r_cnt + 1'b1;
             end
         end
         if (i_dec) begin
             if (r_cnt == 'd0 || r_cnt > 'd9) begin
                 r_cnt <= 'd9;
                 r_carry <= ~r_carry;
             end else begin
                 r_cnt <= r_cnt - 1'b1;
             end
         end
     end
     assign o_cnt = r_cnt;
     assign o_carry = r_carry;

 endmodule
 // vim: expandtab:sw=4 ts=4

Single vibrator

The auxiliary module, which gives out a pulse of a fixed duration when the positive edge of the input signal is detected. It may not be necessary, but all my attempts to use the posedge input_signal led to a compiler hysteria, which for some reason decided that I want to create another clock

`default_nettype none
module SingleTick(
    input wire i_clk,
    input wire i_btn,
    output wire o_btn);
    reg r_oldstate;
    reg r_btn;

    always @(posedge i_clk) begin
        r_oldstate <= i_btn;
        r_btn <= i_btn && (i_btn != r_oldstate);
    end

    assign o_btn = r_btn;
endmodule
// vim: expandtab:sw=4 ts=4

Rotary encoder

How the sensor works is described in article. And here I will give two pictures from there, by which it becomes clear what I'm trying to do in the program:

Angle sensor phases

Sequence of the states

In short, the state of {1, 1} is significant for me, and I determine the direction of rotation depending on previous state.

`default_nettype none
module Rotary2018(input wire i_clk,
            input wire i_btn_a_,
            input wire i_btn_b_,
            output wire o_cw,
            output wire o_ccw);

        /* (meta)stablize buttons */
        wire w_btn_a;
        wire w_btn_b;
        metastab mbtn0(i_clk, ~i_btn_a_, w_btn_a);
        metastab mbtn1(i_clk, ~i_btn_b_, w_btn_b);

        /* debounce buttons */
        wire w_dbtn_a;
        wire w_dbtn_b;
        Debounce5ms dbtn0(i_clk, w_btn_a, w_dbtn_a);
        Debounce5ms dbtn1(i_clk, w_btn_b, w_dbtn_b);

        reg r_cw;
        reg r_ccw;
        reg r_a;
        reg r_b;

        // is {1, 1}
        wire w_is_signal_state;
        assign w_is_signal_state = w_dbtn_a & w_dbtn_b;

        always @(posedge i_clk) begin
            r_a <= w_dbtn_a;
            r_b <= w_dbtn_b;
            // signal only when change to {1, 1}
            if (w_is_signal_state) begin
                if (!(r_a & r_b)) begin
                    r_cw <= r_a;
                    r_ccw <= r_b;
                end
            end else begin
                r_cw <= 0;
                r_ccw <= 0;
            end
        end
        SingleTick st0(i_clk, r_cw, o_cw);
        SingleTick st1(i_clk, r_ccw, o_ccw);
endmodule
// vim: expandtab:sw=4 ts=4

A small graph of clockwise rotation detection:

The signal graph

All together

`default_nettype none
module main(input wire i_clk,
            input wire i_btn_a_,
            input wire i_btn_b_,
            output wire [16:0] o_led);

        wire [3:0] w_counter;
        /* verilator lint_off UNUSED */
        wire w_carry;
        /* verilator lint_on UNUSED */

        /* rotary */
        wire w_cw;
        wire w_ccw;
        Rotary2018 rot0(i_clk, ~i_btn_a_, ~i_btn_b_, w_cw, w_ccw);

        DecadeCounter dcnt0(i_clk, w_cw, w_ccw, w_counter, w_carry);

        // display
        Display16 disp0(w_counter, o_led);

endmodule
// vim: expandtab:sw=4 ts=4

How does this system work:

Video

Conclusion

In general, I liked how you can describe programmatically and then get a working device in the hardware. Yes, there are many pitfalls, yes, you need to change the programmer’s thinking in a different way, but it’s funny and interesting :)

DIY PS/2 keyboard adapter

2019-09-12T16:25:00+10:00

On the one hand, the adapter accepts keystrokes from the standard PS / 2 keyboard, and on the other hand, manipulates the input lines of the 1801VP1-014 chip by pretending to be a matrix of keys. The number of AtMega8 outputs is increased using a shift register. The firmware is written in the Forth dialect muforth

PS/2

I will not repeat here the full descriptions of the PS/2 protocol and electrical connection, as well as the key scancodes. This can be seen here and also here. Two pictures to remind:

Electrical PS/2 connection

PS/2 protocol example

This is how I connect the PS/2:

PS/2 keyboard connection diagram

R7 and R6 provide the formation of signals for outputs with an open collector at the keyboard, circuits with diodes (D1, D2, D3 и D4) and resistors R3 и R5 form a simple protection from static electricity. D2 (INT0) is connected to the CLK line, so an interrupt is used to synchronize with the keyboard when reading data. D3 is used as the DATA.

Power will have to be taken directly from the BK connector

Power for the adapter

INT0 is set to trigger on a fall.

%01 equ ISC00
%10 equ ISC01

code init-ps2
   ( ISC00=0, ISC01=1 -- the falling edge of INT0 generates an interrupt request)
   MCUCR h0 lds ISC00 invert h0 andi ISC01 h0 ori MCUCR h0 sts
   PS2CLK  DDRD cbi PS2CLK  PORTD cbi
   PS2DATA DDRD cbi PS2DATA PORTD cbi
   ret ;c

One of the timers is used to detect a timeout during communication with the keyboard: if a significant amount of time has passed since the last interruption on the CLK line, then I believe that a failure has occurred and I start receiving the byte from the very beginning. Start bit, parity bit and stop bit are ignored. The received byte is written to the ring buffer.

===========================================================================
 INT0 handler. Read data. Ignore start, parity and stop bits.
 After receiving BITS-PER-PACKET bits decode byte.
===========================================================================
code INT0-handler
    r0 push x pushw h0 push
    r0 clr

    -- PS2 wait not expired
    "ff tl ldi TIFR h0 in
    TOV0 h0 sbrs always tl clr 1 TOV0 << h0 ldi TIFR h0 out then
    -- tl = 0  -- PS2 timeout
    -- tl = ff -- no PS2 timeout

    -- X = bitcount addr
    bit-count >hilo xl ldi xh ldi

    -- timeout?
    tl tst .Z if BITS-PER-PACKET h0 ldi x@ h0 st then

    -- reset timeout timer
    256 PS2-WAIT-PERIOD - h0 ldi
    TCNT0 h0 out

    -- read bit if 2 < bitcount < BITS-PER-PACKET
    x@ h0 ld 3 h0 cpi      -- C = 0 if bit-count >= 3
                           -- C = 1 if bit-count < 3
      .C not if
            BITS-PER-PACKET h0 cpi -- C = 0 if bit-count >= BITS-PER-PACKET
                                   -- C = 1 if bit-count < BITS-PER-PACKET
             .C if -- read bit. Note bit C is set now!
                PS2DATA PIND sbis clc
                byte-read tl lds tl ror byte-read tl sts
            then
       then
    x@ h0 ld h0 dec -- h0 = bit-count 1-
    .Z if
              -- input-write
              input-wptr tl lds tl th mov th inc input-wptr th sts  -- input-wptr++
              BUFFER-LEN 1 - tl andi                                -- mask ptr
              input-buffer >hilo xl ldi xh ldi
              tl xl add r0 xh adc
              byte-read tl lds x@ tl st
              BITS-PER-PACKET h0 ldi
           then
    bit-count h0 sts

    h0 pop x popw r0 pop ret ;c

The 32-byte ring buffer is very simple: the pointers for reading and writing are increased to overflow a 16-bit word, and a mask is used for reading / writing. The word for writing to the buffer is commented out because the assembler version is used in the procedure for processing the keyboard interrupt.

===========================================================================
 Simple ring buffer.
 Uses two free pointers, which masked during access only.
===========================================================================
32 equ BUFFER-LEN   -- Note: need 10 bytes for PrtScreen press/release
BUFFER-LEN var input-buffer
1 var input-rptr
1 var input-wptr
: init-input-buffer 0 dup input-rptr c! input-wptr c! ;
code input-mask ( n - n) BUFFER-LEN 1- tl andi ret ;c
: input-empty? ( - f) input-wptr c@ input-rptr c@ = ;

( return ptr value and increment ptr)
: advance-ptr ( a - n) dup c@ swap over 1+ swap c! ;
comment XX : input-write (  b) input-wptr advance-ptr input-mask input-buffer + c! ; XX
: input-read ( - b) input-rptr advance-ptr input-mask input-buffer + c@ ;

Matrix of the keys

Matrix has 10 columns , 8 rows ( is always connected to ground) and few service signals. have pullup resistors 22K, - pulldown resistors 180K. The service lines, besides STOP, have pullup resistors 3.3K.

In the initial state, the corresponding lines of the 1801VP1-014 work as inputs, the resitors provide a high level at and a low level at . When a key is pressed, the following occurs:

gets a high level from the resulting 22K/180K divisor.

switches to low output mode.

gets low.

What do I need for electrical simulation of the matrix?

is always in input mode, so you don’t have to worry about current-limiting resistors

There is a pullup resistor, so I may not apply a high level, but just go into a high impedance state.

work both input and output, so I need to limit the current.

Lines

The lines (except ) are connected directly to the outputs of the microcontroller, the lines are connected through the current-limiting resistors R8-R14. The remaining signal lines and are connected to the shift register via optocouplers due to exhaustion of AtMega8 pins.Technically, optocouplers are not necessary, well, except for the STOP lines, however they were at hand :).

и line management:

===========================================================================
 Manipulate bk input lines
 X lines is switched between input and output. PortX alwayse quals 0.
 Y lines is switched between 0 and 1. DdrY is always output.

 X connects to input with 22k pullup so no need for current limiting (5/22e3 = 0.227mA).
 Y may be connected to the GND through open collector so it's better to
 use resistors. Max 200mA for all 11 pins. 200mA/11 = 18mA per pin,
 5/18e-3 = 275 Ohm min.

 -- input lines
 X0-9       = 9 pins (-x2)
 PS2 (data/clock) = 2 pins

-- output lines
 Y1-7        = 7 pins
 su + ar2 + zagl + str + pr + space + stop + x2 = 4 pins 74HC595 (7)

 total: 23 pins

 PS pins   = 2 x 10k
 Y1-7 pins = 7 x 330
 74HC595 pins = no resistors
 X0-9 = no resistors

===========================================================================

===========================================================================
 x0 - d0, x1 - d1, x3 - d4
 x4 - c5, x5 - c4, x6 - c2, x7 - c1, x8 - c0, x9 - c3
===========================================================================
code x3-3dstate
   4 DDRD cbi ret ;c
code x3-0
   4 DDRD sbi ret ;c

code y1-1
  1 PORTB sbi ret ;c
code y1-0
  1 PORTB cbi ret ;c

Installation check

Transcoding

It all starts with a state machine, going over the edge XXX simulates pressing STOP, going over the edges scancode leads to checking for special keys and then reading the command from one of the function tables. The command is a bit set, which indicates which lines need to be manipulated and how.

===========================================================================
 Normal key pressed
===========================================================================
: NORMAL ( b)
   dup "f0 = if drop 2release  ^ then
   dup "e0 = if drop 2extended ^ then
   dup "e1 = if drop 2pause    ^ then

   dup normal-modifiers? if drop ^ then
   dup normal-quirks? if drop ^ then

   .ifdef DEBUG "c log! .then
   call-decode ;

===========================================================================
 Normal key released
===========================================================================
: RELEASE ( b)
   dup "f0 = if drop 2normal ^ then
   dup "e0 = if drop 2normal ^ then

   dup release-modifiers? if drop 2normal ^ then
   dup release-quirks? if drop 2normal ^ then

   .ifdef DEBUG "d log! .then
   call-release-decode 2normal ;

===========================================================================
 Extended key pressed
===========================================================================
: EXTENDED ( b)
   dup "f0 = if drop 2rel-ext ^ then
   dup "e0 = if drop 2normal ^ then

   dup extended-modifiers? if drop 2normal ^ then
   dup extended-quirks? if drop 2normal ^ then

   .ifdef DEBUG "e log! .then
   call-decode 2normal ;

===========================================================================
 Extended key released
===========================================================================
: REL-EXT ( b)
   dup "f0 = if drop 2normal ^ then
   dup "e0 = if drop 2normal ^ then

   dup ext-release-modifiers? if drop 2normal ^ then
   dup ext-release-quirks? if drop 2normal ^ then

   .ifdef DEBUG "f log! .then
   call-release-decode 2normal ;

===========================================================================
 Pause key pressed
===========================================================================
( Pause send next bytes: E1,14,77,E1,F0,14,F0,77
  there is no reason to store first E1 therefore we store remaining bytes)
7 equ PAUSE-CHARS-LEN
name pause-chars "14 c, "77 c, "e1 c, "f0 c, "14 c, "f0 c, "77 c, .even
: PAUSE ( b)
      ['] pause-chars pause-char-ptr c@ +
      asm{ { t z movw th clr pmz tl ld } }
      = invert if 2normal ^ then
      pause-char-ptr c@ 1+
      dup PAUSE-CHARS-LEN < if pause-char-ptr c! ^ then
      drop
      mod-stop-p send-mod mod-stop-r send-mod 2normal ;

Part of the function table:

===========================================================================
 Recode tables for x/y lines [0..ff]
===========================================================================
( normal/release lat)
name lat-normal
   ( 00            01:F9        02         03:F5         04:F3  )
   key-nop c,    key-sbr-p c, key-nop c, key-|==>-p c, key-=|=>-p c,

   ( 05:F1           06:F2        07:F12     08            09:F10 )
   key-povtor-p c, key-kt-p c,  key-nop c, key-nop c,    key-nop c,

   ( 0a:F8         0b:F6          0c:F4         0d:tab       0e:`)
   key-shag-p c, key-indsu-p c, key-|<==-p c, key-tab-p c, key-nop c,

   ( 0f         10         11:LAlt    12:LShift    13         14:LCtrl)
   key-nop c, key-nop c, key-nop c, key-nop c,   key-nop c, key-nop c,

   ( 15:q       16:1       17         18         19         1a:z)
   key-q-p c, key-1-p c, key-nop c, key-nop c, key-nop c, key-z-p c,

Downloads

Kernel source - Forth kernel.
Monitor source - a monitor designed to exchange commands and data on a serial line is needed for initial initialization of the Fort.
Firmware source - main program.
Binary firmware - compiled firmware.

Fuses: E:FF, H:DE, L:E4

KiCad project

The microcontroller can be flashed directly on the board, here is the table for connecting the programmer:

Pin	Purpose
6 - XT2 (J5)	SCK
9 - XT2 (J5)	MOSI
10 - XT2 (J5)	MISO
12 - XT1 (J2)	GND
2 - J3	RESET

Flashing directly on the board

Key mapping

PS/2 key	BK key
Esc	КТ
F1	ПОВТ
F2	КТ
F3	=\|=>
F4	\|<==
F5	\|==>
F6	ИНДСУ
F7	БЛОКРЕД
F8	ШАГ
F9	СБР
Pause	СТОП
App	ВС
Insert	ВС
Delete	\|<==
Shift	ПР
Ctrl	СУ
Alt	АР2
Left Win	РУС
Right Win	ЛАТ
Home	ВС+ left
End	ВС+ right
PageUp	АР2+ up
PageDown	АР2+ down

Adapter on board