knxultimate
Version:
KNX IP protocol implementation for Node. This is the ENGINE of Node-Red KNX-Ultimate node.
170 lines (169 loc) • 6.23 kB
TypeScript
/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import dgram from 'dgram';
import net from 'net';
import { KnxResponse } from './protocol/KNXProtocol';
import { TunnelTypes } from './protocol/TunnelCRI';
import KNXAddress from './protocol/KNXAddress';
import { KNXLoggerOptions } from './KnxLog';
import { KNXDescriptionResponse, KNXPacket } from './protocol';
import KNXRoutingIndication from './protocol/KNXRoutingIndication';
import KNXTunnelingRequest from './protocol/KNXTunnelingRequest';
import { TypedEventEmitter } from './TypedEmitter';
import KNXHeader from './protocol/KNXHeader';
import KNXTunnelingAck from './protocol/KNXTunnelingAck';
import KNXSearchResponse from './protocol/KNXSearchResponse';
export declare enum ConncetionState {
STARTED = "STARTED",
CONNECTING = "CONNECTING",
CONNECTED = "CONNECTED",
DISCONNECTING = "DISCONNECTING",
DISCONNECTED = "DISCONNECTED"
}
export declare enum SocketEvents {
error = "error",
message = "message",
listening = "listening",
data = "data",
close = "close"
}
export type KNXClientProtocol = 'TunnelUDP' | 'Multicast' | 'TunnelTCP';
export declare enum KNXClientEvents {
error = "error",
disconnected = "disconnected",
discover = "discover",
indication = "indication",
connected = "connected",
ready = "ready",
response = "response",
connecting = "connecting",
ackReceived = "ackReceived",
close = "close",
descriptionResponse = "descriptionResponse"
}
export interface KNXClientEventCallbacks {
error: (error: Error) => void;
disconnected: (reason: string) => void;
discover: (host: string, header: KNXHeader, message: KNXSearchResponse) => void;
getGatewayDescription: (searchResponse: KNXDescriptionResponse) => void;
indication: (packet: KNXRoutingIndication, echoed: boolean) => void;
connected: (options: KNXClientOptions) => void;
ready: () => void;
response: (host: string, header: KNXHeader, message: KnxResponse) => void;
connecting: (options: KNXClientOptions) => void;
ackReceived: (packet: KNXTunnelingAck | KNXTunnelingRequest, ack: boolean) => void;
close: () => void;
descriptionResponse: (packet: KNXDescriptionResponse) => void;
}
export type KNXClientOptions = {
physAddr?: string;
connectionKeepAliveTimeout?: number;
ipAddr?: string;
ipPort?: number | string;
hostProtocol?: KNXClientProtocol;
isSecureKNXEnabled?: boolean;
suppress_ack_ldatareq?: boolean;
localEchoInTunneling?: boolean;
localIPAddress?: string;
interface?: string;
jKNXSecureKeyring?: any;
localSocketAddress?: string;
KNXQueueSendIntervalMilliseconds?: number;
sniffingMode?: boolean;
theGatewayIsKNXVirtual?: boolean;
} & KNXLoggerOptions;
export declare function getDecodedKeyring(): string;
export declare enum KNXTimer {
ACK = "ack",
HEARTBEAT = "heartbeat",
CONNECTION_STATE = "connection_state",
CONNECTION = "connection",
CONNECT_REQUEST = "connect_request",
DISCONNECT = "disconnect",
DISCOVERY = "discovery",
GATEWAYDESCRIPTION = "GatewayDescription"
}
export type SnifferPacket = {
reqType?: string;
request?: string;
response?: string;
resType?: string;
deltaReq: number;
deltaRes?: number;
};
export default class KNXClient extends TypedEventEmitter<KNXClientEventCallbacks> {
private _channelID;
private _connectionState;
private _numFailedTelegramACK;
private _clientTunnelSeqNumber;
private _options;
private _peerHost;
private _peerPort;
private _heartbeatFailures;
private _heartbeatRunning;
private max_HeartbeatFailures;
private _awaitingResponseType;
private _clientSocket;
private sysLogger;
private jKNXSecureKeyring;
private _clearToSend;
private socketReady;
private timers;
physAddr: KNXAddress;
theGatewayIsKNXVirtual: boolean;
private commandQueue;
private exitProcessingKNXQueueLoop;
private currentItemHandledByTheQueue;
private queueLock;
private sniffingPackets;
private lastSnifferRequest;
get udpSocket(): dgram.Socket;
get tcpSocket(): net.Socket;
constructor(options: KNXClientOptions, createSocket?: (client: KNXClient) => void);
private createSocket;
get channelID(): number;
get clearToSend(): boolean;
set clearToSend(val: boolean);
private getKNXDataBuffer;
private waitForEvent;
private setTimer;
private clearTimer;
private clearAllTimers;
private processKnxPacketQueueItem;
private handleKNXQueue;
send(_knxPacket: KNXPacket, _ACK: KNXTunnelingRequest, _priority: boolean, _expectedSeqNumberForACK: number): void;
write(dstAddress: KNXAddress | string, data: any, dptid: string | number): void;
respond(dstAddress: KNXAddress | string, data: Buffer, dptid: string | number): void;
read(dstAddress: KNXAddress | string): void;
writeRaw(dstAddress: KNXAddress | string, rawDataBuffer: Buffer, bitlength: number): void;
private startHeartBeat;
private stopHeartBeat;
isDiscoveryRunning(): boolean;
startDiscovery(): void;
stopDiscovery(): void;
static discover(eth?: string | number, timeout?: number): Promise<string[]>;
isGatewayDescriptionRunning(): boolean;
startGatewayDescription(): void;
stopGatewayDescription(): void;
static getGatewayDescription(ipAddr: string, ipPort: string, eth?: string | number, timeout?: number): Promise<any[]>;
Connect(knxLayer?: TunnelTypes): void;
private closeSocket;
Disconnect(): Promise<void>;
isConnected(): boolean;
private setDisconnected;
private runHeartbeat;
private getSeqNumber;
private getCurrentItemHandledByTheQueue;
private incSeqNumber;
private setTimerWaitingForACK;
private getKNXConstantName;
private processInboundMessage;
private sendDescriptionRequestMessage;
private sendSearchRequestMessage;
private sendConnectRequestMessage;
private sendConnectionStateRequestMessage;
private sendDisconnectRequestMessage;
private sendDisconnectResponseMessage;
private sendSecureSessionRequestMessage;
}