Compiling, but format is wrong

See todos in format_command and parse_packet.

groundStation/src/backend/backend.c

@@ -277,15 +277,14 @@ void sendStartPacket() {
 	metadata_t metadata = 
 	{
 		(char) BEGIN_CHAR,
-		0x04,
-		0x01,
-		0x01,
+		BEGINUPDATE_ID,
+		1,
 		0
 	};
 
 	packet[0] = metadata.begin_char; // BEGIN					//PACKET_START_BYTE;
-	packet[1] = metadata.msg_type;	// UPDATE				//'U'; // U for vrpn camera update, C for command
-	packet[2] = metadata.msg_subtype; // BEGIN UPDATE
+	packet[1] = metadata.msg_type & 0xff;	// UPDATE				//'U'; // U for vrpn camera update, C for command
+	packet[2] = (metadata.msg_type >> 8) & 0xff; // BEGIN UPDATE
 	packet[3] = (currMessageID & 0x000000ff); 			// MSG ID(1)
 	packet[4] =	((currMessageID >> 8) & 0x000000ff); // MSG ID(2)
 	packet[5] = 0; 			// DATALEN(1)
@@ -733,7 +732,13 @@ static void quad_recv() {
 
 	if (validPacket == 0) {
 		/* At least enough data read to check checksum, and it was good!*/
-		char * cmdText = MessageTypes[(int)metadata.msg_type].subtypes[(int)metadata.msg_subtype].cmdText;
+		char * cmdText = MessageTypes[(int)metadata.msg_type].cmdText;
+
+		/* TODO: Parse data correctly
+		 *  - Switch on msg_type
+		 *     - Parse data appropriately and format into a string
+		 *  - Send append data string to cmdText and send to clients
+		 */
 		float value = getFloat((unsigned char *)respBuf, 7);
 		//printf("Quad : %s, %lf\n", cmdText, value);
 

groundStation/src/backend/callbacks.h

@@ -8,4 +8,6 @@
 typedef void (command_cb)(unsigned char *command, 
 		int dataLen, modular_structs_t *structs);
 
+float getFloat(unsigned char * str, int pos);
+
 #endif /* __CALLBACKS_H */

groundStation/src/backend/communication.c

@@ -63,77 +63,79 @@ int formatCommand(char *command, unsigned char **formattedCommand) {
 	int intValue = 0;
 	int valid;
 	metadata_t metadata;
-	
+
 	// ----------------------------------------------
 	if(tokens.numTokens > 0) {
-		for(int type = 0; type < MAX_TYPE; type++)
+		for(int type = 0; type < MAX_TYPE_ID; type++)
 		{
-			for(int subtype = 0; subtype < MAX_SUBTYPE; subtype++)
+			if(strcmp(tokens.tokens[0], MessageTypes[type].cmdText) == 0)
 			{
-				if(strcmp(tokens.tokens[0], MessageTypes[type].subtypes[subtype].cmdText) == 0)
+				printf("Sending\n\ttype: %d, \n\tcommand: %s\n", type, MessageTypes[type].cmdText);
+				/* TODO: Format data correctly
+				 * - Switch on Type instead of cmdDataType
+				 * - Implement a case for every type
+				 * 	- Format the tokens as appropriate for the type,
+				 *   	  based on the quad's callbacks.c.
+				 *   	- Pass the formatted tokens and metadata into
+				 *   	  formatPacket
+				 * - Purge cmdDataType from existence
+				 */
+				// Make sure the second token is the right type
+				switch (MessageTypes[type].cmdDataType)
 				{
-					printf("Sending\n\ttype: %d, \n\tsubtype: %d\n\tcommand: %s\n", type, subtype, MessageTypes[type].subtypes[subtype].cmdText);
-					
-					// Make sure the second token is the right type
-					switch (MessageTypes[type].subtypes[subtype].cmdDataType)
-					{
-						// Validate the float input
-						case floatType:
-							metadata.begin_char = (char) BEGIN_CHAR;
-							metadata.msg_type = MessageTypes[type].ID;
-							metadata.msg_subtype = MessageTypes[type].subtypes[subtype].ID;
-
-							if(MessageTypes[type].ID == 0x01) {
-								valid = checkFloat(tokens.tokens[1], &floatValue);
-								if(!valid) {
-									return -1;
-								}
-								metadata.data_len = sizeof(floatValue);
-							} else {
-								metadata.data_len = 0;
+					// Validate the float input
+					case floatType:
+						metadata.begin_char = (char) BEGIN_CHAR;
+						metadata.msg_type = type;
+
+						if(type == 0x01) {
+							valid = checkFloat(tokens.tokens[1], &floatValue);
+							if(!valid) {
+								return -1;
 							}
-							
-							metadata.msg_id = msgNum++;
-							formatPacket(&metadata, &floatValue, formattedCommand);
-							break;
-						
+							metadata.data_len = sizeof(floatValue);
+						} else {
+							metadata.data_len = 0;
+						}
+
+						metadata.msg_id = msgNum++;
+						formatPacket(&metadata, &floatValue, formattedCommand);
+						break;
+
 						// Validate the integer input
-						case intType:
-							metadata.begin_char = (char) BEGIN_CHAR;
-							metadata.msg_type = MessageTypes[type].ID;
-							metadata.msg_subtype = MessageTypes[type].subtypes[subtype].ID;
-							
-							if(MessageTypes[type].ID == 0x01) {
-								valid = checkInt(tokens.tokens[1], &intValue);
-								if(!valid) {
-									return -1;
-								}
-								metadata.data_len = sizeof(intValue);
-							} else {
-								metadata.data_len = 0;
+					case intType:
+						metadata.begin_char = (char) BEGIN_CHAR;
+						metadata.msg_type = type;
+
+						if(type == 0x01) {
+							valid = checkInt(tokens.tokens[1], &intValue);
+							if(!valid) {
+								return -1;
 							}
-							
-							metadata.msg_id = msgNum++;
-							formatPacket(&metadata, &intValue, formattedCommand);
-							
-							break;
-						
+							metadata.data_len = sizeof(intValue);
+						} else {
+							metadata.data_len = 0;
+						}
+
+						metadata.msg_id = msgNum++;
+						formatPacket(&metadata, &intValue, formattedCommand);
+
+						break;
+
 						// Validate the string input (doesn't need to happen)
-						case stringType:
-							metadata.begin_char = (char) BEGIN_CHAR;
-							metadata.msg_type = MessageTypes[type].ID;
-							metadata.msg_subtype = MessageTypes[type].subtypes[subtype].ID;
-							metadata.msg_id = msgNum++;
-							metadata.data_len = strlen(tokens.tokens[1]);
-							
-							formatPacket(&metadata, &tokens.tokens[1], formattedCommand);
-							
-							break;
-						default:
-							return -1;
-					}
-					return 0;
+					case stringType:
+						metadata.begin_char = (char) BEGIN_CHAR;
+						metadata.msg_type = type;
+						metadata.msg_id = msgNum++;
+						metadata.data_len = strlen(tokens.tokens[1]);
+
+						formatPacket(&metadata, &tokens.tokens[1], formattedCommand);
+
+						break;
+					default:
+						return -1;
 				}
+				return 0;
 			}
 		}
 	}
@@ -150,30 +152,28 @@ int formatPacket(metadata_t *metadata, void *data, unsigned char **formattedComm
 	//----------------------------------------------------------------------------------------------
 	//	   index||	   0	|	  1	   |	  2		 |	3 & 4 |		 5 & 6		 |	7+	|	end	   |
 	//---------------------------------------------------------------------------------------------|
-	// msg param|| beg char | msg type | msg subtype | msg id | data len (bytes) | data | checksum |
+	// msg param|| beg char |               msg type       | msg id | data len (bytes) | data | checksum |
 	//-------------------------------------------------------------------------------------------- |
 	//	   bytes||	   1	|	  1	   |	  1		 |	  2	  |		   2		 | var	|	 1	   |
 	//----------------------------------------------------------------------------------------------
-	
+
 	// Begin Char:
 	(*formattedCommand)[0] = metadata->begin_char;
 
 	// Msg type:
 	(*formattedCommand)[1] = metadata->msg_type;
-	
-	// Msg subtype
-	(*formattedCommand)[2] = metadata->msg_subtype;
-	
+	(*formattedCommand)[2] = ((metadata->msg_type >> 8) & 0x000000ff);
+
 	//Msg id (msgNum is 2 bytes)
 	(*formattedCommand)[3] = (metadata->msg_id & 0x000000ff);
 	(*formattedCommand)[4] = ((metadata->msg_id >> 8) & 0x000000ff);
-	
+
 	// Data length and data - bytes 5&6 for len, 7+ for data
 	(*formattedCommand)[5] = metadata->data_len & 0x000000ff;
 	(*formattedCommand)[6] = (metadata->data_len >> 8) & 0x000000ff;
-	
+
 	memcpy(&((*formattedCommand)[7]), data, metadata->data_len);
-	
+
 	// Checksum
 	// receive data and calculate checksum
 	int i;
@@ -182,9 +182,9 @@ int formatPacket(metadata_t *metadata, void *data, unsigned char **formattedComm
 	{
 		data_checksum ^= (*formattedCommand)[i];
 	}
-	
+
 	(*formattedCommand)[7 + metadata->data_len] = data_checksum;
-	
+
 	return 0;
 }
 
@@ -201,26 +201,25 @@ int parse_packet(unsigned char * packet, unsigned char ** data, metadata_t * met
 	//----------------------------------------------------------------------------------------------
 	//     index||     0    |     1    |      2      |  3 & 4 |      5 & 6       |  7+  |   end    |
 	//---------------------------------------------------------------------------------------------|
-	// msg param|| beg char | msg type | msg subtype | msg id | data len (bytes) | data | checksum |
+	// msg param|| beg char |           msg type     | msg id | data len (bytes) | data | checksum |
 	//-------------------------------------------------------------------------------------------- |
 	//     bytes||     1    |     1    |      1      |    2   |        2         | var  |    1     |
 	//----------------------------------------------------------------------------------------------	
-	
+
 	// first byte must be the begin char
 	if(packet[0] != 0xBE)
 		return -1;
 
 	// receive metadata
 	meta_data->begin_char = packet[0];
-	meta_data->msg_type = packet[1];
-	meta_data->msg_subtype = packet[2];
+	meta_data->msg_type = packet[2] << 8 | packet[1];
 	meta_data->msg_id = (packet[4] << 8) | (packet[3]);
 	meta_data->data_len = (packet[6] << 8) | (packet[5]);
 	unsigned char packet_checksum = packet[7+meta_data->data_len];
 	//fprintf(stderr, "datalen: %d\n", meta_data->data_len);
-	
+
 	int i;
-	
+
 	// receive data
 	*data = malloc(meta_data->data_len);
 	for(i = 0; i < meta_data->data_len; i++)
@@ -243,30 +242,25 @@ int parse_packet(unsigned char * packet, unsigned char ** data, metadata_t * met
 	return 0;
 }
 
-// QUAD & Ground Station
 // Process the command received
 int processCommand(unsigned char *packet, modular_structs_t *structs) {
 	int validPacket;
 	unsigned char *data;
 	metadata_t metadata;
-	
+
 	// Validate the message is correctly formatted
 	validPacket = parse_packet(packet, &data, &metadata);
 	if(validPacket != 0) {
 		return -1;
 	}
-	
+
 	if(metadata.data_len >= 0) {
-		/* Null check*/
-		if (MessageTypes[(unsigned char)metadata.msg_type].subtypes[
-				(unsigned char) metadata.msg_subtype].functionPtr) {
-			// Call the appropriate subtype function
-			(* (MessageTypes[(unsigned char)metadata.msg_type].subtypes[(unsigned char)metadata.msg_subtype].functionPtr))(data, metadata.data_len, structs);
-		}
-			
+		(* (MessageTypes[(unsigned char)metadata.msg_type].functionPtr))(
+				data, metadata.data_len, structs);
+
 		return 0;
 	}
-	
+
 	// Only gets here if there is an error
 	return -1;
 }

groundStation/src/backend/type_def.h

@@ -27,8 +27,7 @@ enum flight_mode{
 //----------------------------------------------------------------------------------------------
 typedef struct {
 	char begin_char;
-	char msg_type;
-	char msg_subtype;
+	int msg_type;
 	int msg_id;
 	int data_len;
 } metadata_t;