nestjs 使用@types/node-snap7 单个地址读写，多个地址读写，重连

nestjs 是一个基于 Node.js 的框架，因此可以直接使用 Node.js 的模块。@types/node-snap7 是一个 Node.js 的库，可以用来与 Snap7 进行通信。下面是使用 @types/node-snap7 实现单个地址读写、多个地址读写和重连的示例代码：

import { Injectable } from '@nestjs/common';
import * as snap7 from 'node-snap7';

@Injectable()
export class Snap7Service {

  private client: snap7.S7Client;

  constructor() {
    this.client = new snap7.S7Client();
  }

  public connect(ip: string, rack: number, slot: number): Promise<void> {
    return new Promise((resolve, reject) => {
      this.client.ConnectTo(ip, rack, slot, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  }

  public disconnect(): void {
    this.client.Disconnect();
  }

  public readBool(db: number, start: number): Promise<boolean> {
    return new Promise((resolve, reject) => {
      const buffer = Buffer.alloc(snap7.S7Client.BOOL_SIZE);
      this.client.ReadArea(snap7.S7Client.S7AreaDB, db, start, snap7.S7Client.BOOL_SIZE, snap7.S7Client.S7WLBit, buffer, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve(buffer.readUInt8(0) !== 0);
        }
      });
    });
  }

  public writeBool(db: number, start: number, value: boolean): Promise<void> {
    return new Promise((resolve, reject) => {
      const buffer = Buffer.alloc(snap7.S7Client.BOOL_SIZE);
      buffer.writeUInt8(value ? 1 : 0, 0);
      this.client.WriteArea(snap7.S7Client.S7AreaDB, db, start, snap7.S7Client.BOOL_SIZE, snap7.S7Client.S7WLBit, buffer, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  }

  public readMultiVars(vars: snap7.S7VariableItem[]): Promise<snap7.S7DataItem[]> {
    return new Promise((resolve, reject) => {
      this.client.ReadMultiVars(vars, (err, data) => {
        if (err) {
          reject(err);
        } else {
          resolve(data);
        }
      });
    });
  }

  public writeMultiVars(vars: snap7.S7VariableItem[]): Promise<void> {
    return new Promise((resolve, reject) => {
      this.client.WriteMultiVars(vars, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  }

  public async reconnect(ip: string, rack: number, slot: number): Promise<void> {
    this.disconnect();
    await this.connect(ip, rack, slot);
  }

}

在上面的代码中，Snap7Service 是一个 NestJS 的服务，提供了四个方法和一个构造函数：

- connect(ip: string, rack: number, slot: number): Promise<void>：连接到 Snap7 服务器；
- disconnect(): void：断开与 Snap7 服务器的连接；
- readBool(db: number, start: number): Promise<boolean>：读取指定地址的布尔值；
- writeBool(db: number, start: number, value: boolean): Promise<void>：写入指定地址的布尔值；
- readMultiVars(vars: snap7.S7VariableItem[]): Promise<snap7.S7DataItem[]>：读取多个地址的值；
- writeMultiVars(vars: snap7.S7VariableItem[]): Promise<void>：写入多个地址的值；
- reconnect(ip: string, rack: number, slot: number): Promise<void>：断开与 Snap7 服务器的连接并重新连接。

这些方法都是异步的，使用 Promise 进行返回。其中，readBool 和 writeBool 分别用于读取和写入单个地址的布尔值，readMultiVars 和 writeMultiVars 分别用于读取和写入多个地址的值。在 readMultiVars 和 writeMultiVars 中，参数 vars 是一个 S7VariableItem 数组，用于指定要读取或写入的地址和类型。在 reconnect 方法中，先断开与 Snap7 服务器的连接，然后再重新连接。

使用示例：

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { Snap7Service } from './snap7.service';
import * as snap7 from 'node-snap7';

@Controller('snap7')
export class Snap7Controller {

  constructor(private readonly snap7Service: Snap7Service) {}

  @Post('connect')
  async connect(@Body() body: { ip: string, rack: number, slot: number }): Promise<void> {
    await this.snap7Service.connect(body.ip, body.rack, body.slot);
  }

  @Get('readBool/:db/:start')
  async readBool(@Param('db') db: number, @Param('start') start: number): Promise<boolean> {
    return await this.snap7Service.readBool(db, start);
  }

  @Post('writeBool/:db/:start')
  async writeBool(@Param('db') db: number, @Param('start') start: number, @Body() body: { value: boolean }): Promise<void> {
    await this.snap7Service.writeBool(db, start, body.value);
  }

  @Post('readMultiVars')
  async readMultiVars(@Body() body: { items: snap7.S7VariableItem[] }): Promise<snap7.S7DataItem[]> {
    return await this.snap7Service.readMultiVars(body.items);
  }

  @Post('writeMultiVars')
  async writeMultiVars(@Body() body: { items: snap7.S7VariableItem[] }): Promise<void> {
    await this.snap7Service.writeMultiVars(body.items);
  }

  @Post('reconnect')
  async reconnect(@Body() body: { ip: string, rack: number, slot: number }): Promise<void> {
    await this.snap7Service.reconnect(body.ip, body.rack, body.slot);
  }

}

在上面的代码中，Snap7Controller 是一个 NestJS 的控制器，提供了五个路由：

- POST /snap7/connect：连接到 Snap7 服务器；
- GET /snap7/readBool/:db/:start：读取指定地址的布尔值；
- POST /snap7/writeBool/:db/:start：写入指定地址的布尔值；
- POST /snap7/readMultiVars：读取多个地址的值；
- POST /snap7/writeMultiVars：写入多个地址的值；
- POST /snap7/reconnect：断开与 Snap7 服务器的连接并重新连接。

其中，readBool、writeBool、readMultiVars 和 writeMultiVars 的参数都是通过 HTTP 请求体中的 JSON 数据传递的。在 readBool、writeBool 和 reconnect 中，通过路由参数传递了 db 和 start（读写的地址）。在 readMultiVars 和 writeMultiVars 中，通过 items 参数传递了要读写的地址和类型。