komunikilo 0.1.5

A chaotic communications simulator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

#!/usr/bin/env python3
import numpy as np
from math import cos, pi
from typing import Any, Generator, Iterable, List
import matplotlib.pyplot as plt

SAMP_RATE = 80000
SYMB_RATE = 1000
CARRIER_FREQ = 2500
SAMPS_PER_SYMB = SAMP_RATE / SYMB_RATE
T_STEP = 1 / SAMPS_PER_SYMB
# DATA = [False, False, True, False, False, True, False, True, True, True]
DATA = [True, True, False, False, True]

HADAMARD8 = [  # fmt: off
    [True, True, True, True, True, True, True, True],
    [True, False, True, False, True, False, True, False],
    [True, True, False, False, True, True, False, False],
    [True, False, False, True, True, False, False, True],
    [True, True, True, True, False, False, False, False],
    [True, False, True, False, False, True, False, True],
    [True, True, False, False, False, False, True, True],
    [True, False, False, True, False, True, True, False],
]  # fmt: on


def bits_to_nrz(bits: Iterable[bool]) -> List[int]:
    return [1 if bit else -1 for bit in bits]


def tx_bpsk(
    bits: Iterable[bool], sample_rate: int, symbol_rate: int, freq: float
) -> List[float]:
    samps_per_symb: int = int(sample_rate / symbol_rate)
    t_step: float = 1 / samps_per_symb
    return [
        b_i * cos(2 * pi * freq * (i * t_step))
        for (i, b_i) in enumerate(
            i for i in bits_to_nrz(bits) for _ in range(samps_per_symb)
        )
    ]


def tx_baseband_cdma(data: Iterable[bool], key: List[bool]) -> List[bool]:
    return [bit ^ keybit for bit in data for keybit in key]


def tx_cdma_bpsk(
    bits: Iterable[bool],
    sample_rate: int,
    symbol_rate: int,
    freq: float,
    key: List[bool],
) -> List[float]:
    """Seemingly Correct."""
    samps_per_symb: int = int(sample_rate / symbol_rate)
    samps_per_chip: int = int(samps_per_symb / len(key))
    t_step: float = 1 / samps_per_symb

    def loop_list(list: List[Any]) -> Generator[Any, None, None]:
        while True:
            for item in list:
                yield item

    loop_key = lambda key: (
        1 if keybit else -1 for keybit in loop_list(key) for _ in range(samps_per_chip)
    )

    bpsk_data = tx_bpsk(
        bits,
        sample_rate,
        symbol_rate,
        freq,
    )
    # A bit comes out every samples_per_symb.
    # We need len(key) chips within samples_per_symb.
    return [s_i * keybit for s_i, keybit in zip(bpsk_data, loop_key(key))]


def t(s: Iterable[Any], t_step: float) -> List[float]:
    return [t_step * i for i in range(len(s))]


def first_hadamard_code_plot():
    key = HADAMARD8[0]

    data_tx = bits_to_nrz(DATA)
    bpsk_tx = tx_bpsk(DATA, SAMP_RATE, SYMB_RATE, CARRIER_FREQ)
    cdma_baseband = tx_baseband_cdma(DATA, key)
    cdma_tx = tx_cdma_bpsk(DATA, SAMP_RATE, SYMB_RATE, CARRIER_FREQ, key)

    fig, axes = plt.subplots(4)
    axes[0].plot(list(range(1, 6)), data_tx, label="DATA: [1 1 0 0 1]")
    axes[0].legend()
    axes[1].plot(t(bpsk_tx, T_STEP), bpsk_tx, label="BPSK: (2.5kHz, 1kHz Data Rate)")
    axes[1].legend()
    axes[2].plot(
        t(cdma_tx, T_STEP),
        cdma_tx,
        label="CDMA: (2.5kHz, 1kHz Data Rate, 8kHz Chip Rate)",
    )
    axes[2].legend()

    _, _ = plt.psd(bpsk_tx, Fs=SAMP_RATE, Fc=CARRIER_FREQ, label="BPSK")
    _, _ = plt.psd(cdma_tx, Fs=SAMP_RATE, Fc=CARRIER_FREQ, label="CDMA-BPSK")
    plt.legend()
    plt.show()


def cdma_plot():
    key = HADAMARD8[3]

    data_tx = bits_to_nrz(DATA)
    bpsk_tx = tx_bpsk(DATA, SAMP_RATE, SYMB_RATE, CARRIER_FREQ)
    cdma_baseband = tx_baseband_cdma(DATA, key)
    cdma_tx = tx_cdma_bpsk(DATA, SAMP_RATE, SYMB_RATE, CARRIER_FREQ, key)

    # plt.rcParams["figure.figsize"] = [16, 9]
    fig, axes = plt.subplots(4)
    axes[0].plot(list(range(1, 6)), data_tx, label="DATA: [1 1 0 0 1]")
    axes[0].legend()
    axes[1].plot(t(bpsk_tx, T_STEP), bpsk_tx, label="BPSK: (2.5kHz, 1kHz Data Rate)")
    axes[1].legend()
    axes[2].plot(
        t(cdma_tx, T_STEP),
        cdma_tx,
        label="CDMA: (2.5kHz, 1kHz Data Rate, 8kHz Chip Rate)",
    )
    axes[2].legend()

    _, _ = plt.psd(bpsk_tx, Fs=SAMP_RATE, Fc=CARRIER_FREQ, label="BPSK")
    _, _ = plt.psd(cdma_tx, Fs=SAMP_RATE, Fc=CARRIER_FREQ, label="CDMA-BPSK")
    plt.legend()
    # plt.savefig("/tmp/asdf.png", dpi=300)
    fig.set_size_inches(16, 9)
    fig.savefig("/tmp/asdf.png", dpi=300)
    # plt.show()


def rust_plot():
    with open("/tmp/cdma_bpsk.csv") as f:
        import csv

        lines = [i for i in csv.reader(f)]
        tr = [float(line[0]) for line in lines[1:]]
        vr = [float(line[1]) for line in lines[1:]]

    (_, ax) = plt.subplots(2)
    ax[0].plot(t(y5p, T_STEP), y5p)
    ax[1].plot(tr, vr)

    plt.legend()
    plt.show()


if __name__ == "__main__":
    cdma_plot()
    # first_hadamard_code_plot()