Merge branch 'master' into mueller/master

2020-11-20 17:26:15 +01:00 · 2020-11-20 17:26:15 +01:00 · ba0f874a38
commit ba0f874a38
parent 3494fcc59b e25fd2f9b9
5 changed files with 200 additions and 35 deletions
--- a/20
+++ b/20
@ -70,8 +70,20 @@ CLEANBIN2 = $(BUILDPATH)/$(OUTPUT_FOLDER)/devel
 #-------------------------------------------------------------------------------

 # Tool suffix when cross-compiling
-CROSS_COMPILE =
+CROSS_COMPILE = arm-linux-gnueabihf-

+ifdef WINDOWS
+# C Compiler
+CC = $(CROSS_COMPILE)gcc.exe
+
+# C++ compiler
+CXX = $(CROSS_COMPILE)g++.exe
+
+# Additional Tools
+SIZE = $(CROSS_COMPILE)size.exe
+STRIP = $(CROSS_COMPILE)strip.exe
+CP = $(CROSS_COMPILE)objcopy.exe
+else
 # C Compiler
 CC = $(CROSS_COMPILE)gcc

@ -82,6 +94,7 @@ CXX = $(CROSS_COMPILE)g++
 SIZE = $(CROSS_COMPILE)size
 STRIP = $(CROSS_COMPILE)strip
 CP = $(CROSS_COMPILE)objcopy
+endif

 HEXCOPY = $(CP) -O ihex
 BINCOPY = $(CP) -O binary
@ -250,6 +263,7 @@ hardclean:

 # Only clean files for current build
 clean:
+	@echo $(DEPFILES)
 	-rm -rf $(CLEANOBJ)
 	-rm -rf $(CLEANBIN)
 	-rm -rf $(CLEANDEP)
@ -322,6 +336,7 @@ endif

 $(OBJDIR)/%.o: %.cpp
 $(OBJDIR)/%.o: %.cpp $(DEPENDDIR)/%.d | $(DEPENDDIR)
+	@echo $(I_INCLUDES)
 	@echo 
 	@echo $(MSG_COMPILING) $<
 	@mkdir -p $(@D)
@ -343,6 +358,7 @@ else
 	@$(CC) $(CXXFLAGS) $(CFLAGS) -c -o $@ $<
 endif

+
 #-------------------------------------------------------------------------------
 #		Dependency Handling
 #-------------------------------------------------------------------------------
@ -357,6 +373,8 @@ DEPFILES = $(addprefix $(DEPENDDIR)/, $(DEPENDENCY_RELATIVE))
 # Create subdirectories for dependencies
 $(DEPFILES):
 	@mkdir -p $(@D)
+	
+	
 # Include all dependencies
 include $(wildcard $(DEPFILES))	
 	
--- a/README.md
+++ b/README.md
@ -1,23 +1,39 @@
 # <a id="top"></a> <a name="linux"></a> EIVE On-Board Software

-## Linux
-These steps were tested for Ubuntu 20.04.
-If not done yet, install the full C++ build chain:
-```sh
-sudo apt-get install build-essential
-```
+## General information
+* OBC
+	* Xiphos Q7S
+	* Based on Zynq-7020 SoC (xc7z020clg484-2)
+		* Dual-core ARM Cortex-A9 
+		* 766 MHz
+		* Artix-7 FPGA (85K pogrammable logic cells)
+	* Datasheet at https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Arbeitsdaten/08_Used%20Components/Q7S&fileid=340648
+	* Also a lot of informatin about the Q7S can be found on the xiphos trac platform: https://trac.xiphos.com/trac/eive-q7/wiki/Q7RevB
+* Linux OS
+	* Built with Yocto 2.5
+	* Linux Kernel https://github.com/XiphosSystemsCorp/linux-xlnx.git
 	
-Linux has a limit to message queue message. Please see the section 
-to set up UNIX environment for more information.
-Sometimes, special steps are necessary so the real-time functionalities can be used
-without root privileges. Instructions are contained in the setup section
-for UNIX as well.
+
+## Setting up development environment
+* Install Vivado 2018.2 and Xilinx SDK from https://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/vivado-design-tools/archive.html
+* For supported OS refer to https://www.xilinx.com/support/documentation/sw_manuals/xilinx2018_2/ug973-vivado-release-notes-install-license.pdf
+* Add path of linux cross-compiler to environment variables SDK\2018.2\gnu\aarch32\nt\gcc-arm-linux-gnueabi\bin
+* Install make (only on windows, SDK on Linux can use the make installed with the SDK)
+	1. Install NodeJS LTS
+	2. Install xpm
+	````
+	npm install --global xpm
+	````
+	3. Install Windows build tools (after installation also linux commands like mkdir can be used from windows) 
+	````
+	xpm install --global @xpack-dev-tools/windows-build-tools@latest
+	````

 ### Building the software

 1. Clone the repository with
 ```sh
-git clone https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example.git
+git clone https://egit.irs.uni-stuttgart.de/eive/eive_obsw.git
 ```

 2. Update all the submodules
@ -27,15 +43,155 @@ git submodule sync
 git submodule update
 ```

-3. After that, the linux binary can be built with:
-```sh
-make -j all
-```
-to compile for Linux. All will build the debug version,
-which can also be built with the target `debug`. The optimized
-release version can be built with the target `release`.
+4. Open Xilinx SDK 2018.2
+5. Import project
+	* File &rarr; Import &rarr; C/C++ &rarr; Existing Code as Makefile Project
+6. Set build command 
+	* When on Linux right click project &rarr; Properties &rarr; C/C++ Build &rarr; Set build command to make -j
+		* -j causes the compiler to use all available cores
+	* On windows create a make target (Windows &rarr; Show View &rarr; Make Target)
+		* Right click eive_obsw &rarr; New
+		* Target name: all
+		* Uncheck "Same as the target name"
+		* Uncheck "Use builder settings"
+		* As build command type: <path to make>\make -j all WINDOWS=1
+7. Run build command (double click the generated target)

-4. Run the binary located inside the `_bin` folder.
+### Debugging the software (when workstation is directly conncected to Q7S)
+1. Assign static IP address to Q7S
+	* Open serial console of Q7S (Accessible via the micro-USB of the PIM, see also Q7S user maunal chapter 10.3)
+	* Baudrate 115200
+	* Login to Q7S:
+		* user: root
+		* pw: root
+	* Set IP address and netmask with
+	````
+	ifconfig eth0 192.168.133.10
+	ifconfig eth0 netmask 255.255.255.0
+	````
+2. Connect Q7S to workstation via ethernet
+3. Make sure the netmask of the ehternet interface of the workstation matches the netmask of the Q7S
+	* When IP address is set to 192.168.133.10 and the netmask is 255.255.255.0, an example IP address for the workstation
+	  is 192.168.133.2
+4. Run tcf-agent on Q7S
+	* Tcf-agent is not yet integrated in the rootfs of the Q7S. Therefore build tcf-agent manually
+	````
+	git clone git://git.eclipse.org/gitroot/tcf/org.eclipse.tcf.agent.git
+	cd org.eclipse.tcf.agent/agent
+	make CC=arm-linux-gnueabihf-gcc LD=arm-linux-gnueabihf-ld MACHINE=arm NO_SSL=1 NO_UUID=1
+	````
+	* Transfer executable agent from org.eclipse.tcf.agent/agent/obj/GNU/Linux/arm/Debug to /tmp of Q7S
+	````
+	cd obj/GNU/Linux/arm/Debug
+	scp agent root@192.168.133.10:/tmp
+	````
+	* On Q7S 
+	````
+	cd /tmp
+	chmod +x agent
+	````
+	* Run agent
+	````
+	./agent
+	````
+5. In Xilinx SDK 2018.2 right click on project &rarr; Debug As &rarr; Debug Configurations
+6. Right click Xilinx C/C++ applicaton (System Debugger) &rarr; New &rarr; 
+7. Set Debug Type to Linux Application Debug and Connectin to Linux Agent
+8. Click New
+9. Give connection a name
+10. Set Host to static IP address of Q7S. e.g. 192.168.133.10
+11. Test connection (This ensures the TCF Agent is running on the Q7S)
+12. Select Application tab
+	* Project Name: eive_obsw
+	* Local File Path: Path to eiveobsw-linux.elf (in _bin\linux\devel)
+	* Remote File Path: /tmp/eive_obsw.elf
+
+### Debugging the software via Flatsat PC
+Open SSH connection to flatsat PC:
+````
+ssh eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5
+````
+To access the console of the Q7S run the following:
+````
+sudo picocom -b 115200 /dev/ttyUSB0
+````
+To debug an application, first make sure a static IP address is assigned to the Q7S. Run ifconfig on the Q7S serial console.
+````
+ifconfig
+````
+Set IP address and netmask with
+````
+ifconfig eth0 192.168.133.10
+ifconfig eth0 netmask 255.255.255.0
+````
+To launch application from Xilinx SDK setup port fowarding on the localhost.
+````
+ssh -L 1534:192.168.133.10:1534 eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5
+````
+This forwards any requests to localhost:1534 to the port 1534 of the Q7S with the IP address 192.168.133.10.
+
+Note: When now setting up a debug session in the Xilinx SDK, the host must be set to localhost instead of the IP address
+      of the Q7S.
+
+
+### Launching an application after boot
+Load the root partiton from the flash memory (there are to nor-flash memories and each flash holds two xdi images).
+Note: It is not possible to modify the current loaded root partition.
+1. Disable write protection of the desired root partition
+````
+writeprotect 0 0 0 # unlocks nominal image on nor-flash 0
+````
+2. Mount the root partition
+````
+xsc_mount_copy 0 0 # Mounts the nominal image from nor-flash 0
+````
+3. Copy the executable to /bin/usr
+4. Make sure the permissions to execute the application are set
+````
+chmod +x application
+````
+5. Create systemd service in /lib/systemd/system. The following shows an example service.
+````
+cat > example.service
+[Unit]
+Description=Example Service
+StartLimitIntervalSec=0
+
+[Service]
+Type=simple
+Restart=always
+RestartSec=1
+User=root
+ExecStart=/usr/bin/application
+
+[Install]
+WantedBy=multi-user.target
+````
+6. Enable the service. This is normally done with systemctl enable. However, this is not possible when the service is
+   created for a mounted root partition. Therefore create a symlink as follows.
+````
+ln -s '/tmp/the-mounted-xdi-image/lib/systemd/system/example.service' '/tmp/the-mounted-xdi-image/etc/systemd/system/multi-user.target.wants/example.service'
+````
+7. The modified root partition is written back when the partion is locked again. 
+````
+writeprotect 0 0 1 
+````
+8. Now verify the application start by booting from the modified image
+````
+xsc_boot_copy 0 0
+````
+9. After booting verify if the service is running 
+````
+systemctl status example
+````
+More detailed information about the used q7s commands can be found in the Q7S user manual.
+
+
+
+### Update file in rootfs
+````
+writeprotect 0 0 0 # qspi0 nom unlock (see also Q7S user manual)
+````

 ### Setting up UNIX environment for real-time functionalities
 Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities 
--- a/bsp_linux/main.cpp
+++ b/bsp_linux/main.cpp
@ -9,8 +9,6 @@
 #include <version.h>
 #include <unistd.h>

-
-
 /**
 * @brief 	This is the main program for the hosted build. It can be run for
 * 			Linux and Windows.
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 7ffce219d5f86df29fe3348cdeb703419ba32acd
+Subproject commit ca34250e8d74cec8a75bed284bf0ec9252019b65
--- a/mission/core/ObjectFactory.cpp
+++ b/mission/core/ObjectFactory.cpp
@ -99,19 +99,12 @@ void ObjectFactory::produce(){

 	/* TMTC Reception via UDP socket */
 	new TmFunnel(objects::TM_FUNNEL);
-#ifdef LINUX
+
 	new TmTcUnixUdpBridge(objects::UDP_BRIDGE,
 			objects::CCSDS_PACKET_DISTRIBUTOR,
 			objects::TM_STORE, objects::TC_STORE);
-	new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
-#elif WIN32
-    new TmTcWinUdpBridge(objects::UDP_BRIDGE,
-            objects::CCSDS_PACKET_DISTRIBUTOR, objects::TM_STORE,
-            objects::TC_STORE);
-    new TcWinUdpPollingTask(objects::UDP_POLLING_TASK,
-            objects::UDP_BRIDGE);
-#endif

+	new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);

 	/* PUS stack */
 	new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION,