Firstly because repeat is optional, it seems intuitive that this is the same as repeat=0. And that intuitively means the entry repeats 0 times, which means it appears 1 time in the container entry list. Likewise a repeat=1, means the entry appears 2 times and forth. This to me makes sense but maybe it doesn't.
The syntax right now is broad and would allow all sort of values including negative ones. It's not clear that that would be anything but an error.
Given all that we should say something about this in the annotation at the very least. And since FixedValue is a long we could change it to positive-only or perhaps non-negative. The DiscreteLookup value's type could also be modified (we'd have to make a "PositveOnlyDiscreteLookup" or some such). The last is a DynamicLookup and that would have to be enforced outside the syntax, we could imply it by calling it "PositiveOnlyDynamicLookup" or similar.
Finally add annotation.

Given that alarm consequence/significance labels are concepts and colors are implementations, should the XTCE schema refer to the colors by name? Perhaps it should refer to implementation of suggest AstroUX as a reference?

To align with other specifications within the OMG and AstroUXDS guidance, deprecate the watch and critical alarm severity levels.

For some reason this idea flew into my funnel this morning. I was looking at the ComparisonList and noticed the annotation to it said there's an implied 'and' between all the comparisons in the list.
I then thought: Why not add an attribute to override that to set to it all ORs? Why would that be a bad thing?
Unable to come up with any reason that this would be a bad thing, I decided it must be a good thing and that a good thing should be an issue.
The main reason to support the OR case is that it's simply a little easier to build out the comparisonlist than the booleanexpression. And one assumes that if it's a good thing to have an ANDed ComparisonList for convenience, that it seems like symmetrically speaking it would be a good thing to have ORed ComparisonList for conveniences as well. Basically this is just a suggested small change for the convenience purposes.

It is unclear in the documentation how it should be handled when a parameter defines a context alarm for which only a match element is provided. This is valid in the schema.

Not sure that specifying range form in a change alarm makes sense as the min/max are relative to the value itself. In addition, both exclusive and inclusive range values are allowed and that doesn't seem to make sense for exclusive.

FixedValueEntry has a hard coded hexBinary value that's supposed to be in "spacecraft order". There's a now optional name in 1.2.

ITOS and ASIST capture the same info slightly differently. The value is in human-readable form, (e.g "5331" or whatever it is that you can read and understand). But Bit/Byte order are provided as modifiers to the field/entry definition so that the software will do the right thing and encode it properly for the final destination on the spacecraft. ITOS/ASIST require the name and other associated the meta data for these fields.

So there's similarities overall between them but the encoding aspect is the key difference.

The upsides to their approach are (there may be more):

• when you see the definition, it makes some sense to you
• the software takes care of the encoding and in a way it is then documented as to what is the both the value is and how it's going to be encoded for the final destination.

The downsides are (could be more):

• well something will have to be done to see the final bit values ...
• there's more to write out to build the definition

Is there a case to be made to change, or modify the existing fixedvalueentry? What would the approach be?

1) maintain pure backwards compatibility: add a second variation "uservalueentry" that supplies it as described above and includes a local bit/byteorder
2) modify fixedavalueentry itself and keep a kind of conceptual compatibility...

What do you think?

The XTCE spec is not very clear on how the aggregate members can be referenced (for example in match criterias). The doc of AggregateParameterType reads:
"Each member may be addressed by the dot syntax similar to C such as P.voltage if P is the referring parameter and voltage is of a member of P’s aggregate type. See MemberType, MemberListType, DataEncodingType, NameReferenceType, and AggregateDataType".

However the definition of "NameReferenceType" is silent about aggregates and the "." (dot) character is not allowed to be used in a reference (except in the "./" where it denotes "current space system). The reference suggested above "P.voltage" is invalid.

In some examples over the internet references to aggregate members are found using standard "/" separator. However this is problematic because a reference like "/A/B/C" is ambiguous, could translate into:
A (space system)/B(space system)/C(parameter name)
or
A(space system)/B(parameter name)/C(aggregate member name)

Suggest to allow dot notation to reference aggregate members. Similarly allow "[idx]" to reference array indices.

For example a reference "/A/B.C[3]" can be unambiguously understood as:
A(space system)/B(parameter name).C(aggregate member name of type array) [3] (index in the C array)

Perhaps NameReferenceType can be made less restrictive or another type can be defined and used in the ParameterRefType definition.

RelativeTimeParamaterType static and change alarms are both TimeAlarmRangesType. At the very least it would be clearer if the ChangePerSecondRangeAlarm is its own type.
A simple solution would be to create a new type (TimeChangePerSecondRangeAlarmType) and have it extend TimeAlarmRangesType.
(Assuming that it's correct that both of these should describe alarms in the same using same underlying type.)

In addition to the clarity issues highlighted by XTCE13-30, the current definition of StringDataEncoding has a major drawback for variable strings: the VariableStringType enforces one of DynamicValueType or DiscreteLookupListType.

However the size of the string can be very well determined by the other two methods LeadingSize or TerminationChar. Usage of LeadingSize/TerminationChar in combination with the enforced DynamicValueType/DiscreteLookupListType does not make sense when the string fills completely the allocated buffer and so the size of the string determines the size of the buffer.

In my opinion having a variable size buffer with a variable string inside that buffer is much less common (never heard of it in fact) than having a fixed size buffer with a variable string inside or a variable string with no buffer (the buffer is the string).

Suggest to make the DynamicValueType/DiscreteLookupListType optional.

In data encoding definitions (currently only BinaryDataEncoding but see my other issue XTCE13-124), XTCE should allow the algorithm used in ToBinaryTransformAlgorithm and FromBinaryTransformAlgorithm to determine the size of the data on the wire.

Thus the SizeInBits which is currently mandatory should be made optional when an algorithm is used.

"There are eight different verifiers each associated with difference states in command processing"

ParameterToSet/Derivation is a MathOperationType which is abstract. Which means you can make an instance of it.

A simple fix is to make a DerivationType extending MathOperationType.

Missing the word, "of" between "instances" and "this" in "...Interlocks apply instead to any Commands that may follow instances this MetaCommand."

Currently the FromBinaryTransformAlgorithm/ToBinaryTransformAlgorithm are allowed only for BinaryDataEncodingType with the comment "Used to convert binary data from an application data type to binary data". However the binary data encoding is used to encode/decode binary data, so not any application data (float, integer, time,...).

We believe it is more beneficial to allow these algorithms to all data encoding types.

For example a FromBinaryTransformAlgorithm attached to a IntegerDataEncoding can extract a varint like the ones used in protobuf (https://developers.google.com/protocol-buffers/docs/encoding#varints).

Similarly a ToBinaryTransformAlgorithm attached to a FloatDataEncoding can be used to encode a floating point number in an exotic format; for example bfloat16 is commonly used in AI chips (https://en.wikipedia.org/wiki/Bfloat16_floating-point_format)

"There are eight different verifiers each associated with *difference* states in command processing"

Sometimes the constraints and/or verifies associated to a command may depend on the value of the arguments of the command sent. For example setting a thermostat to a certain setpoint may have a constraint which will only allow a given setpoint in a specific operational mode.
A verifier can compare the setpoint sent as command argument with the setpoint known in the spacecraft and received as a TM parameter.

To achieve this, arguments references should be allowed in the definition of the constraints/verifiers.

In practice:

• TransmissionConstraintType should extend the ArgumentMatchCriteriaType (instead of MatchCriteriaType)
• CommandVerifierType should allow elements of type ArgumentInputAlgorithmType , ArgumentBooleanExpressionType and ArgumentComparisonType (instead of the non argument variety)

All the Argument* types are superset of the corresponding non-argument types so by doing this change, the schema will be backward compatible.

Note: a similar request could be argued for ParametrToSetType to allow setting a parameter to a value computed based on the user defined argument of the command. However since there is no ArgumentMathOperationType, no easy solution can be immediately seen without adding extra types.

Dynamic lookup is sprinkled about the text to (only?) retrieve a numeric value but perhaps there should be an integer and float form. For example in calculating a dynamic array index, would it make sense if the referred to parameter is a float? we can agree any non-numeric is a error. If it's a float or integer, the slope and intercept are doubles – suggesting a double result. Well that may produce a fractional value of an array index – that doesn't make sense. one can round or chop as one sees fits but that's not documented. in this case integer only dynamic value would make more sense – the slope and intercept would be int/long and it would be in error to ref anything but an integer parameter type. other cases may allow for either data type. [edit] Discrete lookup DOES NOT have the same issue – it's value is a float. It however does need a default. I made an issue for that.

Our for a list<element> in the BooleanExpression which made a base type called – BaseConditionsType is a little too broad because it include sub-type now only relevant on the command side.

we should probably have a ArgumentBaseConditionsType.

The children of it now are:

ANDedConditionsType
ArgumentANDedConditionsType
ORedConditionsType
ArgumentORedConditionsType
ComparisonCheckType
ArgumentComparisonCheckType

XUSP 1.2 changed the base type of CalibratorType from OptionalNameDescriptionType to the new BaseCalibratorType. This change eliminated the previous support for <LongDescription> and <AliasSet>. These elements are supported in the XUSP 1.0 profile and are used in existing databases.

Remove use of non-ASCII characters to improve tooling ease of use. These characters are utilized within Annotation fields.

Symbols to change:
‘
’ '
“
”
–

Also, in ArgumentAssignmentListType, add a single quote before "power on"

We have experienced the following error with the Xerces XML parser:

Exception thrown at 0x00007FFB902D4F69 in InstallDB4.exe: Microsoft C++ exception: xercesc_3_0::InvalidDatatypeValueException at memory location 0x000000000014D5A0.

It seems to be driven by this line:
<attribute name="idlePattern" type="xtce:FixedIntegerValueType" default="0x0"/>

Changing the default value to "0" seems to make the problem go away.

Can we change the line instead to:
<attribute name="idlePattern" type="xtce:FixedIntegerValueType" default="0"/>

Appears to be a typo in the BinaryDataEncoding description in the ParameterTypeSet section. "...specifies the bit order, the size in bits, and two algorithms to convert to and from the endcode
value, along with error detection (CRC and Parity checks).

The EnumerationList should probably have a key to disallow the duplicate labels. (similar to the @name keys)

This is more for discussion. our syntax is ok but when the schema types that control the syntax in parameter/argument type are manifest into classes, the result is less than ideal.

Firstly all our parametertype/argumenttypes have NameDescriptionType as the root. It might for example make sense to have as a root "DataType" or something of that nature – and maybe to then ScalarDataType and ComplexDataType which seems natural.

Secondly we now have split the parameter type and argument types because we had to support looking up parameters and arguments in the latter. And these appear deep in the syntax trees. More ideally we'd just bolt on those latter in the hierarchy so as to show more schema types.

Finally somehow array and aggregate didn't get the message – and the time types have their own data encoding syntax.

The result is this:

BaseDataType – all the scalars on the parameter type side have this as a parent.

XXXDataType – next up the various scalars have this interim schema type. This is a vestige from 1.1. So for example IntegerDataType.

BaseTimeDataType – absolute and relative use this though.

ArrayDataTypeType and AggregateDataType – array and aggregate follow this line

Then on the argument side, this is mirrored but with "argument" stuck in front of it all:

ArgumentBaseDataType, ArgumentBaseTimeDataType – oddly Array and Aggregate on this side have ArrayDataTypeType and AggregateDataType as parents.

In the end we up with lots of "root" schema types that are all children of NameDescriptionType – BaseDataType, BaseTimeDataType, ArgumentBaseDataType, ArgumentTimeBaseDataType, ArrayDataTypeType and AggregateDataType.

There's no DataType, ScalarDataType or ComplexDataType which might more natural organize it.

Conclusion: this could all be better.

This seems an old issue. Slope is optional and intercept is optional. But intercept defaults to 0. Slope has no default. The generated classes then return a Double and double. Seems like slope=1 by default would be a good thing.

Btw there's a related issue of having this return doubles when they are only being used in non-float number evaluation.

Perhaps this is more about discussion first but a language/implementation (& version?) attribute would help custom algorithm be useful – and perhaps resolvable by your code.

For example, since most of the implementations of xtce are java – there are many jvm languages that could run as embedded "script" through the custom algorithm – if we but only knew which one to run!

For example so called "space python" could be run on jython…

We use gradle at work, and I'm so used to it forking of JVMs in other languages to do things – I'm thinking, let's give it a go! (we use a plugin that is in written python and is run by gradle on as jython on another jvm)

The discrete lookup list, also sprinkled about the syntax tree retrieves the specified numeric value if its condition evaluates to true. for particular discrete in the list. there are several kinds of conditions. The text isn't completely clear but it seems the first discrete lookup in the list that evaluates to true – returns that value. But what happens if none eval to true? it seems that default value is warrented.

Note: the value is a long. Therefore it does not have same problem as dynamic lookups double data types for integer syntax items.

Type in element name in BinaryParameterType. Possibly a duplicated but I couldnt find it.

The InputSetType has a InputParameterInstanceRefType as well as a ConstantType.
The ArguementInputSetType has a InputParameterInstanceRefType as well as a InputArgumentInstanceRefType.
The inconsistency causes some confusion as to usage.

For instance the documentation for the the ArgumentIntegerDataType says that it is identical to the IntegerDataType. However the initialValue attribute is types as a FixedIntegerValueType whereas the initialValue attribute for the IntegerDataType is typed as long.

Items that previously were typed as FixedIntegerValueType but were changed to become long need to be revisited to update the documentation annotation. For instance IntegerDataType initialValue attribute documentation:
"Default/Initial value is always given in calibrated form. Default is base 10 form; binary, octal, or hexadecimal values may be given by preceding value with 0[b|B], 0[o|O|, 0[x|X] respectively."
Such forms no longer validate against the schema.

XTCE v1.2 added "unit" attribute to TimeAssocationType and added a specialized data type (TimeAssociationUnitType) that is inconsistent with the existing data type (TimeUnitsType)

Draft version of XTCE v1.2 defined <MetaCommandRef> element as:
<element name="MetaCommandRef" type="xtce:MetaCommandRefType">
<complexType name="MetaCommandRefType">
<annotation>
<documentation>Describe a reference to a MetaCommand . See NameReferenceType.</documentation>
</annotation>
<attribute name="metaCommandRef" type="xtce:NameReferenceType" use="required"/>
</complexType>

Published version of XTCE v1.2:
<element name="MetaCommandRef" type="xtce:NameReferenceType">

Published version is inconsistent:

• The attribute "metaCommandRef" is used several other places
• This is the place where a name reference is element text content instead of an attribute.

"A new attribute UnitFormType allows to specify a unit for calibrated values and another unit for uncalibrated values.

Why is this attribute defined with 3 enumerations? ‘raw’, ‘uncalibrated’ and ‘calibrated’?
"

The CustomAlarmType appears to extend BaseAlarmType, where as it should just be an extension of InputAlgorithmType (or similar). The result is there are three name attributes to fill in if you want to do so.

In fact because the AlarmType is the base for all the various DefaultAlarms, the CustomAlarm should probably extend a stubby version of InputAlgorithm without a name or description attribute.

The current schema improves upon XTCE 1.1 but still has issues. Firstly it lacks overall clarity and simple syntax. Second it appears to give 2 ways to describe an overall "string box" and dynamic part which may be confusing to some (we should favor one over the other). See for example Fixed plus one of the TerminatingChar or LeadingSize, or Variable/DynamicValue and maxSizeInBits. Also maxSizeInBits is required and this may be a problem in some scenarios. Finally the choice of syntactic element does make it possible to say that variable length has a dynamic look up terminatingChar and LeadingSize.

The overall use cases of support are:

• fixed string
• fixed box, variable string
• variable string but overall max size (simlar to above)
• variable string unlimited

Here's a longer write up:

1) Fixed string, like as in literally:

StringDataEncoding/SizeInBits/Fixed/FixedValue

2) Fixed string BOX but variable inside that...

StringDataEncoding/SizeInBits/Fixed/FixedValue AND one of Fixed/LeadingSize or Fixed/TerminatingChar

3) Fixed string BOX but variable inside that... yeah we can say this two ways then:

StringDataEncoding/Variable/@maxSizeInBits=sizeOf(StringBox) AND one of DynamicValue or DiscreteValue to look up the length from it, and then optionally either LeadingSize or TerminationChar or both even too

This one is terribly confusing...

4) Variable and Max size

StringDataEncoding/Variable/Dynamic|Discrete plus required maxSizeInBits and then optionally either LeadingSize or TerminationChar too

5) Variable but no max size stated in source material

StringDataEncoding/Variable/Dynamic|Discrete set maxSizeInBits to ginormous and probably just ignore and then optionally either LeadingSize or TerminationChar too

So #1 and #2 make sense but are a tad unwieldy syntax wise... well we are probably a little stuck there in regard to "backwards compatibility". This is probably the most used, these two.

I think #4 makes sense – although mixing in the leading size or termination char seems either just plain confusing or weird...

#5 is unfortunate but making @maxSizeinBits optional seems quick fix OR the workaround isn't necessarily bad.

The "let's set everything" #3 isn't great but could be factored away in documentation

"The issue is declared Closed.
The problem has not been fixed. It is still impossible to reference an argument in a CommandContainerSet/CommandContainer/RefEntry."

Much of the annotation is gone in InputAlgorithmType in 1.2 in its major elements. These were turned into schema types for 1.2, and somehow the annotation was not copied over from 1.1.

"The issue is partially fixed. The new attribute rangeForm shall be also used in ValidRange and not only in AlarmRangesType.

The use of this new attribute allows to simplify the definition of ranges (in replacing minInclusive, maxInclusive, minExclusive and maxExclusive with min & max)."

An issue marked as deferred in 1.1, made into 1.2.

"Type inheritance missing from Absolute and Relative time data types

The status of this issue is ‘Deferred’ but the proposed change has been implemented in 20180204-SpaceSystemV1.2.xsd"

In the MemberType element, the initialValue attribute missed the annotation fix to remove the "0b" and "0x" stuff from previous discussions and resolution in XTCE 1.2.

The service ref now require content and an attribute – this clearly the result of an "oops" during clean up of 1.2.

Basically it should NOT extend NameDescriptionType.

<complexType name="ServiceRefType">
<annotation>
<documentation xml:lang="en">A reference to a Service</documentation>
</annotation>
<simpleContent>
<extension base="xtce:NameReferenceType">
<attribute name="serviceRef" type="xtce:NameReferenceType" use="required"/>
</extension>
</simpleContent>
</complexType>

<element name="RelativeTimeAgumentType" type="xtce:RelativeTimeArgumentType">
RelativeTimeAgumentType should have an "r" in it.

"Some typos have been fixed (twosComplement instead of twosCompliment & onesComplement instead of onesCompliment) but one is still present in the schema: RelativeTimeAgumentType instead of RelativeTimeArgumentType."

This should be ArgumentAssignmentList, with an "n".

Just a typo in the schema construction, should just be optional choice.

<sequence>
<choice minOccurs="0">
<element name="AlarmConditions" type="xtce:AlarmConditionsType">
<annotation>
<documentation xml:lang="en">A MatchCriteria may be specified for each of the 5 alarm levels. Each level is optional and the alarm should be the highest level to test true.</documentation>
</annotation>
</element>
<element name="CustomAlarm" type="xtce:CustomAlarmType">
<annotation>
<documentation xml:lang="en">An escape for ridiculously complex alarm conditions. Will trigger on changes to the containing Parameter.</documentation>
</annotation>
</element>
</choice>
</sequence>

RangeForm now appears in Static, Change and the multi band. It's not clear these all make sense to me.

In the static ranges – having the red be the most severe inner band and green "good" on the outside does make sense although I get the impression the use cases are less in number than the standard way folks think of limits. (you're going too fast! not – you're not going fast enough!)

In the change alarm, which I think of mainly as deltas – again intuitively checking for big changes make sense. Unwanted big jumps are intuitive. But unwanted little jumps? That is big jumps are good? Is there a real use case – perhaps we can jam it into the annotation.

Finally for the multirange alarm. The rangeForm is at each band. I suspect but don't know that this was to change the range set meaning...
Intuitively "inside" would be something like this: [min, max] – where x is between them is "ok" ...

And "outside" would be (-inf, min] and [max, inf) ... that is ranges point 'away'...

But maybe not – who knows!? Given that though the default is "outside" when perhaps most would want it to be "inside" etc...

I just wonder if we have done this correctly or its slipped through and is overly general because we inherited the various types, etc...

The rangeForm annotation is vague and needs improvement. There are two places it occurs – one at the attribute level with another brief mention at the schema type:
"A value of outside specifies that the most severe range is outside all the other ranges: -severe -critical -distress -warning -watch normal +watch +warning +distress +critical +severe. A value of inside "inverts" these bands: -green -watch -warning -distress -critical severe +critical +distress +warning +watch. The most common form used is "outside" and is the default."

The key problem is the term "inverts" is not really defined and so the entire explanation is overly general.

XTCE 1.2 defined as base data type for calibrators (BaseCalibratorType).
This data type is used an extension twice for each calibrator:

• Once in CalibratorType
• Again in the child element (e.g., PolynomialCalibratorType)

Draft version of XTCE v1.2 defined dataSource attribute as:
<attribute name="dataSource" type="xtce:TelemetryDataSourceType" default="telemetered">

Published version is v1.1:
<attribute name="dataSource" type="xtce:TelemetryDataSourceType" use="optional">