@kvaser/canking-api
Version:
CanKing API to communicate with the CanKing service using Node.js.
525 lines (524 loc) • 20.5 kB
TypeScript
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import Long from "long";
import { FixedPosFrameIdentifier, ScheduleTable, SignalValue, WriteFrame } from "./frame_params";
import { CanChannelConfiguration, DataProcessorNodeProperties, LinChannelConfiguration, LogFileFormat, MeasurementSetup, PeriodicTransmissionSettings, SourceNodeProperties, TargetNodeProperties } from "./measurement_settings";
/**
* Possible events.
* @internal
*/
export declare enum MeasurementEvent {
MEASUREMENT_EVENT_UNSPECIFIED = 0,
/** MEASUREMENT_EVENT_MEASUREMENT_SETUP_CHANGED - Raised when the measurement setup has changed, will pass the new MeasurementSetup as event data */
MEASUREMENT_EVENT_MEASUREMENT_SETUP_CHANGED = 1,
/** MEASUREMENT_EVENT_ONLINE_STATUS_CHANGED - Raised when the online status has changed, will pass the new OnlineStatus as event data */
MEASUREMENT_EVENT_ONLINE_STATUS_CHANGED = 2,
/** MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STARTED - Raised when a periodic transmission has started, will pass the transmission's identifier as event data */
MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STARTED = 3,
/** MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STOPPED - Raised when a periodic transmission has stopped, will pass the transmission's identifier as event data */
MEASUREMENT_EVENT_PERIODIC_TRANSMISSION_STOPPED = 4,
UNRECOGNIZED = -1
}
export declare function measurementEventFromJSON(object: any): MeasurementEvent;
export declare function measurementEventToJSON(object: MeasurementEvent): string;
/**
* A request message for setting a new measurement setup.
* @internal
*/
export interface SetMeasurementSetupRequest {
setup: MeasurementSetup | undefined;
}
/**
* A request message for adding all connected CAN channels.
* @internal
*/
export interface AddAllConnectedCanChannelsRequest {
configuration: CanChannelConfiguration | undefined;
}
/**
* A request message for adding all connected LIN channels.
* @internal
*/
export interface AddAllConnectedLinChannelsRequest {
configuration: LinChannelConfiguration | undefined;
}
/**
* A request message for adding or updating a source node.
* @internal
*/
export interface AddOrUpdateSourceRequest {
source: SourceNodeProperties | undefined;
/**
* If true then all properties will be replaced with values from source.
* If false then only properties with values in source will be updated.
* This field is ignored when adding a new node.
*/
replaceAllProperties: boolean;
}
/**
* A response message for getting a source node.
* @internal
*/
export interface GetSourceResponse {
source: SourceNodeProperties | undefined;
}
/**
* A request message for adding or updating a data processor node.
* @internal
*/
export interface AddOrUpdateDataProcessorRequest {
dataProcessor: DataProcessorNodeProperties | undefined;
/** If adding a new data processor after another node then set previous_node to the id of the preceding node */
previousNode: string;
/** If adding a new data processor before another node then set next_node to the id of the subsequent node */
nextNode: string;
/**
* If true then all properties will be replaced with values from data_processor.
* If false then only properties with values in data_processor will be updated.
* This field is ignored when adding a new node.
*/
replaceAllProperties: boolean;
}
/**
* A response message for getting a data processor node.
* @internal
*/
export interface GetDataProcessorResponse {
dataProcessor: DataProcessorNodeProperties | undefined;
}
/**
* A request message for adding or updating a target node.
* @internal
*/
export interface AddOrUpdateTargetRequest {
target: TargetNodeProperties | undefined;
/**
* If true then all properties will be replaced with values from target.
* If false then only properties with values in target will be updated.
* This field is ignored when adding a new node.
*/
replaceAllProperties: boolean;
}
/**
* A response message for getting a target node.
* @internal
*/
export interface GetTargetResponse {
target: TargetNodeProperties | undefined;
}
/**
* A request message for connecting two nodes.
* @internal
*/
export interface ConnectNodesRequest {
startNode: string;
endNode: string;
}
/**
* A request message for disconnecting two nodes.
* @internal
*/
export interface DisconnectNodesRequest {
startNode: string;
endNode: string;
}
/**
* A request message for any service method that needs to know one identifier of a node
* in the measurement setup.
* @internal
*/
export interface IdentifierRequest {
identifier: string;
}
/**
* A request message for any service method that needs to know identifiers of a nodes
* in the measurement setup.
* @internal
*/
export interface IdentifiersRequest {
identifiers: string[];
}
/**
* A request message for sending out one message frame.
* @internal
*/
export interface SendMessageRequest {
channelIdentifier: string;
frame: WriteFrame | undefined;
}
/**
* A request message for sending out several message frames.
* @internal
*/
export interface SendMessagesRequest {
channelIdentifier: string;
frames: WriteFrame[];
}
/**
* A request message for sending out one LIN wakeup frame.
* @internal
*/
export interface SendLinWakeupFrameRequest {
/** Identifier of the LIN channel to send the wakeup frame on. */
channelIdentifier: string;
/** The number of wakeup frames to send. Maximum value of count is 255 (0xFF). */
count: number;
/** The time, in bit times, between the wakeup frames. Maximum value of interval is either 255 (0xFF) or 65535 (0xFFFF) depending on device. */
interval: number;
}
/**
* A request message for writing a LIN message header to the LIN bus.
* @internal
*/
export interface RequestLinMessageRequest {
/** Identifier of the LIN channel to clear the message buffer on. */
channelIdentifier: string;
/** The LIN message id to write to the LIN bus. */
frameId: number;
}
/**
* A request message for updating a message buffer in a slave. The contents of the message buffer will be used the next time the slave
* is polled for the specified LIN message id.
* @internal
*/
export interface UpdateLinMessageRequest {
/** Identifier of the LIN channel to update the message buffer on. */
channelIdentifier: string;
/** The new LIN message. */
frame: WriteFrame | undefined;
}
/**
* A request message for clearing a message buffer for a LIN slave. The slave will not answer next time it is polled.
* @internal
*/
export interface ClearLinMessageRequest {
/** Identifier of the LIN channel to clear the message buffer on. */
channelIdentifier: string;
/** The LIN message id for which the corresponding buffer will be cleared. */
frameId: number;
}
/**
* A request message for start sending out message frames periodically.
* @internal
*/
export interface StartPeriodicTransmissionRequest {
/** Periodic transmission settings */
settings: PeriodicTransmissionSettings | undefined;
}
/**
* A request message for updating the settings of a periodic transmission.
* @internal
*/
export interface UpdatePeriodicTransmissionRequest {
/** Periodic transmission settings */
settings: PeriodicTransmissionSettings | undefined;
/** Identifier of periodic transmission */
identifier: string;
}
/**
* A response message for start sending out message frames periodically.
* @internal
*/
export interface StartPeriodicTransmissionResponse {
periodicTransmissionIdentifier: string;
}
/** A message for streaming online status information. */
export interface OnlineStatus {
/** Indicates if the measurement is online. */
isOnline: boolean;
/** Counter that is increased every time the measurement goes online. This can be used to detect when the measurement goes offline and then online again. */
onlineCounter: number;
}
/**
* Event arguments
* @internal
*/
export interface MeasurementEventArgs {
eventType: MeasurementEvent;
identifier?: string | undefined;
measurementSetup?: MeasurementSetup | undefined;
onlineStatus?: OnlineStatus | undefined;
}
/**
* A request message to get supported log file formats.
* @internal
*/
export interface GetLogFileFormatsRequest {
/** Set to true to include message log formats. */
messageLog: boolean;
/** Set to true to include signal value log formats. */
signalLog: boolean;
/** Set to true to only include formats with read support. */
readSupport: boolean;
}
/**
* Information about a log file format.
* @internal
*/
export interface LogFileFormatInfo {
/** File format. */
format: LogFileFormat;
/** File format name. */
name: string;
/** File format file extension. */
extension: string;
/** File format description. */
description: string;
/** Supported protocols by the format. */
supportedProtocols: string[];
}
/**
* A response message for GetLogFileFormats request.
* @internal
*/
export interface GetLogFileFormatsResponse {
/** All supported formats. */
formats: LogFileFormatInfo[];
}
/**
* A request message to get all channels listed in a log file.
* @internal
*/
export interface GetChannelsFromLogFileRequest {
/** Log file to retrieve channels from. */
logFile: string;
}
/**
* A response message for GetChannelsFromLogFile request.
* @internal
*/
export interface GetChannelsFromLogFileResponse {
/** Channels listed in the log file. */
channels: number[];
/** Channel protocols listed in the log file. */
protocols: string[];
/** True if the log file contains received frames. */
hasRxFrames: boolean;
/** True if the log file contains transmitted frames. */
hasTxFrames: boolean;
}
/**
* A request message to get all schedule tables listed in the specified database files.
* @internal
*/
export interface GetScheduleTablesFromDatabaseFilesRequest {
/** Database files to retrieve schedule tables from. */
files: string[];
}
/**
* A response message for GetScheduleTablesFromDatabaseFiles request.
* @internal
*/
export interface GetScheduleTablesFromDatabaseFilesResponse {
/** Tables listed in the database file. */
tables: ScheduleTable[];
}
/**
* A request message to get all signal values for a message.
* @internal
*/
export interface GetSignalDataFromMessageDataRequest {
/** Message qualified name. */
messageQualifiedName: string;
/** Message data. */
data: number[];
}
/**
* A response message for GetSignalDataFromMessageData request.
* @internal
*/
export interface GetSignalDataFromMessageDataResponse {
/** Signal values. */
signalValues: SignalValue[];
}
/**
* A request message to set all signal values for a message.
* @internal
*/
export interface SetSignalDataToMessageDataRequest {
/** Message qualified name. */
messageQualifiedName: string;
/** The current message data. */
data: number[];
/** New signal values. One or more signals to be updated. */
signalValues: SignalValue[];
}
/**
* A response message for SetSignalDataToMessageData request.
* @internal
*/
export interface SetSignalDataToMessageDataResponse {
/**
* Updated signal values. Might be different from the once passed in the request if the
* specified signal value couldn't be exactly represented in raw data.
*/
signalValues: SignalValue[];
/** Updated message data. */
data: number[];
}
/**
* A request message to get data frames before a specified timestamp.
* @internal
*/
export interface GetDataFramesBeforeTimestampRequest {
/** Maximum number of frames to retrieve. */
maxCount?: number | undefined;
/** Timestamp in microseconds to retrieve frames before. */
timestampUs: Long;
}
/**
* A request message to get data frames between specified timestamps.
* @internal
*/
export interface GetDataFramesBetweenTimestampsRequest {
/** Optional frame identifiers to filter on. If no frame identifiers are specified, frames from all identifiers are retrieved. */
frameIds: FixedPosFrameIdentifier[];
/** Timestamp in microseconds to retrieve frames from (inclusive). */
startTimestampUs: Long;
/** Timestamp in microseconds to retrieve frames to (exclusive). */
endTimestampUs: Long;
}
/**
* A request message to subscribe for data frames.
* @internal
*/
export interface SubscribeForDataRequest {
/** Subscribed frame identifiers, for frames specified here all data will be streamed. */
frameIds: FixedPosFrameIdentifier[];
}
/**
* A request message to get data envelopes between specified timestamps for specific frames.
* @internal
*/
export interface GetFrameEnvelopesRequest {
/** Timestamp in microseconds to retrieve envelopes from (inclusive). */
startTimestampUs: Long;
/** Timestamp in microseconds to retrieve envelopes to (exclusive). */
endTimestampUs: Long;
/** Width of the view in pixels. */
viewWidthPx: number;
/** Optional frame identifiers to filter on. If no frame identifiers are specified, envelopes from all identifiers are retrieved. */
frameIds: FixedPosFrameIdentifier[];
}
/**
* A data envelope for a specific signal.
* All arrays must have the same length.
* @internal
*/
export interface SignalDataEnvelope {
/** Signal qualified name. */
signalQualifiedName: string;
/** Timestamps in microseconds. */
timestampsUs: Long[];
/** Minimum values. */
minValues: number[];
/** Maximum values. */
maxValues: number[];
/** Frame identifiers to filter on. */
frameIds: FixedPosFrameIdentifier[];
}
export interface FrameDataEnvelope {
/** Frame identifier. */
frameId: FixedPosFrameIdentifier | undefined;
/** Signal data envelopes for all signals in the frame. */
signalEnvelopes: SignalDataEnvelope[];
}
/**
* A response message for GetFrameEnvelopes request.
* @internal
*/
export interface GetFrameEnvelopesResponse {
/** Data envelopes for all signals for each requested frame identifier. */
envelopes: FrameDataEnvelope[];
}
/**
* A collection of frame property names.
* @internal
*/
export interface FramePropertyNames {
/** The names of the frame properties. */
names: string[];
}
/**
* A response message for GetAvailableFramePropertyNames request.
* @internal
*/
export interface GetAvailableFramePropertyNamesResponse {
/**
* Map of node type to available frame property names.
* The node type can be used to determine which properties are available for frames processed by a specific node in the measurement setup.
* Each node in the measurement setup has a node type, and the properties available for frames processed by that node depend on the node type.
* For example, for frames processed by a CAN channel node, properties related to CAN frames will be available, while for frames processed by
* a LIN channel node, properties related to LIN frames will be available.
*/
framePropertyNamesByNodeType: {
[key: string]: FramePropertyNames;
};
}
export interface GetAvailableFramePropertyNamesResponse_FramePropertyNamesByNodeTypeEntry {
key: string;
value: FramePropertyNames | undefined;
}
export declare const SetMeasurementSetupRequest: MessageFns<SetMeasurementSetupRequest>;
export declare const AddAllConnectedCanChannelsRequest: MessageFns<AddAllConnectedCanChannelsRequest>;
export declare const AddAllConnectedLinChannelsRequest: MessageFns<AddAllConnectedLinChannelsRequest>;
export declare const AddOrUpdateSourceRequest: MessageFns<AddOrUpdateSourceRequest>;
export declare const GetSourceResponse: MessageFns<GetSourceResponse>;
export declare const AddOrUpdateDataProcessorRequest: MessageFns<AddOrUpdateDataProcessorRequest>;
export declare const GetDataProcessorResponse: MessageFns<GetDataProcessorResponse>;
export declare const AddOrUpdateTargetRequest: MessageFns<AddOrUpdateTargetRequest>;
export declare const GetTargetResponse: MessageFns<GetTargetResponse>;
export declare const ConnectNodesRequest: MessageFns<ConnectNodesRequest>;
export declare const DisconnectNodesRequest: MessageFns<DisconnectNodesRequest>;
export declare const IdentifierRequest: MessageFns<IdentifierRequest>;
export declare const IdentifiersRequest: MessageFns<IdentifiersRequest>;
export declare const SendMessageRequest: MessageFns<SendMessageRequest>;
export declare const SendMessagesRequest: MessageFns<SendMessagesRequest>;
export declare const SendLinWakeupFrameRequest: MessageFns<SendLinWakeupFrameRequest>;
export declare const RequestLinMessageRequest: MessageFns<RequestLinMessageRequest>;
export declare const UpdateLinMessageRequest: MessageFns<UpdateLinMessageRequest>;
export declare const ClearLinMessageRequest: MessageFns<ClearLinMessageRequest>;
export declare const StartPeriodicTransmissionRequest: MessageFns<StartPeriodicTransmissionRequest>;
export declare const UpdatePeriodicTransmissionRequest: MessageFns<UpdatePeriodicTransmissionRequest>;
export declare const StartPeriodicTransmissionResponse: MessageFns<StartPeriodicTransmissionResponse>;
export declare const OnlineStatus: MessageFns<OnlineStatus>;
export declare const MeasurementEventArgs: MessageFns<MeasurementEventArgs>;
export declare const GetLogFileFormatsRequest: MessageFns<GetLogFileFormatsRequest>;
export declare const LogFileFormatInfo: MessageFns<LogFileFormatInfo>;
export declare const GetLogFileFormatsResponse: MessageFns<GetLogFileFormatsResponse>;
export declare const GetChannelsFromLogFileRequest: MessageFns<GetChannelsFromLogFileRequest>;
export declare const GetChannelsFromLogFileResponse: MessageFns<GetChannelsFromLogFileResponse>;
export declare const GetScheduleTablesFromDatabaseFilesRequest: MessageFns<GetScheduleTablesFromDatabaseFilesRequest>;
export declare const GetScheduleTablesFromDatabaseFilesResponse: MessageFns<GetScheduleTablesFromDatabaseFilesResponse>;
export declare const GetSignalDataFromMessageDataRequest: MessageFns<GetSignalDataFromMessageDataRequest>;
export declare const GetSignalDataFromMessageDataResponse: MessageFns<GetSignalDataFromMessageDataResponse>;
export declare const SetSignalDataToMessageDataRequest: MessageFns<SetSignalDataToMessageDataRequest>;
export declare const SetSignalDataToMessageDataResponse: MessageFns<SetSignalDataToMessageDataResponse>;
export declare const GetDataFramesBeforeTimestampRequest: MessageFns<GetDataFramesBeforeTimestampRequest>;
export declare const GetDataFramesBetweenTimestampsRequest: MessageFns<GetDataFramesBetweenTimestampsRequest>;
export declare const SubscribeForDataRequest: MessageFns<SubscribeForDataRequest>;
export declare const GetFrameEnvelopesRequest: MessageFns<GetFrameEnvelopesRequest>;
export declare const SignalDataEnvelope: MessageFns<SignalDataEnvelope>;
export declare const FrameDataEnvelope: MessageFns<FrameDataEnvelope>;
export declare const GetFrameEnvelopesResponse: MessageFns<GetFrameEnvelopesResponse>;
export declare const FramePropertyNames: MessageFns<FramePropertyNames>;
export declare const GetAvailableFramePropertyNamesResponse: MessageFns<GetAvailableFramePropertyNamesResponse>;
export declare const GetAvailableFramePropertyNamesResponse_FramePropertyNamesByNodeTypeEntry: MessageFns<GetAvailableFramePropertyNamesResponse_FramePropertyNamesByNodeTypeEntry>;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
[K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
type Exact<P, I extends P> = P extends Builtin ? P : P & {
[K in keyof P]: Exact<P[K], I[K]>;
} & {
[K in Exclude<keyof I, KeysOfUnion<P>>]: never;
};
interface MessageFns<T> {
encode(message: T, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): T;
fromJSON(object: any): T;
toJSON(message: T): unknown;
create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};