Redundant Communication - Revision history

IHaveADrone: /* Hardware */ Tx pin locations

2016-06-30T15:33:00Z

Hardware: Tx pin locations

← Older revision		Revision as of 09:33, 30 June 2016
Line 129:		Line 129:
	* For the Lisa/M, the USB port can actually be used as a UART port with some hardware modifications.		* For the Lisa/M, the USB port can actually be used as a UART port with some hardware modifications.
	* Using an I2C GPS instead of a UART one can free up a UART port on most autopilots.		* Using an I2C GPS instead of a UART one can free up a UART port on most autopilots.
	* For the Lisa/M, can UART 1 and 5 be used if Spektrum Satellite receivers aren't used? ~~If so, where are~~ the ~~Tx pins?~~		* For the Lisa/M, can UART 1 and 5 be used if Spektrum Satellite receivers aren't used? The board needs to be modified to access UART1_Tx see [[Lisa/M_v2.0#USB_as_UART1TX_.2B_hardware_flow_control\|here]]. UART5_Tx is PC12 on the GPIO connector.

	In addition, future hardware designs could includes more UART ports for redundant communications or any other purpose.		In addition, future hardware designs could includes more UART ports for redundant communications or any other purpose.

Camlee at 03:50, 31 May 2013

2013-05-31T03:50:17Z

← Older revision		Revision as of 21:50, 30 May 2013
Line 3:		Line 3:
	<div style="float: right; width: 40%">__TOC__</div>		<div style="float: right; width: 40%">__TOC__</div>

	There is currently a pull request to integrate a redundant communication system into the existing ground segment agents: [https://github.com/paparazzi/paparazzi/pull/429 github.com/paparazzi/paparazzi/pull/429]. The goal of this project is to allow multiple radio modems or other links be used between the aircraft and the ground station in a redundant fashion so that even if one link is lost, communication can be maintained. So far, the aircraft to ground component has been created and tested in the lab~~. More comprehensive testing should be performed before the system is considered to be stable~~. The ground to aircraft component has not been created yet.		This goal of this project is to allow multiple radio modems or other links be used between the aircraft and the ground station in a redundant fashion so that even if one link is lost, communication can be maintained. So far, the aircraft to ground component has been created and tested in the lab. The ground to aircraft component has not been created yet.

	===Reasons to Use Redundant Links===		===Reasons to Use Redundant Links===

Camlee at 02:07, 29 April 2013

2013-04-29T02:07:15Z

← Older revision		Revision as of 20:07, 28 April 2013
Line 5:		Line 5:
	There is currently a pull request to integrate a redundant communication system into the existing ground segment agents: [https://github.com/paparazzi/paparazzi/pull/429 github.com/paparazzi/paparazzi/pull/429]. The goal of this project is to allow multiple radio modems or other links be used between the aircraft and the ground station in a redundant fashion so that even if one link is lost, communication can be maintained. So far, the aircraft to ground component has been created and tested in the lab. More comprehensive testing should be performed before the system is considered to be stable. The ground to aircraft component has not been created yet.		There is currently a pull request to integrate a redundant communication system into the existing ground segment agents: [https://github.com/paparazzi/paparazzi/pull/429 github.com/paparazzi/paparazzi/pull/429]. The goal of this project is to allow multiple radio modems or other links be used between the aircraft and the ground station in a redundant fashion so that even if one link is lost, communication can be maintained. So far, the aircraft to ground component has been created and tested in the lab. More comprehensive testing should be performed before the system is considered to be stable. The ground to aircraft component has not been created yet.

	===Reasons to ~~redundant links~~===		===Reasons to Use Redundant Links===
	Communication from the aircraft to the ground is called telemetry. This communication allows the status of the aircraft such as location, altitude, airspeed, battery level, current flight block, and much more to be monitored in real time. Communication from the ground to the aircraft is called datalink. This communication allows commands to be sent to the aircraft from the ground. This includes telling the aircraft what navigation to perform: fly to a waypoint, start the search area, come in for a landing. If a single link is used, as was always the case before this project, then if the aircraft goes out of range, or that link is otherwise lost, no telemetry information can be displayed in the GCS and commands sent from the GCS won't be received by the aircraft. Using the following redundant link system allows multiple links to be used in an effort to avoid this. Typically, you would introduce diversity when adding links. For example:		Communication from the aircraft to the ground is called telemetry. This communication allows the status of the aircraft such as location, altitude, airspeed, battery level, current flight block, and much more to be monitored in real time. Communication from the ground to the aircraft is called datalink. This communication allows commands to be sent to the aircraft from the ground. This includes telling the aircraft what navigation to perform: fly to a waypoint, start the search area, come in for a landing. If a single link is used, as was always the case before this project, then if the aircraft goes out of range, or that link is otherwise lost, no telemetry information can be displayed in the GCS and commands sent from the GCS won't be received by the aircraft. Using the following redundant link system allows multiple links to be used in an effort to avoid this. Typically, you would introduce diversity when adding links. For example:
	* If you have an on-board computer, you could tunnel messages through Wi-Fi over UDP in addition to a traditional 900 MHz XBee radio modem.		* If you have an on-board computer, you could tunnel messages through Wi-Fi over UDP in addition to a traditional 900 MHz XBee radio modem.
Line 40:		Line 40:
	* A performance and resource use analysis could be done to optimize the Link Combiner. The circular buffer is currently implemented using Python lists which could probably be improved upon. Also, significantly more ivy messages are sent and received. This might make optimizations to the regex or other parts of the ivybus worthwhile.		* A performance and resource use analysis could be done to optimize the Link Combiner. The circular buffer is currently implemented using Python lists which could probably be improved upon. Also, significantly more ivy messages are sent and received. This might make optimizations to the regex or other parts of the ivybus worthwhile.

	===How to ~~use~~===		===How to Use===

	For an example using two USB-serial adaptors, see the '''Flight USB-serial Redundant''' session saved in the example control_panel.xml configuration (on master branch, once the pull request has been accepted).		For an example using two USB-serial adaptors, see the '''Flight USB-serial Redundant''' session saved in the example control_panel.xml configuration (on master branch, once the pull request has been accepted).

Camlee at 05:33, 28 April 2013

2013-04-28T05:33:42Z

← Older revision		Revision as of 23:33, 27 April 2013
Line 137:		Line 137:

	The challenging part of this design will be integrating it properly into the existing systems.		The challenging part of this design will be integrating it properly into the existing systems.

			[[Category:Tools]]

Camlee at 05:31, 28 April 2013

2013-04-28T05:31:20Z

← Older revision		Revision as of 23:31, 27 April 2013
Line 53:		Line 53:
	The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:		The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:

	[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|700px\|The Agents Running in a Redundant Link Setup]]		[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|700px\|thumb\|center\|The Agents Running in a Redundant Link Setup]]
			<br style="clear:both">

	* Test the system and make sure that it works correctly under all circumstances. Do this before flying. In particular, make sure that the buffer size if appropriate. Take a look at the [[#Algorithm Considerations\|Algorithm Considerations]] section for details.		* Test the system and make sure that it works correctly under all circumstances. Do this before flying. In particular, make sure that the buffer size if appropriate. Take a look at the [[#Algorithm Considerations\|Algorithm Considerations]] section for details.
Line 61:		Line 62:

	The following screenshot clearly shows these changes:		The following screenshot clearly shows these changes:
	[[File:redundant_link_gcs.png\|alt=Changes to the GCS when redundant links are used\|1000px]]		[[File:redundant_link_gcs.png\|alt=Changes to the GCS when redundant links are used\|1000px\|thumb\|center\|Screenshot of the GCS with multiple links]]
			<br style="clear:both">

	Firstly, we can see that there is a new page in the notebook named Link. This page contains critical information for each link. More information can easily be added, but for now, it shows the status of the link (just like the main Link status indicator in the strip), the current ping time, and the rate of received messages. So if one link is lost, it's status indicator will turn red and start counting up just like link 2 in the above screenshot.		Firstly, we can see that there is a new page in the notebook named Link. This page contains critical information for each link. More information can easily be added, but for now, it shows the status of the link (just like the main Link status indicator in the strip), the current ping time, and the rate of received messages. So if one link is lost, it's status indicator will turn red and start counting up just like link 2 in the above screenshot.
Line 73:		Line 75:
	Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:		Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:

	[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|500px\|Paparazzi Ground Segment]]		[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|500px\|thumb\|center\|Paparazzi Ground Segment]]
			<br style="clear:both">

	The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:		The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:

	[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|800px\|Paparazzi Ground Segment with Redundant Links]]		[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|800px\|thumb\|center\|Paparazzi Ground Segment with Redundant Links]]
			<br style="clear:both">


Line 87:		Line 91:
	The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:		The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:

	[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|500px\|Algorithm to prevent duplicate messages]]		[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|500px\|thumb\|center\|Algorithm to prevent duplicate messages]]
			<br style="clear:both">

	====Algorithm Considerations====		====Algorithm Considerations====

Camlee at 05:25, 28 April 2013

2013-04-28T05:25:18Z

← Older revision		Revision as of 23:25, 27 April 2013
Line 53:		Line 53:
	The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:		The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:

	[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|700px]]		[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|700px\|The Agents Running in a Redundant Link Setup]]

	The Agents Running in a Redundant Link Setup

	* Test the system and make sure that it works correctly under all circumstances. Do this before flying. In particular, make sure that the buffer size if appropriate. Take a look at the [[#Algorithm Considerations\|Algorithm Considerations]] section for details.		* Test the system and make sure that it works correctly under all circumstances. Do this before flying. In particular, make sure that the buffer size if appropriate. Take a look at the [[#Algorithm Considerations\|Algorithm Considerations]] section for details.
Line 75:		Line 73:
	Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:		Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:

	[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|500px]]		[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|500px\|Paparazzi Ground Segment]]

	~~Paparazzi Ground Segment~~		The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:

	~~The ivy bus lets the programs talk to each other through the use of short messages~~. ~~Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block~~ diagram of the redundant ~~link system:~~		[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|800px\|Paparazzi Ground Segment with Redundant Links]]

	~~[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|800px]]~~
	~~Paparazzi Ground Segment with Redundant Links~~

	Here we can see the new agent, the Link Combiner. We also see multiple occurrences of the Link agent. When operating in redundant mode, each occurrence of Link transmits the data it receives from the aircraft to the Link Combiner instead of the Server. It does this by transmitting the received telemetry messages within the TELEMETRY_MESSAGE message which the Server doesn't listen to. The Link Combiner on the other hand does. TELEMETRY_MESSAGE messages are sent by each link and include the id of that link. The Link Combiner listens to all of them and then transmits a single set of messages to the Server with the combined data. This results in the Server and all other ground segment agents (such as Messages and the Real Time Plotter) getting their telemetry data from Link Combiner as if it was coming from a single occurrence of Link.		Here we can see the new agent, the Link Combiner. We also see multiple occurrences of the Link agent. When operating in redundant mode, each occurrence of Link transmits the data it receives from the aircraft to the Link Combiner instead of the Server. It does this by transmitting the received telemetry messages within the TELEMETRY_MESSAGE message which the Server doesn't listen to. The Link Combiner on the other hand does. TELEMETRY_MESSAGE messages are sent by each link and include the id of that link. The Link Combiner listens to all of them and then transmits a single set of messages to the Server with the combined data. This results in the Server and all other ground segment agents (such as Messages and the Real Time Plotter) getting their telemetry data from Link Combiner as if it was coming from a single occurrence of Link.
Line 91:		Line 87:
	The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:		The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:

	[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|500px]]		[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|500px\|Algorithm to prevent duplicate messages]]

	Algorithm to prevent duplicate messages

	====Algorithm Considerations====		====Algorithm Considerations====

Camlee at 05:22, 28 April 2013

2013-04-28T05:22:23Z

← Older revision		Revision as of 23:22, 27 April 2013
Line 81:		Line 81:
	The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:		The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:

	[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|~~1000px~~]]		[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|800px]]
	Paparazzi Ground Segment with Redundant Links		Paparazzi Ground Segment with Redundant Links

Line 91:		Line 91:
	The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:		The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:

	[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|~~300px~~]]		[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|500px]]

	Algorithm to prevent duplicate messages		Algorithm to prevent duplicate messages

Camlee at 05:20, 28 April 2013

2013-04-28T05:20:33Z

← Older revision		Revision as of 23:20, 27 April 2013
Line 53:		Line 53:
	The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:		The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:

	[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|~~1000px~~]]		[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|700px]]

	The Agents Running in a Redundant Link Setup		The Agents Running in a Redundant Link Setup
Line 75:		Line 75:
	Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:		Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:

	[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|~~1000px~~]]		[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|500px]]

	Paparazzi Ground Segment		Paparazzi Ground Segment

Line 90:		Line 91:
	The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:		The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:

	[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|~~1000px~~]]		[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|300px]]

	Algorithm to prevent duplicate messages		Algorithm to prevent duplicate messages

Camlee at 05:18, 28 April 2013

2013-04-28T05:18:55Z

Camlee at 05:14, 28 April 2013

2013-04-28T05:14:42Z

← Older revision		Revision as of 23:18, 27 April 2013
Line 53:		Line 53:
	The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:		The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:

	[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|~~upright=0.2~~]]		[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|1000px]]

	The Agents Running in a Redundant Link Setup		The Agents Running in a Redundant Link Setup
Line 63:		Line 63:

	The following screenshot clearly shows these changes:		The following screenshot clearly shows these changes:
	[[File:redundant_link_gcs.png\|alt=Changes to the GCS when redundant links are used\|~~upright=0.1~~]]		[[File:redundant_link_gcs.png\|alt=Changes to the GCS when redundant links are used\|1000px]]

	Firstly, we can see that there is a new page in the notebook named Link. This page contains critical information for each link. More information can easily be added, but for now, it shows the status of the link (just like the main Link status indicator in the strip), the current ping time, and the rate of received messages. So if one link is lost, it's status indicator will turn red and start counting up just like link 2 in the above screenshot.		Firstly, we can see that there is a new page in the notebook named Link. This page contains critical information for each link. More information can easily be added, but for now, it shows the status of the link (just like the main Link status indicator in the strip), the current ping time, and the rate of received messages. So if one link is lost, it's status indicator will turn red and start counting up just like link 2 in the above screenshot.
Line 75:		Line 75:
	Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:		Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:

	[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|~~upright=0.1~~]]		[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|1000px]]
	Paparazzi Ground Segment		Paparazzi Ground Segment

	The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:		The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:

	[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|~~upright=0.1~~]]		[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|1000px]]
	Paparazzi Ground Segment with Redundant Links		Paparazzi Ground Segment with Redundant Links

Line 90:		Line 90:
	The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:		The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:

	[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|~~upright=0.1~~]]		[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|1000px]]

	Algorithm to prevent duplicate messages		Algorithm to prevent duplicate messages

← Older revision		Revision as of 23:14, 27 April 2013
Line 53:		Line 53:
	The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:		The following screenshot shows a session with two links, connected to serial ports ttyUSB0 and ttyUSB1, and with id's 1 and 2:

	[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|upright=0.5]]		[[File:redundant_session.png\|alt=Agents in Redundant Link Session\|upright=0.2]]

	The Agents Running in a Redundant Link Setup		The Agents Running in a Redundant Link Setup
Line 63:		Line 63:

	The following screenshot clearly shows these changes:		The following screenshot clearly shows these changes:
	[[File:redundant_link_gcs.png\|alt=Changes to the GCS when redundant links are used\|upright=0.25]]		[[File:redundant_link_gcs.png\|alt=Changes to the GCS when redundant links are used\|upright=0.1]]

	Firstly, we can see that there is a new page in the notebook named Link. This page contains critical information for each link. More information can easily be added, but for now, it shows the status of the link (just like the main Link status indicator in the strip), the current ping time, and the rate of received messages. So if one link is lost, it's status indicator will turn red and start counting up just like link 2 in the above screenshot.		Firstly, we can see that there is a new page in the notebook named Link. This page contains critical information for each link. More information can easily be added, but for now, it shows the status of the link (just like the main Link status indicator in the strip), the current ping time, and the rate of received messages. So if one link is lost, it's status indicator will turn red and start counting up just like link 2 in the above screenshot.
Line 75:		Line 75:
	Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:		Here's a block diagram showing how the aircraft talks to the various ground segment programs (also known as agents) when not using the redundant link system:

	[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|upright=0.25]]		[[File:ground_segment_block_diagram.png\|alt=Block diagram of agents in the ground segment\|upright=0.1]]
	Paparazzi Ground Segment		Paparazzi Ground Segment

	The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:		The ivy bus lets the programs talk to each other through the use of short messages. Pay close attention to the coloured arrows, which show the main flow of these messages. Next we have a block diagram of the redundant link system:

	[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|upright=0.25]]		[[File:redundant_links_block_diagram.png\|alt=Block diagram of agents in the ground segment when redundant links are used\|upright=0.1]]
	Paparazzi Ground Segment with Redundant Links		Paparazzi Ground Segment with Redundant Links

Line 90:		Line 90:
	The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:		The algorithm gives each link a circular buffer to store the last N messages. When a new message comes in on a particular link, the algorithm first checks if it's already in that link's buffer. If it is, then it's obviously a new message, so its removed from all of the other buffers if it's in any of them. Then, the message is sent to the other agents. If the message isn't already in the link's buffer, then it's added to the buffer. After that, all of the other link's buffers are checked for the message. If it's in any of them, then the message was already received by another link, so isn't sent. If it's not in any of them, then the message is sent. The following flowchart depicts this algorithm:

	[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|upright=0.25]]		[[File:link_combiner_flowchart.png\|alt=Flowchart of the Link Combiner\|upright=0.1]]

	Algorithm to prevent duplicate messages		Algorithm to prevent duplicate messages