X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FNetwork%2Fgeneric.cxx;h=423d2be189b28ffec2de641415dc99ab3b1bdcfb;hb=ae50c054a9007b98f1a8dafe6d589d0b4cab8873;hp=09cefa4a6a4f20087f5c1b28869c6d8b717c060a;hpb=36f8519973a67caf566a92f65dccf7b4bc87218f;p=flightgear.git diff --git a/src/Network/generic.cxx b/src/Network/generic.cxx index 09cefa4a6..423d2be18 100644 --- a/src/Network/generic.cxx +++ b/src/Network/generic.cxx @@ -45,7 +45,7 @@ FGGeneric::FGGeneric(vector tokens) : exitOnError(false) { - int configToken; + size_t configToken; if (tokens[1] == "socket") { configToken = 7; } else if (tokens[1] == "file") { @@ -54,303 +54,356 @@ FGGeneric::FGGeneric(vector tokens) : exitOnError(false) configToken = 6; } - string config = tokens[ configToken ]; - string file = config+".xml"; - - SGPath path( globals->get_fg_root() ); - path.append("Protocol"); - path.append(file.c_str()); - SG_LOG(SG_GENERAL, SG_INFO, "Reading communication protocol from " - << path.str()); - - SGPropertyNode root; - try { - readProperties(path.str(), &root); - } catch (const sg_exception &e) { - SG_LOG(SG_GENERAL, SG_ALERT, - "Unable to load the protocol configuration file"); - return; + if (configToken >= tokens.size()) { + SG_LOG(SG_GENERAL, SG_ALERT, + "Not enough tokens passed for generic protocol"); + return; } - if (tokens[2] == "out") { - SGPropertyNode *output = root.getNode("generic/output"); - if (output) { - read_config(output, _out_message); - } - } else if (tokens[2] == "in") { - SGPropertyNode *input = root.getNode("generic/input"); - if (input) { - read_config(input, _in_message); - } - } else { + string config = tokens[ configToken ]; + file_name = config+".xml"; + direction = tokens[2]; + + if (direction != "in" && direction != "out") { SG_LOG(SG_GENERAL, SG_ALERT, "Unsuported protocol direction: " - << tokens[2]); + << direction); } + + reinit(); } FGGeneric::~FGGeneric() { } +union u32 { + uint32_t intVal; + float floatVal; +}; + +union u64 { + uint64_t longVal; + double doubleVal; +}; // generate the message -bool FGGeneric::gen_message() { +bool FGGeneric::gen_message_binary() { string generic_sentence; - char tmp[255]; length = 0; double val; for (unsigned int i = 0; i < _out_message.size(); i++) { - if (i > 0 && !binary_mode) - generic_sentence += var_separator; - switch (_out_message[i].type) { case FG_INT: val = _out_message[i].offset + _out_message[i].prop->getIntValue() * _out_message[i].factor; - if (binary_mode) { - if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { - *((int32_t*)&buf[length]) = (int32_t)val; - } else { - *((uint32_t*)&buf[length]) = sg_bswap_32((uint32_t)val); - } - length += sizeof(int32_t); + + if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { + *((int32_t*)&buf[length]) = (int32_t)val; } else { - snprintf(tmp, 255, _out_message[i].format.c_str(), (int)val); + *((uint32_t*)&buf[length]) = sg_bswap_32((uint32_t)val); } + length += sizeof(int32_t); break; case FG_BOOL: - if (binary_mode) { - *((int8_t*)&buf[length]) - = _out_message[i].prop->getBoolValue() ? true : false; - length += 1; - } else { - snprintf(tmp, 255, _out_message[i].format.c_str(), - _out_message[i].prop->getBoolValue()); - } + *((int8_t*)&buf[length]) + = _out_message[i].prop->getBoolValue() ? true : false; + length += 1; break; case FG_FIXED: + { val = _out_message[i].offset + - _out_message[i].prop->getFloatValue() * _out_message[i].factor; - if (binary_mode) { - int fixed = (int)(val * 65536.0f); - if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { - *((int32_t*)&buf[length]) = (int32_t)fixed; - } else { - *((uint32_t*)&buf[length]) = sg_bswap_32((uint32_t)val); - } - length += sizeof(int32_t); + _out_message[i].prop->getFloatValue() * _out_message[i].factor; + + int fixed = (int)(val * 65536.0f); + if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { + *((int32_t*)&buf[length]) = (int32_t)fixed; } else { - snprintf(tmp, 255, _out_message[i].format.c_str(), (float)val); - } + *((uint32_t*)&buf[length]) = sg_bswap_32((uint32_t)fixed); + } + length += sizeof(int32_t); break; - + } case FG_FLOAT: val = _out_message[i].offset + - _out_message[i].prop->getFloatValue() * _out_message[i].factor; - if (binary_mode) { - if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { - *((float*)&buf[length]) = val; - } else { - *((float*)&buf[length]) = sg_bswap_32(*(uint32_t*)&val); - } - length += sizeof(int32_t); + _out_message[i].prop->getFloatValue() * _out_message[i].factor; + + if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { + *((float*)&buf[length]) = val; } else { - snprintf(tmp, 255, _out_message[i].format.c_str(), (float)val); + u32 tmpun32; + tmpun32.floatVal = static_cast(val); + *((uint32_t*)&buf[length]) = sg_bswap_32(tmpun32.intVal); } + length += sizeof(uint32_t); break; case FG_DOUBLE: val = _out_message[i].offset + - _out_message[i].prop->getFloatValue() * _out_message[i].factor; - if (binary_mode) { - if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { - *((double*)&buf[length]) = val; - } else { - *((double*)&buf[length]) = sg_bswap_64(*(uint64_t*)&val); - } - length += sizeof(int64_t); + _out_message[i].prop->getFloatValue() * _out_message[i].factor; + + if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { + *((double*)&buf[length]) = val; } else { - snprintf(tmp, 255, _out_message[i].format.c_str(), (float)val); + u64 tmpun64; + tmpun64.doubleVal = val; + *((uint64_t*)&buf[length]) = sg_bswap_64(tmpun64.longVal); } + length += sizeof(int64_t); break; default: // SG_STRING - if (binary_mode) { - const char *strdata = _out_message[i].prop->getStringValue(); - int strlength = strlen(strdata); + const char *strdata = _out_message[i].prop->getStringValue(); + int strlength = strlen(strdata); - if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { - SG_LOG( SG_IO, SG_ALERT, "Generic protocol: " - "FG_STRING will be written in host byte order."); - } - /* Format for strings is - * [length as int, 4 bytes][ASCII data, length bytes] - */ - if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { - *((int32_t*)&buf[length]) = strlength; - } else { - *((int32_t*)&buf[length]) = sg_bswap_32(strlength); - } - length += sizeof(int32_t); - strncpy(&buf[length], strdata, strlength); - length += strlength; - /* FIXME padding for alignment? Something like: - * length += (strlength % 4 > 0 ? sizeof(int32_t) - strlength % 4 : 0; - */ + if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { + SG_LOG( SG_IO, SG_ALERT, "Generic protocol: " + "FG_STRING will be written in host byte order."); + } + /* Format for strings is + * [length as int, 4 bytes][ASCII data, length bytes] + */ + if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { + *((int32_t*)&buf[length]) = strlength; } else { - snprintf(tmp, 255, _out_message[i].format.c_str(), - _out_message[i].prop->getStringValue()); + *((int32_t*)&buf[length]) = sg_bswap_32(strlength); } + length += sizeof(int32_t); + strncpy(&buf[length], strdata, strlength); + length += strlength; + /* FIXME padding for alignment? Something like: + * length += (strlength % 4 > 0 ? sizeof(int32_t) - strlength % 4 : 0; + */ } + } + + // add the footer to the packet ("line") + switch (binary_footer_type) { + case FOOTER_LENGTH: + binary_footer_value = length; + break; + + case FOOTER_MAGIC: + case FOOTER_NONE: + break; + } - if (!binary_mode) { - generic_sentence += tmp; + if (binary_footer_type != FOOTER_NONE) { + if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { + *((int32_t*)&buf[length]) = binary_footer_value; + } else { + *((int32_t*)&buf[length]) = sg_bswap_32(binary_footer_value); } + length += sizeof(int32_t); } - if (!binary_mode) { - /* After each lot of variables has been added, put the line separator - * char/string - */ - generic_sentence += line_separator; + return true; +} - length = generic_sentence.length(); - strncpy( buf, generic_sentence.c_str(), length ); - } else { - // add the footer to the packet ("line") - switch (binary_footer_type) { - case FOOTER_LENGTH: - binary_footer_value = length; - break; - - case FOOTER_MAGIC: - break; +bool FGGeneric::gen_message_ascii() { + string generic_sentence; + char tmp[255]; + length = 0; + + double val; + for (unsigned int i = 0; i < _out_message.size(); i++) { + + if (i > 0) { + generic_sentence += var_separator; } - if (binary_footer_type != FOOTER_NONE) { - if (binary_byte_order == BYTE_ORDER_MATCHES_NETWORK_ORDER) { - *((int32_t*)&buf[length]) = binary_footer_value; - } else { - *((int32_t*)&buf[length]) = sg_bswap_32(binary_footer_value); - } - length += sizeof(int32_t); + + switch (_out_message[i].type) { + case FG_INT: + val = _out_message[i].offset + + _out_message[i].prop->getIntValue() * _out_message[i].factor; + snprintf(tmp, 255, _out_message[i].format.c_str(), (int)val); + break; + + case FG_BOOL: + snprintf(tmp, 255, _out_message[i].format.c_str(), + _out_message[i].prop->getBoolValue()); + break; + + case FG_FIXED: + val = _out_message[i].offset + + _out_message[i].prop->getFloatValue() * _out_message[i].factor; + snprintf(tmp, 255, _out_message[i].format.c_str(), (float)val); + break; + + case FG_FLOAT: + val = _out_message[i].offset + + _out_message[i].prop->getFloatValue() * _out_message[i].factor; + snprintf(tmp, 255, _out_message[i].format.c_str(), (float)val); + break; + + case FG_DOUBLE: + val = _out_message[i].offset + + _out_message[i].prop->getDoubleValue() * _out_message[i].factor; + snprintf(tmp, 255, _out_message[i].format.c_str(), (double)val); + break; + + default: // SG_STRING + snprintf(tmp, 255, _out_message[i].format.c_str(), + _out_message[i].prop->getStringValue()); } + + generic_sentence += tmp; } + /* After each lot of variables has been added, put the line separator + * char/string + */ + generic_sentence += line_separator; + + length = generic_sentence.length(); + strncpy( buf, generic_sentence.c_str(), length ); + return true; } -bool FGGeneric::parse_message() { +bool FGGeneric::gen_message() { + if (binary_mode) { + return gen_message_binary(); + } else { + return gen_message_ascii(); + } +} + +bool FGGeneric::parse_message_binary() { char *p2, *p1 = buf; + int32_t tmp32; double val; int i = -1; - if (!binary_mode) { - while ((++i < (int)_in_message.size()) && - p1 && strcmp(p1, line_separator.c_str())) { + p2 = p1 + FG_MAX_MSG_SIZE; + while ((++i < (int)_in_message.size()) && (p1 < p2)) { - p2 = strstr(p1, var_separator.c_str()); - if (p2) { - *p2 = 0; - p2 += var_separator.length(); + switch (_in_message[i].type) { + case FG_INT: + if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { + tmp32 = sg_bswap_32(*(int32_t *)p1); + } else { + tmp32 = *(int32_t *)p1; } - switch (_in_message[i].type) { - case FG_INT: - val = _in_message[i].offset + atoi(p1) * _in_message[i].factor; - _in_message[i].prop->setIntValue((int)val); - break; + val = _in_message[i].offset + (double)tmp32 * _in_message[i].factor; - case FG_BOOL: - _in_message[i].prop->setBoolValue( atof(p1) != 0.0 ); - break; + _in_message[i].prop->setIntValue((int)val); + p1 += sizeof(int32_t); + break; - case FG_FIXED: - case FG_DOUBLE: - val = _in_message[i].offset + strtod(p1, 0) * _in_message[i].factor; - _in_message[i].prop->setFloatValue((float)val); - break; + case FG_BOOL: + _in_message[i].prop->setBoolValue( p1[0] != 0 ); + p1 += 1; + break; - default: // SG_STRING - _in_message[i].prop->setStringValue(p1); + case FG_FIXED: + if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { + tmp32 = sg_bswap_32(*(int32_t *)p1); + } else { + tmp32 = *(int32_t *)p1; } - p1 = p2; - } - } else { - /* Binary mode */ - int64_t tmp; + val = _in_message[i].offset + + ((double)tmp32 / 65536.0f) * _in_message[i].factor; - while ((++i < (int)_in_message.size()) && - (p1 - buf < FG_MAX_MSG_SIZE)) { + _in_message[i].prop->setFloatValue(val); + p1 += sizeof(int32_t); + break; - switch (_in_message[i].type) { - case FG_INT: - if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { - tmp = sg_bswap_32(*(int32_t *)p1); - } else { - tmp = *(int32_t *)p1; - } - val = _in_message[i].offset + - (double)tmp * - _in_message[i].factor; - _in_message[i].prop->setIntValue((int)val); - p1 += sizeof(int32_t); - break; - - case FG_BOOL: - _in_message[i].prop->setBoolValue( p1[0] != 0 ); - p1 += 1; - break; - - case FG_FIXED: - if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { - tmp = sg_bswap_32(*(int32_t *)p1); - } else { - tmp = *(int32_t *)p1; - } - val = _in_message[i].offset + - ((double)tmp / 65536.0f) * _in_message[i].factor; - _in_message[i].prop->setFloatValue(val); - p1 += sizeof(int32_t); - break; - - case FG_FLOAT: - if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { - tmp = sg_bswap_32(*(int32_t *)p1); - } else { - tmp = *(int32_t *)p1; - } - val = _in_message[i].offset + - *(float *)&tmp * _in_message[i].factor; - _in_message[i].prop->setFloatValue(val); - p1 += sizeof(int32_t); - break; - - case FG_DOUBLE: - if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { - tmp = sg_bswap_64(*(int64_t *)p1); - } else { - tmp = *(int64_t *)p1; - } - val = _in_message[i].offset + - *(double *)&tmp * _in_message[i].factor; - _in_message[i].prop->setDoubleValue(val); - p1 += sizeof(int64_t); - break; + case FG_FLOAT: + u32 tmpun32; + if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { + tmpun32.intVal = sg_bswap_32(*(uint32_t *)p1); + } else { + tmpun32.floatVal = *(float *)p1; + } - default: // SG_STRING - SG_LOG( SG_IO, SG_ALERT, "Generic protocol: " - "Ignoring unsupported binary input chunk type."); + val = _in_message[i].offset + + tmpun32.floatVal * _in_message[i].factor; + + _in_message[i].prop->setFloatValue(val); + p1 += sizeof(int32_t); + break; + + case FG_DOUBLE: + u64 tmpun64; + if (binary_byte_order == BYTE_ORDER_NEEDS_CONVERSION) { + tmpun64.longVal = sg_bswap_64(*(uint64_t *)p1); + } else { + tmpun64.doubleVal = *(double *)p1; } + + val = _in_message[i].offset + + tmpun64.doubleVal * _in_message[i].factor; + + _in_message[i].prop->setDoubleValue(val); + p1 += sizeof(int64_t); + break; + + default: // SG_STRING + SG_LOG( SG_IO, SG_ALERT, "Generic protocol: " + "Ignoring unsupported binary input chunk type."); } } return true; } +bool FGGeneric::parse_message_ascii() { + char *p2, *p1 = buf; + double val; + int i = -1; + + while ((++i < (int)_in_message.size()) && + p1 && strcmp(p1, line_separator.c_str())) { + + p2 = strstr(p1, var_separator.c_str()); + if (p2) { + *p2 = 0; + p2 += var_separator.length(); + } + + switch (_in_message[i].type) { + case FG_INT: + val = _in_message[i].offset + atoi(p1) * _in_message[i].factor; + _in_message[i].prop->setIntValue((int)val); + break; + + case FG_BOOL: + _in_message[i].prop->setBoolValue( atof(p1) != 0.0 ); + break; + + case FG_FIXED: + case FG_FLOAT: + val = _in_message[i].offset + strtod(p1, 0) * _in_message[i].factor; + _in_message[i].prop->setFloatValue((float)val); + break; + + case FG_DOUBLE: + val = _in_message[i].offset + strtod(p1, 0) * _in_message[i].factor; + _in_message[i].prop->setDoubleValue(val); + break; + + default: // SG_STRING + _in_message[i].prop->setStringValue(p1); + } + + p1 = p2; + } + + return true; +} + +bool FGGeneric::parse_message() { + if (binary_mode) { + return parse_message_binary(); + } else { + return parse_message_ascii(); + } +} // open hailing frequencies @@ -392,39 +445,54 @@ bool FGGeneric::process() { goto error_out; } } else if ( get_direction() == SG_IO_IN ) { - if (!binary_mode) { - if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) { - parse_message(); + if ( io->get_type() == sgFileType ) { + if (!binary_mode) { + length = io->readline( buf, FG_MAX_MSG_SIZE ); + if ( length > 0 ) { + parse_message(); + } else { + SG_LOG( SG_IO, SG_ALERT, "Error reading data." ); + return false; + } } else { - SG_LOG( SG_IO, SG_ALERT, "Error reading data." ); - return false; - } - } else { - if ( (length = io->read( buf, binary_record_length )) > 0 ) { - if (length != binary_record_length) { + length = io->read( buf, binary_record_length ); + if ( length == binary_record_length ) { + parse_message(); + } else { SG_LOG( SG_IO, SG_ALERT, "Generic protocol: Received binary " "record of unexpected size, expected: " - << binary_record_length << "received: " + << binary_record_length << " but received: " << length); - } else { - SG_LOG( SG_IO, SG_DEBUG, - "Generic protocol: received record of " << length << - " bytes."); + } + } + } else { + if (!binary_mode) { + while ((length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) { parse_message(); } } else { - SG_LOG( SG_IO, SG_INFO, - "Generic protocol: Error reading data." ); - return false; + while ((length = io->read( buf, binary_record_length )) + == binary_record_length ) { + parse_message(); + } + + if ( length > 0 ) { + SG_LOG( SG_IO, SG_ALERT, + "Generic protocol: Received binary " + "record of unexpected size, expected: " + << binary_record_length << " but received: " + << length); + } } } } return true; error_out: - if (exitOnError) + if (exitOnError) { fgExit(1); - else + return true; // should not get there, but please the compiler + } else return false; } @@ -450,6 +518,41 @@ bool FGGeneric::close() { } +void +FGGeneric::reinit() +{ + SGPath path( globals->get_fg_root() ); + path.append("Protocol"); + path.append(file_name.c_str()); + + SG_LOG(SG_GENERAL, SG_INFO, "Reading communication protocol from " + << path.str()); + + SGPropertyNode root; + try { + readProperties(path.str(), &root); + } catch (const sg_exception &) { + SG_LOG(SG_GENERAL, SG_ALERT, + "Unable to load the protocol configuration file"); + return; + } + + if (direction == "out") { + SGPropertyNode *output = root.getNode("generic/output"); + if (output) { + _out_message.clear(); + read_config(output, _out_message); + } + } else if (direction == "in") { + SGPropertyNode *input = root.getNode("generic/input"); + if (input) { + _in_message.clear(); + read_config(input, _in_message); + } + } +} + + void FGGeneric::read_config(SGPropertyNode *root, vector<_serial_prot> &msg) { @@ -468,38 +571,41 @@ FGGeneric::read_config(SGPropertyNode *root, vector<_serial_prot> &msg) var_sep_string = fgUnescape(root->getStringValue("var_separator")); line_sep_string = fgUnescape(root->getStringValue("line_separator")); - if ( var_sep_string == "newline" ) - var_separator = '\n'; - else if ( var_sep_string == "tab" ) - var_separator = '\t'; - else if ( var_sep_string == "space" ) - var_separator = ' '; - else if ( var_sep_string == "formfeed" ) - var_separator = '\f'; - else if ( var_sep_string == "carriagereturn" ) - var_sep_string = '\r'; - else if ( var_sep_string == "verticaltab" ) - var_separator = '\v'; - else - var_separator = var_sep_string; - - if ( line_sep_string == "newline" ) - line_separator = '\n'; - else if ( line_sep_string == "tab" ) - line_separator = '\t'; - else if ( line_sep_string == "space" ) - line_separator = ' '; - else if ( line_sep_string == "formfeed" ) - line_separator = '\f'; - else if ( line_sep_string == "carriagereturn" ) - line_separator = '\r'; - else if ( line_sep_string == "verticaltab" ) - line_separator = '\v'; - else - line_separator = line_sep_string; + if ( var_sep_string == "newline" ) { + var_separator = '\n'; + } else if ( var_sep_string == "tab" ) { + var_separator = '\t'; + } else if ( var_sep_string == "space" ) { + var_separator = ' '; + } else if ( var_sep_string == "formfeed" ) { + var_separator = '\f'; + } else if ( var_sep_string == "carriagereturn" ) { + var_sep_string = '\r'; + } else if ( var_sep_string == "verticaltab" ) { + var_separator = '\v'; + } else { + var_separator = var_sep_string; + } + + if ( line_sep_string == "newline" ) { + line_separator = '\n'; + } else if ( line_sep_string == "tab" ) { + line_separator = '\t'; + } else if ( line_sep_string == "space" ) { + line_separator = ' '; + } else if ( line_sep_string == "formfeed" ) { + line_separator = '\f'; + } else if ( line_sep_string == "carriagereturn" ) { + line_separator = '\r'; + } else if ( line_sep_string == "verticaltab" ) { + line_separator = '\v'; + } else { + line_separator = line_sep_string; + } } else { - binary_footer_type = FOOTER_NONE; // default choice - binary_record_length = -1; // default choice = sizeof(representation) + // default values: no footer and record_length = sizeof(representation) + binary_footer_type = FOOTER_NONE; + binary_record_length = -1; // default choice is network byte order (big endian) if (sgIsLittleEndian()) { @@ -510,20 +616,23 @@ FGGeneric::read_config(SGPropertyNode *root, vector<_serial_prot> &msg) if ( root->hasValue("binary_footer") ) { string footer_type = root->getStringValue("binary_footer"); - if ( footer_type == "length" ) + if ( footer_type == "length" ) { binary_footer_type = FOOTER_LENGTH; - else if ( footer_type.substr(0, 5) == "magic" ) { + } else if ( footer_type.substr(0, 5) == "magic" ) { binary_footer_type = FOOTER_MAGIC; binary_footer_value = strtol(footer_type.substr(6, footer_type.length() - 6).c_str(), (char**)0, 0); - } else if ( footer_type != "none" ) + } else if ( footer_type != "none" ) { SG_LOG(SG_IO, SG_ALERT, - "generic protocol: Undefined generic binary protocol" - "footer, using no footer."); + "generic protocol: Unknown generic binary protocol " + "footer '" << footer_type << "', using no footer."); + } } + if ( root->hasValue("record_length") ) { binary_record_length = root->getIntValue("record_length"); } + if ( root->hasValue("byte_order") ) { string byte_order = root->getStringValue("byte_order"); if (byte_order == "network" ) { @@ -557,7 +666,10 @@ FGGeneric::read_config(SGPropertyNode *root, vector<_serial_prot> &msg) chunk.prop = fgGetNode(node.c_str(), true); string type = chunks[i]->getStringValue("type"); - if (type == "bool") { + + // Note: officially the type is called 'bool' but for backward + // compatibility 'boolean' will also be supported. + if (type == "bool" || type == "boolean") { chunk.type = FG_BOOL; record_length += 1; } else if (type == "float") { @@ -579,12 +691,14 @@ FGGeneric::read_config(SGPropertyNode *root, vector<_serial_prot> &msg) } - if (binary_record_length == -1) { - binary_record_length = record_length; - } else if (binary_record_length < record_length) { - SG_LOG(SG_IO, SG_ALERT, - "generic protocol: Requested binary record length shorter than" - " requested record representation."); - binary_record_length = record_length; + if( binary_mode ) { + if (binary_record_length == -1) { + binary_record_length = record_length; + } else if (binary_record_length < record_length) { + SG_LOG(SG_IO, SG_ALERT, + "generic protocol: Requested binary record length shorter than " + " requested record representation."); + binary_record_length = record_length; + } } }