# IOT-Labor

## Versuch 1: Bash

- Alle Aufgaben sind als Skripte implementiert

## Versuch 2: Python

- Aufgaben a bis c als Skripte implementiert

### d)

- Laden des Servo Daemon

```bash
/home/pi/PiBits/ServoBlaster/user/servod
```

- Konfigurieren von zwei Servos auf den P1 Pins **11** und **12**.
    - Pin in P1 Header: 11 ist GPIO Pin: 17 ist Servo: 1
    - Pin in P1 Header: 12 ist GPIO Pin: 18 ist Servo: 2
    - Pulsbreite ist die Periodendauer: T = $\frac{1}{f}$
    - 100Hz sind 0.01s, also 10000 $\mu s$
        - $\frac{1}{100Hz} = 0.01s = 10000\mu s$
- Servos und Pulsbreite in ```/dev/servoblaster``` eintragen

```bash
echo 1=10000 > /dev/servoblaster
echo 2=10000 > /dev/servoblaster
```

### e)

- Oszilloskop an GPIO Pin 17 anschließen
- Minimale Pulsbreite ermitteln? 10$\mu s$ ???

### f)

- in der servoblaster_ctl.py

### g)

- Als Skript implementiert

## Versuch 3: Steuerung Keyboard

### 4d)

#### Motor

- Pulsbreite von 100 bis 200
- $150 + \frac{v}{v_{max}} * 50$

| v [m/s] | PWM (gemessen) | PWM (soll) |
|---------|----------------|------------|
| 0       |                |1.5ms       |
| -12.3   |                |2ms         |
| 0.9     |                |15.409ms    |
| -7.4    |                |11.636ms    |

#### Steuerung

- Pulsbreite von 100 bis 200
- $150 + \frac{\alpha}{\alpha_{max}} * 50$

| $\alpha$ [°] | PWM (gemessen) | PWM (soll) |
|-------|----------------|------------|
| -3    |                |14.66ms     |
| 18    |                |17ms        |
| 0     |                |1.5ms       |
| -44.2 |                |10.08ms     |

## Veruch 4: Wiimote

- Wiimote mit dem hcitool finden

```bash
hcitool scan 
```

- Grundgerüst ist implementiert

- Accelerometer Steuerung
    - TODO
    - Anlog zur Maussteuerung
        - Werte MAX, MIN anpassen

## Versuch 5

- Verbinden mit WLAN
- ESSID: group20n
- Kein Passwort und kein DHCP

```bash
sudo ifconfig ra0 192.168.1.42 netmask 255.255.255.0 up
sudo iwconfig ra0 essid off
sudo iwconfig ra0 essid group02n
```

- dann Routen prüfen

### Delays und Offset messen

- Zeit synkronisieren

```bash
ntpq time1.rrzn.uni-hannover.de
```

- Für dratgebunden

|       | Dealy | Offset |
|-------|-------|--------|
|Laptop |       |        |
| Pi    |       |        |

- Für dratlos

|       | Dealy | Offset |
|-------|-------|--------|
|Laptop |       |        |
| Pi    |       |        |

- **Default Route wieder auf ethernet stellen**
- NTP Service konfigurieren#
    - in ```/etc/ntp.conf```
    - ```server time1.rrzn.uni-hannover.de``` eintragen
    - ```sudo service ntp stop|start```


### Streaming über das drahtgebundene Netz

- PI Kamera konfigurieren
    - Kamera anstellen

```bash
sudo raspi-config
```

- Segmentation offloading ausschalten
    - Für beide Interfaces

```bash
ethtool -K <interface> tso off
```

- tcpdump starten auf Client und Server
    - als root
- Auf dem Client

```bash
tcpdump -i <interface> tcp and port 1337 and dst <server-ip> -r <file-name.pcap>
```

- Auf dem Server

```bash
tcpdump -i <interface> tcp and port 1337 and src <client-ip> -r <file-name.pcap>
```

- simple-server.py und simple-client.py verwenden
    - Client auf dem PI
    - Server auf dem Laptop

```bash
./simple-server.py -a <IP> --tcp
./simple-client.py -s <Server-IP> --tcp
```

- Commulative arrival function für Server und Client berechnen und ploten
    - Für später schon Bitraten notieren

```bash
./plot-pcap.py --client <pcap> --server <pcap>
```

- OWDs berechnen

```bash
./calc-owd.py --client <pcap> --server <pcap>
```

- Mittelwert:
- Varianz:
- Standardabweichung:

- Eingestellte Bitrate:
- Tatsächlich gesendete Bitrate:

### Streaming über WLAN

- default route über WLan einrichten

#### Plot TCP

- Stream für 60s mitschneiden und auswerten
    - Wie vorher schon nur über WLan
    - Plot der Pakete
    - OWDS

- Mittelwert:
- Varianz:
- Standardabweichung:

#### Plot UDP

- Mittelwert:
- Varianz:
- Standardabweichung:


- Was ist besser?

#### Mittelwert und Standardabweichung der OWDs

- TCP:
    - Mittelwert:
    - Standardabweichung:
- UDP:
    - Mittelwert:
    - Standardabweichung:

- Um OWDs mit UDP genauer zu berechnen müsste die Reihenfolge der Pakete beachtet werden und die Uhren von Client und Server genaustens synkronisiert werden.

#### Verschiedene Bitraten

- Hier wieder OWDs messen

- Für LAN

- Für WLAN

#### Verschiedene Parameter raspivid

- Hier wieder OWDs messen

#### Verschiedene Puffergrößen

- Einmal mit 10Byte und 1400 Byte (WLan MTU)
- Was passiert, wenn die Puffergröße größer als tie MTU
    - Fragmentierung, mehr Overhead
- Mit 4000B Puffergröße versuchen
    - Mit Wireshark angucken

### Streaming am Fahrzeug

- Ploten der Pakete in einer Abbildung (wie vorher)
    - Wenn das Modellauto sich stetig vom Router entfernt.
    - Wenn das Modellauto den Raum verlässt.
- Was kann in beiden Fällen beobachtet werden?

## Versuch 6

- Sensoten für diesen Versuch:
    - Infrarot: GP2D12
    - Kompas: CMPS03
    - Radencoder: Hat Reflexoptokoppler CNY70
    - Ultraschall-Modul: SRF08

- Überprüfen ob Sensoren angeschlossen sind
    - y-Flag gibt den Bus an

```bash
sudo i2cdetect -l
sudo i2cdetect -y 1
```

- Kernelmodule laden i2c-bcm2708
    - Überprüfen mit ```lsmod```

- Adressen in die ```ikt_car_sensorik.py``` eintragen
    - Unten in der Main