OpenIPC
/
wiki
mirror of https://github.com/OpenIPC/wiki.git
1
0
Fork 0
Code Activity

Merge branch 'OpenIPC:master' into master

pull/416/head
cdg123 2024-10-04 13:45:41 +01:00 committed by GitHub
parent 366f866823 66554dc46b
commit b758b3b5a2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 241 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -63,6 +63,7 @@ OpenIPC Wiki
- [A selection of OpenIPC videos on YouTube](en/fpv-youtube.md)
- [RunCam WiFiLink based on OpenIPC](en/fpv-runcam-wifilink-openipc.md)
- [Radxa based groundstation](en/fpv-radxa.md)
- [The mavfwd tool](en/fpv-mavfwd.md)
### Troubleshooting

5
en/fpv-kit.md
View File

@ -4,11 +4,6 @@
Selecting hardware to complete OpenIPC FPV kits
-----------------------------------------------
<p align="center">
<img src="https://github.com/OpenIPC/wiki/blob/master/images/fpv-logo.jpg?raw=true" alt="Logo"/>
</p>
### FPV kit 1
- IPCam board GK7205V200 + IMX307

30
en/fpv-mavfwd.md 100644
View File

@ -0,0 +1,30 @@
# OpenIPC Wiki
[Table of Content](../README.md)
OpenIPC FPV - mavfwd tool
-------------------------
Edit **/etc/wifibroadcast.cfg**:
```diff
[gs_mavlink]
peer = 'connect://127.0.0.1:14550' # outgoing connection
-# peer = 'listen://0.0.0.0:14550' # incoming connection
+peer = 'listen://0.0.0.0:14550' # incoming connection
```
Update settings:
```
echo cli -s .video0.fps 120 > /dev/udp/localhost/14550
```
Update drone key:
```
file="echo $(cat gs.key | base64) | base64 -d > /etc/drone.key"
echo $file > /dev/udp/localhost/14550
```
Update configuration:
```
file="echo $(cat wfb.conf | base64) | base64 -d > /etc/wfb.conf"
echo $file > /dev/udp/localhost/14550
```

146
en/fpv-openipc-aio-internet-forwarding.md 100644
View File

@ -0,0 +1,146 @@
## AIO Mario firmware update over usb via internet forwarding
This method will work on Linux due to specific network commands. The key idea is to use the local PC as a network bridge betwen AIO board ethernet interface and your local internet interface.
## Steps
1. Connect AIO Mario to USB
2. Identify your PC address. On your local PC run:
```bash
ip -c a
...
3: enx00e099fead02: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 00:e0:99:fe:ad:02 brd ff:ff:ff:ff:ff:ff
inet 192.168.1.11/24 brd 192.168.1.255 scope global noprefixroute enx00e099fead02
valid_lft forever preferred_lft forever
inet6 fe80::de74:78fc:9af0:f031/64 scope link noprefixroute
valid_lft forever preferred_lft forever
```
Here: `192.168.1.11` is my local PC address on AIO ethernet interface.
3. Connect to AIO Mario over ssh. On PC:
```bash
ssh root@192.168.1.10
```
4. List AIO routes. On AIO run:
```bash
root@openipc-ssc338q:~# route -n
Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
192.168.1.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0
```
5. We need to add a route to our local PC, so traffic could get route over. On AIO run:
```bash
root@openipc-ssc338q:~# route add default gw 192.168.1.11 eth0
```
Here: `192.168.1.11` is the local PC address.
6. Verify that route was added correctly:
```bash
root@openipc-ssc338q:~# route -n
Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
0.0.0.0 192.168.1.11 0.0.0.0 UG 0 0 0 eth0
192.168.1.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0
```
7. On the local PC we need to forward all the traffic from `enx00e099fead02` AIO Mario ethernet interface to our local connection.
This can be `wlp2s0` for wifi. To check the interface name, on the local PC run again:
```bash
ip -c a
2: wlp2s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether f8:34:41:af:55:37 brd ff:ff:ff:ff:ff:ff
inet 192.168.1.8/24 brd 192.168.1.255 scope global noprefixroute wlp2s0
valid_lft forever preferred_lft forever
inet6 fe80::8d6a:f2f6:c850:cf9d/64 scope link noprefixroute
valid_lft forever preferred_lft forever
```
Here: `wlp2s0` is my internet connection, it could be also `eth0` on other setups.
8. Traffic forwarding. Create a bash script `~/forward.sh`:
```bash
#!/bin/bash
# Get the interface name of the wireless card by stdin
# $1 is the interface name of the AIO card
USB_AIO=$1
INTERNET_IF=$2
sudo iptables -A FORWARD -i $USB_AIO -o $INTERNET_IF -j ACCEPT
sudo iptables -A FORWARD -i $INTERNET_IF -o $USB_AIO -m state --state RELATED,ESTABLISHED -j ACCEPT
sudo iptables --table nat -A POSTROUTING -o $INTERNET_IF -j MASQUERADE
```
This script will receive as input `$1` the AIO ethernet interface, and forward the traffic to `$2`.
Enable IP forwading by editing `/etc/sysctl.conf` on your local PC and adding:
```
net.ipv4.ip_forward = 1
```
And enable the changes with:
```bash
sudo sysctl -p /etc/sysctl.conf
```
on Debian/Ubuntu systems this can be also done restarting the procps service:
```
sudo /etc/init.d/procps restart
```
9. Run the script on your local PC:
```bash
chmod u+x ./forward.sh
sudo ./forward.sh enx00e099fead02 wlp2s0
```
Here: `enx00e099fead02` is AIO ethernet interface, and `wlp2s0` local PC interface.
10. On AIO Mario we need to configure DNS servers. Edit `/etc/resolv.conf` and add:
```
nameserver 8.8.8.8
nameserver 8.8.4.4
```
11. Test internet acces. On AIO run `ping 8.8.8.8` and `ping openipc.org`:
```bash
root@openipc-ssc338q:~# ping 8.8.8.8
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: seq=0 ttl=116 time=23.611 ms
64 bytes from 8.8.8.8: seq=1 ttl=116 time=28.683 ms
^C
--- 8.8.8.8 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 23.611/26.147/28.683 ms
root@openipc-ssc338q:~# ping openipc.org
PING openipc.org (5.161.116.152): 56 data bytes
64 bytes from 5.161.116.152: seq=0 ttl=51 time=290.381 ms
64 bytes from 5.161.116.152: seq=1 ttl=51 time=207.881 ms
64 bytes from 5.161.116.152: seq=2 ttl=51 time=232.049 ms
^C
--- openipc.org ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 207.881/243.437/290.381 ms
```
12. Update firmware:
```bash
root@openipc-ssc338q:~# sysupgrade -r -k -n --force_ver
OpenIPC System Updater v1.0.41
Vendor sigmastar
SoC ssc338q
Kernel 03:35:18 2024-09-27
RootFS master+d69195a, 2024-09-27
Synchronizing time
ntpd: setting time to 2024-09-28 00:05:42.525372 (offset +73821.493151s)
Sat Sep 28 00:05:42 GMT 2024
Checking for sysupgrade update...
Same version. No update required.
Stop services, sync files, free up memory
Stopping crond: OK
Stopping ntpd: OK
Stopping klogd: OK
Stopping syslogd: OK
...
```

85
en/sysupgrade.md
View File

@ -3,31 +3,58 @@
Upgrading firmware
------------------
Once the initial installation of the OpenIPC software for your camera is complete it is possible to upgrade it either via the web interface or manually via a terminal window.
### Upgrading from GitHub
For old firmware running `sysupgrade` without parameters is enough. For newer firmware, run `sysupgrade -k -r` to update both kernel and rootfs.
This article is about how to manually perform an update using a terminal window using the sysupgrade command.
__ATTENTION! Upgrading firmware can lead to "bricking" your camera. Make sure you are prepared both morally and skillwise. Have your rescue SD card and/or UART adapter ready. Be prepared to de-solder and reprogram flash chip as the last resort. Do not upgrade production cameras unless you really have to!__
_Note: By default, sysupgrade will reboot the camera to complete the update. If you don't wish to do that then use the -x option (see sysupgrade --help for all options)_.
### Upgrading from a TFTP server
### Upgrading from the GitHub latest release.
By default, running sysupgrade will attempt to download the latest software for your camera model from the github sources.
[Set up a TFTP server](installation-tftpd.md).
There are other options available so you can use a local copy of the Linux kernel (uImage) and camera software (rootfs.squashfs).
Go to <https://github.com/OpenIPC/firmware/releases/tag/latest> and download the latest firmware bundle for your SoC.
Extract content of the bundle into the root directory of your TFTP server.
For old firmware running `sysupgrade` without parameters is enough. For newer firmware, run `sysupgrade -k -r` to update both kernel and rootfs is required.
On the camera run:
__ATTENTION! Upgrading firmware can lead to "bricking" your camera. Make sure you are prepared both morally and skill wise. Have your rescue SD card and/or UART adapter ready. Be prepared to de-solder and reprogram flash chip as the last resort. Do not upgrade production cameras unless you really have to!__
#### Github: From Linux
### Using sysupgrade
Typically running sysupgrade will give you the latest release for your camera, as described above, however if you wish to revert to a previous image, or load your own updates, then use any the options described below.
Remember once you are ready to run sysupgrade you must use the syntax </br></br>
`sysupgrade --kernel=/tmp/uImage.${soc} --rootfs=/tmp/rootfs.squashfs.${soc} -z` </br></br>where '${soc}' is your camera specific soc e.g. gk7205v300
otherwise the latest release on Github will be downloaded.
### Using a TFTP server
#### On your host machine:
If you haven't already got a TFTP server running on your host machine then take a look at the Wiki article [Set up a TFTP server](installation-tftpd.md).
If you don't already have the uImage and rootfs.squashfs images for your camera then go to <https://github.com/OpenIPC/firmware/releases/tag/latest> and download the latest firmware bundle for your SoC and extract the content of the bundle into the root directory of your TFTP server.
```bash
tar xvf <firmware.tgz>
```
If you have built your own versions using a copy of the [firmware repository](https://github.com/OpenIPC/firmware) then your uImage and rootsfs.squashfs images will be in your _output/images_ folder. Copy these to the root of your tftp server.
#### On the camera:
You can either update the images from a Linux terminal session or from the U-Boot prompt, if you have a UART serial connection and interrupted Linux loading.
Check that your camera environment variable for the TFTP server is correct by looking for the _serverip_ entry when listing them with _fw_printenv_.
If it needs updating use _fw_setenv serverip <your.tftp.ip.address>_ command.
##### From Linux
```bash
soc=$(fw_printenv -n soc)
serverip=$(fw_printenv -n serverip)
cd /tmp
busybox tftp -r rootfs.squashfs.${soc} -g ${serverip}
busybox tftp -r uImage.${soc} -g ${serverip}
sysupgrade --kernel=/tmp/uImage.${soc} --rootfs=/tmp/rootfs.squashfs.${soc} -z
```
#### Github: Alternatively, from U-Boot
##### From U-Boot
for 8MB image
@ -49,37 +76,53 @@ tftp ${baseaddr} rootfs.squashfs.${soc}
sf probe 0; sf erase 0x250000 0xA00000; sf write ${baseaddr} 0x250000 ${filesize}
```
### Upgrading from local files
Now restart the camera to load the new images.
Go to <https://github.com/OpenIPC/firmware/releases/tag/latest> and download the latest firmware bundle for your SoC.
Unpack the bundle and upload its content on camera using `scp`:
### Using scp
#### On your host machine:
If you don't already have the uImage and rootfs.squashfs images for your camera then go to <https://github.com/OpenIPC/firmware/releases/tag/latest> and download the latest firmware bundle for your SoC and extract the contents.
```bash
tar xvf <firmware.tgz>
```
If you have built your own versions using a copy of the [firmware repository](https://github.com/OpenIPC/firmware) then your uImage and rootsfs.squashfs images will be in your _output/images_ folder.
Now copy these to the camera using scp.
```bash
scp uImage* rootfs* root@<yourcameraip>:/tmp/
```
On the camera run:
**Note:** If you get an error that '/usr/libexec/sftp-server could not be found' it is because in later versions of scp sftp is now used behind the scenes and this is not built into the busybox implementation currently. To force scp to use the legacy behavour use the -O option so
```bash
scp -O uImage* rootfs* root@<yourcameraip>:/tmp/
```
#### On the camera:
Now create a terminal session with the camera e.g. ssh root@192.168.1.10 and run the sysupgrade command pointing at your new images in /tmp.
```bash
soc=$(fw_printenv -n soc)
sysupgrade --kernel=/tmp/uImage.${soc} --rootfs=/tmp/rootfs.squashfs.${soc} -z
```
### Upgrading from SD card
### Upgrading from an SD card
#### On your host machine
If you don't already have the uImage and rootfs.squashfs images for your camera then go to <https://github.com/OpenIPC/firmware/releases/tag/latest> and download the latest firmware bundle for your SoC and extract the contents
#### SD Card: From Linux
If you have built your own versions using a copy of the [firmware repository](https://github.com/OpenIPC/firmware) then your uImage and rootsfs.squashfs images will be in your _output/images_ folder.
Go to <https://github.com/OpenIPC/firmware/releases/tag/latest> and download the latest firmware bundle for your SoC.
Insert an SD card into your desktop PC. Unpack the bundle and copy its content to the card:
Insert an SD card into your host machine and copy the uImage and squashfs files to the card e.g.
```bash
tar xvf <firmware.tgz>
cp uImage* rootfs* /media/<username>/<card-id>/
```
#### On your camera
Insert the SD card into your camera.
On the camera run:
Create a terminal session and run the following
```bash
soc=$(fw_printenv -n soc)
@ -114,7 +157,7 @@ sf probe 0; sf erase 0x350000 0xa00000; sf write ${baseaddr} 0x350000 ${filesize
### Flashing U-Boot via ymodem
Clean 320K of RAM amd load bootloader file into it:
Clean 320K of RAM and load bootloader file into it:
```bash
mw.b ${baseaddr} 0xff 0x50000