@jiabaida/tools 1.0.0 → 1.0.1

package/src/core/BleCmdAnalysis/index.js

@@ -0,0 +1,7 @@
+export * from './BleCmdAnalysis';
+export * from './BleCmdFFAA';
+export * from './BleCmdDD';
+export * from './readAndSetParam'
+export * from './BaseParamProtocol'
+export * from './BleCmdHVES'
+export * from './ESHostProtocol'

package/src/core/BleCmdAnalysis/readAndSetParam.js

@@ -0,0 +1,288 @@
+import { decimalToTwoByteHexArray, decimalToHex, getParamBaseValue } from '../BleDataProcess.js'
+import { readExistFactory, getDDA5FAAsync, enterFactory, getDDA5OldAsync, existFactory, setDDA5FAAsync, setDDA5OldAsync } from './BleCmdDD.js'
+
+// #region 发指令读取参数 
+/**
+ * 发指令读取参数
+ * @param {*} chipType 芯片类型
+ * @param {*} deviceId 设备deviceId
+ * @param {*} paramInfo 参数信息
+ * @param {*} paramInfo.address 新协议开始读取地址（十进制）如 31
+ * @param {*} paramInfo.length 新协议读参数内容长度（需要读取的所有参数的字节数之和/2）（十进制）如 1
+ * @param {*} paramInfo.oldAddress 旧协议读取地址 默认读一个（十六进制字符串）如 '0x1f'
+ * @param {*} needFactoryMode 是否需要进入工厂模式 默认true
+ * @returns data 读取到的参数值（只返回内容的十进制数组）
+ */
+export const readParamCmd = (chipType, deviceId, paramInfo, needFactoryMode = true) => {
+  console.log('chipType: ', chipType);
+  return new Promise(async (resolve, reject) => {
+    const { address = 0, length = 1, oldAddress = "0x1f" } = paramInfo;
+    /**  地址转换为16进制 */
+    const hexAddress = decimalToTwoByteHexArray(address);
+    // 长度转换为16进制
+    const hexLength = decimalToHex(length);
+    const handleRead = async (readFunction, index) => {
+      try {
+        const hex = await readFunction();
+        if (index == 4 && needFactoryMode) await readExistFactory(deviceId);
+        if (!hex) {
+          resolve(null);
+          return;
+        }
+        const data = hex.slice(index, -3);
+        console.log("data: 读参数", data);
+        if (data) {
+          resolve(data);
+        } else {
+          resolve(null);
+        }
+      } catch (error) {
+        console.error("读取参数出错: ", error);
+        reject(error);
+      }
+    };
+    try {
+      if (chipType) {
+        await handleRead(async () => await getDDA5FAAsync(deviceId, hexAddress, hexLength), 7);
+      } else {
+        if (!oldAddress) return resolve(null);
+        if (needFactoryMode) await enterFactory(deviceId);
+        await handleRead(async () => await getDDA5OldAsync(deviceId, oldAddress), 4);
+      }
+    }
+    catch (error) {
+      console.error("读取参数出错---: ", error);
+      reject(error);
+    }
+  });
+};
+// #region 系统读参数处理 
+/**读参数处理 
+ * @param {*} chipType 芯片类型
+ * @param {*} deviceId 设备deviceId
+ * @param {Object} paramInfo 开始读取的参数信息
+ * @param {*} paramInfo.paramNo 新协议开始读取地址（十进制）如 31
+ * @param {*} paramInfo.paramLength 新协议读参数内容长度（内容字节数）（十进制）如 2字节，实际读取一个参数
+ * @param {*} paramInfo.oldParamNo 旧协议读取地址 默认读一个（十六进制字符串）如 '0x1f'
+ * @returns — data 读取到的参数值（只返回内容的十进制数组如[1, 2]）
+*/
+export const getSysParamCmd = async (chipType, deviceId, paramInfo, needFactoryMode = true) => {
+  try {
+    console.log('paramInfo: ', paramInfo);
+    const paramObj = {
+      address: paramInfo.paramNo,
+      length: paramInfo.paramLength / 2,
+      oldAddress: paramInfo.oldParamNo,
+    }
+    let data = await readParamCmd(chipType, deviceId, paramObj, needFactoryMode);
+    if (!data) return null;
+    // data = data.map((el)=>{
+    //   const hexValue = decimalToHex(el)
+    //   console.log('el: ------------', hexValue);
+    //   return hexValue;
+    // })
+    // console.log('data: ', data);
+    return data
+  } catch (error) {
+    console.error('error: 读系统参数报错 getSysParamCmd', error);
+    throw error
+  }
+}
+
+// #region 系统写参数处理 
+/**
+ * @param {*} chipType 芯片类型
+ * @param {*} deviceId 设备deviceId
+ * @param {Array|Object} paramInfoArray 包含多个参数信息的数组或单个参数信息对象
+ * @param {*} paramInfoArray[].newValue 新设置的参数输入值十进制值
+ * @param {*} paramInfoArray[].paramValue 新设置的参数值十进制值 部分参数输入的值需单独处理
+ * @param {*} paramInfoArray[].oldParamNo 旧协议写入地址 默认一个（十六进制字符串）如 '0x1f'
+ * @param {*} paramInfoArray[].paramNo 新协议写入地址 十进制
+ * @param {*} paramInfoArray[].paramLength 新协议写参数内容长度（内容字节数）（十进制）如 2字节，实际写入一个参数
+ * @param {*} paramInfoArray[].divisor 缩放系数（十进制）如 10
+ * @param {*} paramInfoArray[].isTemp 是否是温度参数
+*/
+export const setSysParamCmd = async (chipType, deviceId, paramInfoArray) => {
+  try {
+    console.log('paramInfoArray: ', paramInfoArray);
+
+    // 确保paramInfoArray是数组
+    const paramsToProcess = Array.isArray(paramInfoArray) ? paramInfoArray : [paramInfoArray];
+
+    // 收集所有处理后的参数对象到一个数组中
+    const paramObjs = [];
+
+    for (const paramInfo of paramsToProcess) {
+      let value = Math.round(Number(paramInfo?.paramValue || paramInfo.newValue) / Number(paramInfo?.divisor || 1));
+      console.log('value: ', value);
+      if (paramInfo.isTemp) {
+        value = 2731 + (Number(paramInfo.newValue) * 10)
+      }
+      const valuesHexs = decimalToTwoByteHexArray(value);
+      console.log('valuesHexs: ', valuesHexs);
+
+      // 将处理后的参数对象添加到数组中
+      paramObjs.push({
+        address: paramInfo.paramNo,
+        length: paramInfo.paramLength / 2,
+        values: valuesHexs,
+        oldAddress: paramInfo.oldParamNo,
+      });
+    }
+
+    // 一次性将所有参数对象数组传递给setParamCmd函数
+    await setParamCmd(chipType, deviceId, paramObjs);
+  } catch (error) {
+    console.error('error: 写系统参数报错 setSysParamCmd', error);
+    throw error
+  }
+}
+
+// #region 发指令设置参数 
+/**
+ * 发指令设置参数
+ * @param {*} chipType 芯片类型
+ * @param {*} deviceId 设备deviceId
+ * @param {Array} paramInfoArray 参数信息数组 或单个对象
+ * @param {*} paramInfoArray[].address 新协议开始写入地址（十进制）如 31
+ * @param {*} paramInfoArray[].length 新协议写参数内容长度（写几个）（十进制）如 1
+ * @param {*} paramInfoArray[].values 新设置的参数值（十六进制数组）如 ['0x00','0x10']
+ * @param {*} paramInfoArray[].oldAddress 旧协议写入地址 默认一个（十六进制字符串）如 '0x1f'
+ * @returns {Promise<Array>} 包含所有参数设置结果的数组
+ */
+export const setParamCmd = (chipType, deviceId, paramInfoArray) => {
+  console.log("chipType: 芯片", chipType);
+
+  // 确保paramInfoArray是数组
+  const paramsToProcess = Array.isArray(paramInfoArray) ? paramInfoArray : [paramInfoArray];
+
+  return new Promise(async (resolve, reject) => {
+    try {
+      // 只进入工厂一次
+      await enterFactory(deviceId);
+
+      const results = [];
+
+      // 处理所有参数
+      for (let i = 0; i < paramsToProcess.length; i++) {
+        const paramInfo = paramsToProcess[i];
+        const { address, length, values, oldAddress } = paramInfo;
+
+        /** 地址转换为16进制 */
+        const hexAddress = decimalToTwoByteHexArray(address);
+
+        // 长度转换为16进制
+        const hexLength = decimalToHex(length);
+
+        // 根据芯片类型选择不同的设置函数
+        let hex;
+        if (chipType) {
+          hex = await setDDA5FAAsync(deviceId, hexAddress, hexLength, values);
+        } else {
+          hex = await setDDA5OldAsync(deviceId, oldAddress, values);
+        }
+
+        console.log(`data: 写入第${i + 1}个参数结果`, hex);
+
+        if (!hex) {
+          throw new Error(`设置第${i + 1}个参数失败`);
+        }
+
+        results.push(hex);
+      }
+
+      // 所有参数都执行完后才退出工厂
+      await existFactory(deviceId);
+
+      // 返回所有结果
+      resolve(results);
+
+    } catch (error) {
+      console.error("设置参数出错: ", error);
+
+      try {
+        // 发生错误时也要尝试退出工厂
+        await existFactory(deviceId);
+      } catch (exitError) {
+        console.error("退出工厂模式失败: ", exitError);
+      }
+
+      reject(error);
+    }
+  });
+}
+
+// #region 写入标称容量
+/**写入标称容量 同步写入满充及循环
+ * @param {*} chipType 芯片类型
+ * @param {*} deviceId 设备deviceId
+ * @param {*} paramInfo 参数信息 
+  * @param {*} paramInfo.values 新设置的参数值（十进制）如 10000
+  * @param {*} paramInfo.address 新协议写入地址（十进制）如 1
+  * @param {*} paramInfo.oldAddress 旧协议写入地址 默认一个（十六进制字符串）如 '0x1f'
+  * @param {*} paramInfo.length 参数写入长度（十进制）如 1
+  * @returns
+ */
+export const setCapacityParamCmd = (chipType, deviceId, paramInfo) => {
+  console.log("chipType: 芯片", chipType);
+
+  return new Promise(async (resolve, reject) => {
+    const { values } = paramInfo;
+    // 循环 循环是标称的80%
+    const circular = {
+      address: 1,
+      oldAddress: "0x11",
+      values: values * 0.8,
+      length: 1,
+    };
+    // 满充 满充等于标称  旧协议没有满充
+    const full = {
+      address: 112,
+      oldAddress: "0x10",
+      values: values,
+      length: 1,
+    };
+
+    const handleSet = async (setFunction, index) => {
+      try {
+        const hex = await setFunction();
+        console.log("data: 写入参数结果", hex);
+        if (!hex) {
+          reject("设置参数失败");
+          return;
+        }
+        return hex;
+      } catch (error) {
+        console.error("设置参数出错: ", error);
+        reject(error);
+      }
+    };
+    const handleParam = async (paramObj) => {
+      const { address, oldAddress, length } = paramObj;
+      const hexValues = decimalToTwoByteHexArray(Number(paramObj.values) * 100);
+      /**  地址转换为16进制 */
+      const hexAddress = decimalToTwoByteHexArray(address);
+      // 长度转换为16进制
+      const hexLength = decimalToHex(length);
+      if (chipType) {
+        return await handleSet(() => setDDA5FAAsync(deviceId, hexAddress, hexLength, hexValues), 7);
+      } else {
+        return await handleSet(() => setDDA5OldAsync(deviceId, oldAddress, hexValues), 4);
+      }
+    };
+    try {
+      await enterFactory(deviceId);
+      const paramInfoHex = await handleParam(paramInfo);
+      const circularHex = await handleParam(circular);
+      if (chipType) {
+        const fullHex = await handleParam(full);
+      }
+      await existFactory(deviceId);
+      if (paramInfoHex) {
+        resolve(paramInfoHex);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};

package/src/core/BleDataProcess.js

@@ -0,0 +1,355 @@
+  // #region 校验----------------------------------------
+  /** 标准modbus_crc16
+   *
+   * @param {number[]} data 十六进制的数据
+   * @param {boolean} swapNeed 是否高低位交换, 默认高位在前-低位在后
+   * @returns 十进制校验位
+   */
+  export const crc16modbus = (data, swapNeed = false) => {
+    let crc = 0xffff;
+    for (let i = 0; i < data.length; i++) {
+      crc ^= data[i];
+      for (let j = 0; j < 8; j++) {
+        if (crc & 0x0001) {
+          crc = (crc >> 1) ^ 0xa001;
+        } else {
+          crc = crc >> 1;
+        }
+      }
+    }
+    // swap crc
+    if (swapNeed) crc = ((crc & 0xff) << 8) | ((crc >> 8) & 0xff);
+    return crc & 0xffff;
+  }
+  /** 生成十六进制校验位(适用于3B3C、储能协议)
+   *
+   * @param {number[]} data 十六进制的数据
+   * @param {boolean} swapNeed 是否高低位交换, 默认高位在前-低位在后
+   * @returns string[] 十六进制校验位
+   */
+  export const generateCrc16modbusCheck = (data, swapNeed = false) => {
+    const hex = crc16modbus(data, swapNeed);
+    const hexStr = decimalToHex(hex, 4);
+    return [`0x${hexStr.slice(0, 2)}`, `0x${hexStr.slice(2, 4)}`];
+  }
+
+  /** crc校验和算法
+   * 数据段内容+长度字节+状态码字节的校验和然后在取反加1
+   * @param {number[]} data 十六进制的数据
+   * @param {*} offset 求和后的偏移量
+   * @returns 十进制校验位
+   */
+  export const crcCheckSum = (data, offset = 0x01) => {
+    console.log('data: --------', data);
+    let hex = 0x00;
+    for (let i = 0; i < data.length; i++) {
+      hex = hex + (data[i] & 0x0ff);
+    }
+    hex = hex ^ 0xffff;
+    hex = hex + offset;
+    console.log('hex: -------------', hex);
+    return hex;
+  }
+
+  /** 生成校验和校验位(适用于通用板协议)
+   *
+   * @param {number[]} data 十六进制的数据 命令码、长度、内容
+   * @returns string[] 十六进制校验位
+   */
+  export const generateCrcCheckSum = (data) => {
+    const hex = crcCheckSum(data);
+    const hexStr = decimalToHex(hex, 4);
+    return [`0x${hexStr.slice(0, 2)}`, `0x${hexStr.slice(2, 4)}`];
+  }
+
+  /** FFAA协议校验算法
+   *
+   * @param {number[]} data 十六进制的数据
+   * @returns 十进制校验位
+   */
+  export const checkSum = (data = []) => {
+    const sum = data.map((o) => parseInt(o, 16)).reduce((a, c) => a + c, 0);
+    let sumHex = '0x' + decimalToHex(sum, 2);
+    // 取低8位
+    sumHex = sumHex & 0xff;
+    return sumHex;
+  }
+
+  /**生成校验和校验位(适用于FFAA指令协议)
+   *
+   * @param {number[]} data 十六进制的数据
+   * @returns string[] 十六进制校验位
+   */
+  export const generateCheckSum = (data) => {
+    const hex = checkSum(data);
+    const hexStr = decimalToHex(hex, 2);
+    return [`0x${hexStr}`];
+  }
+
+  // #region Buffer 数据转换-------------------------------------------
+
+  /** ArrayBuffer转换为十进制数字数组
+   *
+   * @param {ArrayBuffer} buffer
+   * @returns number[] 十进制数字数组
+   */
+  export const ab2decimalArr = (buffer) => {
+    return Array.prototype.map.call(new Uint8Array(buffer), (bit) => bit);
+  }
+  /** ArrayBuffer转换为十六进制字符串
+   *
+   * @param {ArrayBuffer} buffer
+   * @returns string 十六进制字符串
+   */
+
+  export const ab2hex = (buffer) => {
+    const hexArr = Array.prototype.map.call(
+      new Uint8Array(buffer),
+      function (bit) {
+        return ('00' + bit.toString(16)).slice(-2)
+      }
+    )
+    return hexArr.join('')
+  }
+  /** ArrayBuffer转16进制数组
+   *
+   * @param {ArrayBuffer} arrayBuffer
+   * @param {boolean} withPrefix
+   * @returns string[] 十六进制数组
+   */
+
+  export const arrayBufferToHexArray = (arrayBuffer, withPrefix = true) => {
+    return Array.prototype.map.call(new Uint8Array(arrayBuffer), (x) => {
+      let hex = ('00' + x.toString(16)).slice(-2);
+      return withPrefix ? `0x${hex}` : hex;
+    });
+  }
+  /** Base64转16进制数组
+   *
+   * @param {string} base64
+   * @param {boolean} withPrefix
+   * @returns string[] 十六进制数组
+   */
+
+  export const base64ToHexArray = (base64, withPrefix = true) => {
+    const arrayBuffer = uni.base64ToArrayBuffer(base64);
+    return arrayBufferToHexArray(arrayBuffer, withPrefix);
+  }
+  // 将HexArray转成Module指定格式的ArrayBuffer
+  export const hexArrayToModuleArrayBuffer = (fields, hexArray, withCheck = true, withPrefix = true) => {
+    const fieldsLength = fields.length; //e.g [0xff, 0xaa, 0x80]: 包头(2Byte)  指令码(1Byte)
+    let offset = fieldsLength + 1; // +1 for data length
+    if (withCheck) offset++; // check
+
+    let bufferLength = hexArray.length + offset;
+    const buffer = new ArrayBuffer(bufferLength);
+    const dataView = new DataView(buffer);
+    const lengthCode = decimalToHex(hexArray.length);
+
+    // 包头&指令码
+    fields.forEach((field, i) => {
+      dataView.setUint8(i, field);
+    });
+    // 数据位长度
+    dataView.setUint8(fieldsLength, '0x' + lengthCode);
+    // 数据位
+    let indexNum = fieldsLength + 1;
+    hexArray.forEach((el, index) => {
+      dataView.setUint8(indexNum, withPrefix ? '0x' + el : el);
+      indexNum += 1;
+    });
+    // 校验位
+    if (withCheck) {
+      const code = fields[2].toString(16); //
+      let check = generateCheckSum([code, lengthCode, ...hexArray]);
+      dataView.setUint8(bufferLength - 1, check[0]);
+    }
+    return buffer;
+  }
+
+  // #region 进制转换------------------------------------------
+  /**
+   * 获取参数的基础值
+   * 将参数十六进制内容数组转换为十进制数值
+   * @param {*} arr 
+   * @returns 
+   */
+  export const getParamBaseValue = (arr) => { 
+    // 将有效的字节转换为十六进制字符串
+    const hexString = arr.map(el => decimalToHex(el)).join('');
+    let value = parseInt(hexString, 16); // 转为十进制
+    return value;
+  }
+  /** 十进制转十六进制
+   *
+   * @param {number} decimal 十进制数字
+   * @param {*} padding 补零长度
+   * @returns 十六进制字符串
+   */
+  export const decimalToHex = (decimal, padding = 2) => {
+    const hex = Number(decimal).toString(16).padStart(padding, '0');
+    return hex;
+  }
+  /** 十进制转十六进制
+   * *
+   * @param {number} decimal 十进制数字
+   * @param {*} padding 补零长度
+   * @returns 0x + 十六进制字符串
+   */
+  export const  decimalToHex0x = (decimal, padding = 2) => {
+    const hex = Number(decimal).toString(16).padStart(padding, "0");
+    return "0x" + hex;
+  }
+  /** 十六进制转十进制 */ 
+  export const hexToDecimal = (hex) => {
+    const decimal = parseInt(hex, 16)
+    return decimal;
+  }
+  /** 十六进制数据的数组转为ArrayBuffer
+   *
+   * @param {(string|number)[]} hexArr 十六进制数据的数组
+   * @returns ArrayBuffer
+   */
+  export const hexArr2ab = (hexArr) => {
+    const buffer = new ArrayBuffer(hexArr.length);
+    const dataView = new DataView(buffer);
+    hexArr.forEach((hex, i) => dataView.setUint8(i, hex));
+    return buffer;
+  }
+
+  /** 十六进制转十六进制字符串
+   *
+   * @param {string|number} hex 十六进制数据
+   * @returns string 十六进制数据对应的字符串
+   */
+  export const hex2string = (hex) => {
+    return ('00' + hex.toString(16)).slice(-2).toUpperCase();
+  }
+  /** 字符串转十六进制
+   *
+   * @param {string} str
+   * @returns 十六进制数组
+   */
+  export const string2hexArr = (str) => {
+    let hexArray = [];
+    for (let i = 0; i < str.length; i++) {
+      const charCode = str.charCodeAt(i).toString(16).padStart(2, '0');
+      hexArray.push(charCode);
+    }
+    return hexArray;
+  }
+
+  /** 十六进制转ASSIC
+   *
+   * @param {(string|number)[]} hexArr
+   * @returns string
+   */
+  export const hexArr2Assic = (hexArr = []) => {
+    return String.fromCharCode(...hexArr).replace(/\u0000/g, '');
+  }
+
+  /** 十六进制字符串转ASSIC
+   *
+   * @param {string} hexString
+   * @returns string
+   */
+
+  export const hexStrAscii = (hexString) => {
+    let asciiString = '';
+    for (let i = 0; i < hexString.length; i += 2) {
+      const hexPair = hexString.substr(i, 2);
+      const decimalValue = parseInt(hexPair, 16);
+      asciiString += String.fromCharCode(decimalValue);
+    }
+    const result = asciiString.replace(/\u0000/g, '');
+
+    return result;
+  }
+  /** 十六进制转ASSIC
+   *
+   * @param {string} hexArr
+   * @returns string
+   */
+  export const hex2Ascii = (value = []) => {
+    const hexString = value.join('');
+    return hexStrAscii(hexString)
+  }
+  /** 十六进制数据的数组转为字符串
+   *
+   * @param {(string|number)[]} hexArr 十六进制数据的数组
+   * @returns string 十六进制字符串 e.g:3B3C000000000000000001160104000201000200030A444830342E312E342E370400775A0D
+   */
+  export const hexArr2string = (hexArr = [], connector = '') => {
+    return hexArr.map((o) => hex2string(o)).join(connector);
+  }
+
+  /** 十六进制转二进制
+   *
+   * @param {*} hex
+   * @returns
+   */
+  export const hex2Binary = (hex, len = 0) => {
+    return parseInt(hex, 16).toString(2).padStart(len, '0');
+  }
+  /**
+   * 计算Bit位区间值（包头包尾）
+   * 例如：计算Bit7-Bit11的值
+   * @param number 十进制数值
+   * @param start 开始位（从0开始）
+   * @param end 结束位
+   * @examples extractBits(a, 7, 11)
+   */
+  export const extractBits = (number, start, end) => {
+    // 创建掩码，使用(1<<n)-1来创建n位的掩码
+    let mask = (1 << (end - start + 1)) - 1;
+    // 右移去掉低位，并应用掩码以提取位
+    return (number >> start) & mask;
+  }
+  /**计时器 等待n毫秒
+   * @param {number} n 毫秒
+   */
+  export const sleep = (n = 500) => {
+    return new Promise((r) => setTimeout(() => r(true), n));
+  }
+  /**
+ * 十进制数转换为两个字节的十六进制数组
+ * @param {number} decimal 十进制数，范围 0 - 65535
+ * @returns {Array} 包含两个字节十六进制字符串的数组
+ */
+  export const decimalToTwoByteHexArray = (decimal) => {
+    // 添加类型和整数检查
+    if (typeof decimal !== 'number' || !Number.isInteger(decimal)) {
+      throw new Error('输入必须为整数');
+    }
+    if (decimal < 0 || decimal > 65535) {
+      throw new Error('输入的十进制数超出 16 位无符号整数范围（0 - 65535）');
+    }
+    let f = `00${(decimal >> 8).toString(16)}`.slice(-2);
+    let e = `00${(decimal & 0xff).toString(16)}`.slice(-2);
+    return [`0x${f}`, `0x${e}`];
+  }
+
+  /**
+   * 将十六进制字符串转换为两个十六进制的数组
+   * @param {string} str 要转换的字符串 '1881'
+   * @returns {string[]} 转换后的十六进制数组 ['0x18', '0x81']
+   */
+  export const stringToTwoHexArray = (str) => {
+    // 确保字符串长度为 4
+    const paddedStr = str.padStart(4, '0');
+    return [
+      `0x${paddedStr.slice(0, 2)}`,
+      `0x${paddedStr.slice(2, 4)}`
+    ];
+  }
+  /**
+   * 将十六进制字符串转换为二进制字符串
+   * @param {string} hexString 要转换的十六进制字符串
+   * @returns {string} 转换后的二进制字符串
+   */
+  export const hexStringToBinary = (hexString) => {
+    const decimalNumber = parseInt(hexString, 16);
+    const binaryString = decimalNumber.toString(2);
+    return binaryString;
+  }
+