ttytee 1.0.2

A process that exposes 2 copies of the same TTY
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

### For people new to rust we left here an easy copy paste doc to get you running if you want to contribute to this crate.

#### First you need to install rust stable.

Check first if on your distrib if they provide rustup:
For example on Arch Linux it is in the extra repro:
```
pacman -Ss rustup
[...]
extra/rustup 1.26.0-3 (2.5 MiB 7.0 MiB) (Installed)
    The Rust toolchain installer
[...]
```

Otherwise you can install it through the shell installer:
```bash
curl https://sh.rustup.rs -sSf | sh
```

You need then to install toolchains, let's start with the stable and native to your platform that will allow to
compile and test locally:

```bash
rustup toolchain install stable
```

#### Running

Note: ttytee is executed and the `--help` is the passed to it so it prints its help.
```bash
cargo run -- --help

   Compiling ttytee v0.1.0 (/home/gbin/projects/jet/telemetry/ttytee)
    Finished dev [unoptimized + debuginfo] target(s) in 0.44s
     Running `target/debug/ttytee --help`
Usage: ttytee [OPTIONS]

Options:
  -m, --master <MASTER>                              [default: /dev/skywaysgps1]
      --baudrate <BAUDRATE>                          [default: 9600]
      --slave0 <SLAVE0>                              [default: slave0.pty]
      --slave1 <SLAVE1>                              [default: slave1.pty]
      --master-read-timeout <MASTER SERIAL TIMEOUT>  [default: 1000]
      --slave-read-timeout <SLAVE READ TIMEOUT>      [default: 1000]
      --log-path <LOG_PATH>
  -h, --help                                         Print help
  -V, --version                                      Print version
```

#### Testing
```
cargo test
```

#### Formatting the entire project
```
cargo fmt
```

### Cross compiling for ARM targets

#### For the old 32bit version

First you need to add the crosscompiling and system part of the toolchain:
Here we use the musl variation of the libc because the system is so old it is hard to target for.
Musl enables us to build a fully static executable.
```bash
wget https://more.musl.cc/11.2.1/x86_64-linux-musl/arm-linux-musleabihf-cross.tgz
# somewhere you like you can decompress the tarball (I usually use ~/prefix).
tar xvf arm-linux-musleabihf-cross.tgz
```

Then in `~/.cargo/config.toml` you can inform Rust which linker you need to use for which target:
```toml
[target.armv7-unknown-linux-musleabihf]
linker = "[where you uncompressed it]/arm-linux-musleabihf-cross/bin/arm-linux-musleabihf-gcc"
```

Then finally we need to install the rust portion of it.
```bash
rustup target add armv7-unknown-linux-gnueabihf
```

To compile it for a target, just add it to any of the cargo command like (run, test ...):

- *Debug* build:
```bash
cargo build --target=armv7-unknown-linux-musleabihf

# The file will be produced here ~21MB:
file target/armv7-unknown-linux-musleabihf/debug/ttytee 
target/armv7-unknown-linux-musleabihf/debug/ttytee: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, with debug_info, not stripped
```

- *Release* build [recommended for prod]:
```bash
cargo build --release --target=armv7-unknown-linux-musleabihf

# The build will be produced here ~5MB:
file target/armv7-unknown-linux-musleabihf/release/ttytee
target/armv7-unknown-linux-musleabihf/release/ttytee: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, with debug_info, not stripped
```

- *Super tight prod* build added as an example if we target embedded systems:
```bash
cargo build --profile=stripped --target=armv7-unknown-linux-musleabihf

# The build will be produced here only ~500kB:
file target/armv7-unknown-linux-musleabihf/stripped/ttytee`
target/armv7-unknown-linux-musleabihf/stripped/ttytee: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, stripped
```

#### For an ARM 64bit version

The standard arm toolchain from arm then works, not that you can probably find it in your distribution too.

Same as the previous steps with
```bash
wget https://developer.arm.com/-/media/Files/downloads/gnu-a/10.3-2021.07/binrel/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu.tar.xz
tar xvf gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu.tar.xz
rustup target add aarch64-unknown-linux-gnu
```

in ~/.cargo/config.toml
```toml
[target.aarch64-unknown-linux-gnu]
linker = "[path to where you uncompressed it]/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu/bin/aarch64-none-linux-gnu-gcc"
```