Версия для печати темы

#include <Keyboard.h>
int i = 0;
int trigerKey = 0;
int lengthStr = 0;
int key[20];
int tmDelayValue;
String tmDelayStr;

void setup() {
  Serial.begin(9600);
  Keyboard.begin();
}
 
void loop() {
  // Собираем информацию из порта
  while (Serial.available()) {
    key[i++] = Serial.read();
    delay(5);
  } 
  // Триггер, что данные пришли
  if (i != 0 && lengthStr == 0){
    lengthStr = i;
    i = 0;
  }
  
  if (lengthStr != 0){
    
    for (i = 0; i <= lengthStr; i++){
      delay(5);
//Находим задержку с которой необходимо нажимать кнопки
      if (trigerKey == 0){
        if (key[i] == 124){
          tmDelayValue = tmDelayStr.toInt();
          trigerKey = 1;
          i++;
        } 
        else {
          tmDelayStr += char (key[i]);
        }
      }

//Находим и нажимаем спец кнопки если необходимо
      if (trigerKey == 1){
        if (key[i] == 94){Keyboard.press(KEY_LEFT_CTRL);}    //94 - символ "^"
        if (key[i] == 64){Keyboard.press(KEY_LEFT_ALT);}     //64 - символ "@" 
        if (key[i] == 126){Keyboard.press(KEY_LEFT_SHIFT);}  //126 - символ "~"
        if (key[i] == 124){trigerKey = 2; i++;}              //124 - символ "|"
      }

//Нажимаем по очереди остальные кнопки с задержкой
      if (trigerKey == 2){
        delay(tmDelayValue);
        Keyboard.print(char (key[i]));
      }
    }
// Сбрасываем все
    Keyboard.releaseAll();
    i = 0;
    trigerKey = 0;
    lengthStr = 0;
    tmDelayStr = "";
  }
}

--lua
local hw = require'arduino'
hw.com = hw.get_port (2341, 8036)    -- указать vid и pid ардуино
 if hw.com < 1 then   -- если номер порта меньше 1
     log ('error = ' .. tostring(hw.com))    -- код ошибки, если 0 значит устройство с указанными vip и pid не найдено
     end_script ()
 end
hw.set_delay_key (20)     -- установить паузу между нажатиями клавиш клавиатуры
hw.set_random_delay_key(10)  -- установить рандом между нажатием и отпускание клавиш
-- т. е. между нажатием и отпусканием клавиши будет пауза от 20 до 29 мсек

wait (3000)    -- пауза 3 секунды чтобы переключиться на нужное окно
hw.key ('k')    -- нажать клавишу 'k'
hw.key (hw.enter)  -- нажать 'Enter'

wait (1000)   -- пауза 1 сек.

hw.key_down ('s')   -- зажать клавишу 's'
wait (3000)         -- пауза 3 сек., при этом клавиша будет зажата
hw.key_up ('s')     -- отпустить клавишу 's'
hw.key (hw.enter)   -- нажать 'Enter'

hw.text ('Hello Привет')  -- напечатать текст
hw.key ('V')    -- нажать Shift+'v'

--lua
local hw = require'arduino'
hw.com = hw.get_port (2341, 8036)    -- указать vid и pid ардуино
 if hw.com < 1 then   -- если номер порта меньше 1
     log ('error = ' .. tostring(hw.com))    -- код ошибки
     end_script ()
 end
hw.set_delay_mouse (20)   -- установить паузу между нажатиями клавиш мыши
hw.set_offset_mousemove(4)  -- шаг перемещения курсора
hw.set_random_delay_mouse(10)  -- установить рандом между нажатиями клавиш мыши
-- т. е. между нажатием и отпусканием кнопки мыши будет пауза от 20 до 29 мсек.

hw.mouse.left (200, 100)      -- клик левой кнопкой мыши в координатах 200, 100
hw.mouse.right (200, 100)     -- клик правой кнопкой мыши
wait (3000)                   -- пауза 3 секунды
hw.mouse.left_dbl (35, 35)    -- двойной клик левой кнопкой мыши
wait (2000)
hw.mouse.left_down (200, 200) -- зажать левую кнопку мыши
wait(500)
hw.mouse.left_up (900, 300)   -- отпустить левую кнопку мыши

#include <Keyboard.h>
#include <stdlib.h>

// Максимальный размер буффера
#define MAX_BUFFER_SIZE 20
// Порт
#define SERIAL_PORT 9600
// Задержка считывания с порта
#define SERIAL_READ_DELAY 5
// Задержка нажатия клавиш по умолчанию
#define DEFAULT_SEND_DELAY 0

void setup() {
    Serial.begin(SERIAL_PORT);
    Keyboard.begin();
}

void loop() {
    // буффер под коммандную строку
    char buffer[MAX_BUFFER_SIZE];
    // размер полученного буфера
    int buffSize = 0;
    // текущая позиция в буффере
    int buffPos = 0;
    // задержка нажатия клавиш
    int send_delay_value = DEFAULT_SEND_DELAY;

    // Собираем информацию из порта
    while (Serial.available() && buffSize < MAX_BUFFER_SIZE) {
        buffer[buffSize++] = Serial.read();
        delay(SERIAL_READ_DELAY);
    }

    // если данные пришли
    if (buffSize > 0) {
        // пытаемся сначала выбрать задержку 
        send_delay_value = parseSendDelay(buffPos, buffer, buffSize);
        // разбор и нажатие контрольных клавиш
        sendControlKeys(buffPos, buffer, buffSize);
        // нажатие клавиш
        while (buffPos < buffSize) {
            delay(send_delay_value);
            Keyboard.print(buffer[buffPos++]);
        };

        // очистка
        Keyboard.releaseAll();
        buffPos = 0;
        buffSize = 0;
    }
}

// парсинг задержки отправки клавиш
int parseSendDelay(int* curPos, char* buff, int buffSize) {
    // идем по полученным данным пока не встретим разделитель
    while (buff[*curPos] != '|') {
        ++*curPos;
    }
    // далее получаем задержку в числовом виде
    // не очень красиво, но должно работать.

    // заменяем | на символ конца строки
    buff[*curPos] = '\0';
    // получаем задержку
    int parsedDelay = atoi(buff);
    // возвращаем если нужно
    //data[*curPos] = '\|';
    
    // пропуск разделителя
    ++*curPos;

    //возврат
    return parsedDelay;
}

// парсинг клавиши
int parseKey(int *curPos, const char *buff, int buffSize) {
    switch (buff[(*curPos)++])
    {
    case '^':
        return KEY_LEFT_CTRL;
    case '@':
        return KEY_LEFT_ALT;
    case '~':
        return KEY_LEFT_SHIFT;
    default:
        return -1;
    }
}


// нажатие контрольных клавиш
void sendControlKeys(int *curPos, const char* buff, int buffSize) {
    // пока не встретили разделитель
    while (buff[(*curPos)++] != '|') {
        // попытка распарсить управляющую клавишу
        int key = parseKey(curPos, buff, buffSize);
        // если успешно
        if (key > 0) {
            Keyboard.press(key);
        }
    }
    // пропускаем разделитель
    ++*curPos;
}

#include <Keyboard.h>
#include <stdlib.h>

// Максимальный размер буффера
#define MAX_BUFFER_SIZE 20
// Порт
#define SERIAL_PORT 9600
// Задержка считывания с порта
#define SERIAL_READ_DELAY 5
// Задержка нажатия клавиш по умолчанию
#define DEFAULT_SEND_DELAY 0

void setup() {
    Serial.begin(SERIAL_PORT);
    Keyboard.begin();
}

void loop() {
    // буффер под коммандную строку
    char buffer[MAX_BUFFER_SIZE];
    // размер полученного буфера
    int buffSize = 0;
    // текущая позиция в буффере
    int buffPos = 0;
    // задержка нажатия клавиш
    int send_delay_value = DEFAULT_SEND_DELAY;

    // Собираем информацию из порта
    while (Serial.available() && buffSize < MAX_BUFFER_SIZE) {
        buffer[buffSize++] = Serial.read();
        delay(SERIAL_READ_DELAY);
    }

    // если данные пришли
    if (buffSize > 0) {
        // пытаемся сначала выбрать задержку 
        send_delay_value = parseSendDelay(buffPos, buffer, buffSize);
        // разбор и нажатие контрольных клавиш
        sendControlKeys(buffPos, buffer, buffSize);
        // нажатие клавиш
        while (buffPos < buffSize) {
            delay(send_delay_value);
            Keyboard.print(buffer[buffPos++]);
        };

        // очистка
        Keyboard.releaseAll();
        buffPos = 0;
        buffSize = 0;
    }
}

// парсинг задержки отправки клавиш
int parseSendDelay(int* curPos, char* buff, int buffSize) {
    // идем по полученным данным пока не встретим разделитель
    while (buff[*curPos] != '|') {
        ++*curPos;
    }
    // далее получаем задержку в числовом виде
    // не очень красиво, но должно работать.

    // заменяем | на символ конца строки
    buff[*curPos] = '\0';
    // получаем задержку
    int parsedDelay = atoi(buff);
    // возвращаем если нужно
    //data[*curPos] = '\|';
    
    // пропуск разделителя
    ++*curPos;

    //возврат
    return parsedDelay;
}

// парсинг клавиши
int parseKey(int *curPos, const char *buff, int buffSize) {
    switch (buff[(*curPos)++])
    {
    case '^':
        return KEY_LEFT_CTRL;
    case '@':
        return KEY_LEFT_ALT;
    case '~':
        return KEY_LEFT_SHIFT;
    default:
        return -1;
    }
}


// нажатие контрольных клавиш
void sendControlKeys(int *curPos, const char* buff, int buffSize) {
    // пока не встретили разделитель
    while (buff[(*curPos)++] != '|') {
        // попытка распарсить управляющую клавишу
        int key = parseKey(curPos, buff, buffSize);
        // если успешно
        if (key > 0) {
            Keyboard.press(key);
        }
    }
    // пропускаем разделитель
    ++*curPos;
}

#include <Keyboard.h>
#include <stdlib.h>

// Максимальный размер буффера
#define MAX_BUFFER_SIZE 20
// Порт
#define SERIAL_PORT 9600
// Задержка считывания с порта
#define SERIAL_READ_DELAY 5
// Задержка нажатия клавиш по умолчанию
#define DEFAULT_SEND_DELAY 0

void setup() {
    Serial.begin(SERIAL_PORT);
    Keyboard.begin();
}

void loop() {
    // буффер под коммандную строку
    char buffer[MAX_BUFFER_SIZE];
    // размер полученного буфера
    int buffSize = 0;
    // текущая позиция в буффере
    int buffPos = 0;
    // задержка нажатия клавиш
    int send_delay_value = DEFAULT_SEND_DELAY;

    // Собираем информацию из порта
    while (Serial.available() && buffSize < MAX_BUFFER_SIZE) {
        buffer[buffSize++] = Serial.read();
        delay(SERIAL_READ_DELAY);
    }

    // если данные пришли
    if (buffSize > 0) {
        // пытаемся сначала выбрать задержку 
        send_delay_value = parseSendDelay(&buffPos, buffer, buffSize);
        // разбор и нажатие контрольных клавиш
        sendControlKeys(&buffPos, buffer, buffSize);
        // нажатие клавиш
        while (buffPos < buffSize) {
            delay(send_delay_value);
            Keyboard.print(buffer[buffPos++]);
        };

        // очистка
        Keyboard.releaseAll();
        buffPos = 0;
        buffSize = 0;
    }
}

// парсинг задержки отправки клавиш
int parseSendDelay(int* curPos, char* buff, int buffSize) {
    // идем по полученным данным пока не встретим разделитель
    while (buff[*curPos] != '|') {
        ++*curPos;
    }
    // далее получаем задержку в числовом виде
    // не очень красиво, но должно работать.

    // заменяем | на символ конца строки
    buff[*curPos] = '\0';
    // получаем задержку
    int parsedDelay = atoi(buff);
    // возвращаем если нужно
    //data[*curPos] = '\|';
    
    // пропуск разделителя
    ++*curPos;

    //возврат
    return parsedDelay;
}

// парсинг клавиши
int parseKey(int *curPos, const char *buff, int buffSize) {
    switch (buff[*curPos])
    {
    case '^':
        return KEY_LEFT_CTRL;
    case '@':
        return KEY_LEFT_ALT;
    case '~':
        return KEY_LEFT_SHIFT;
    default:
        return -1;
    }
}


// нажатие контрольных клавиш
void sendControlKeys(int *curPos, const char* buff, int buffSize) {
    // пока не встретили разделитель
    while (buff[*curPos] != '|') {
        // попытка распарсить управляющую клавишу
        int key = parseKey(curPos, buff, buffSize);
        // если успешно
        if (key > 0) {
            Keyboard.press(key);
        }
        // следующий байт
        ++*curPos;
    }
    // пропускаем разделитель
    ++*curPos;
}

#include <Keyboard.h>
#include <stdlib.h>


/* Настройки железки*/
#define MAX_BUFFER_SIZE 20 // Максимальный размер буффера
#define SERIAL_PORT 9600 // Порт
#define SERIAL_READ_DELAY 5 // Задержка считывания с порта
#define DEFAULT_SEND_DELAY 0 // Задержка нажатия клавиш по умолчанию


/* Кастомизация спец. символов */
#define SEND_DELAY_START_CHAR '['
#define SEND_DELAY_END_CHAR ']'
#define CONTROL_KEY_CTRL_CHAR '^'
#define CONTROL_KEY_ALT_CHAR '@'
#define CONTROL_KEY_SHIFT_CHAR '~'
#define ESCAPE_CHAR '\\'
#define EOF_CHAR '\0'


/* Ввод парсера (для построения матрицы) */
#define SEND_DELAY_START_INPUT 0 
#define SEND_DELAY_END_INPUT 1
#define CONTROL_KEY_CTRL_INPUT 2
#define CONTROL_KEY_ALT_INPUT 3
#define CONTROL_KEY_SHIFT_INPUT 4
#define ESCAPE_CHAR_INPUT 5
#define CHAR_INPUT 6
#define DIGIT_INPUT 7
#define EOF_INPUT 8

#define MAX_INPUT_INDEX EOF_INPUT

/* Состояния парсера */
#define SEND_DELAY_INPUT 0 // начат ввод задержки ввода символов
#define ESCAPE_INPUT 1 // начат ввод управляющих клавиш
#define SEND_INPUT 2 // начат ввод обычных символов
#define SEND_END 3 // ввод окончен

#define MAX_STATE_INDEX SEND_END


/* Глобальные переменные */
int SEND_DELAY_VALUE = DEFAULT_SEND_DELAY; // задержка нажатия клавиш
char BUFFER[MAX_BUFFER_SIZE]; // буффер под задержку
int BUFFER_POS = 0; // позиция в буффере
char ESCAPE_CHAR_VALUE = '\0'; // сохраненный экран




// начать ввод задержки
int startSendDelayInput(char c) {
    return SEND_DELAY_INPUT;
}

// закончить ввод задержки и распарсить ее
int stopSendDelayInput(char c) {
    BUFFER[BUFFER_POS + 1] = '\0';
    SEND_DELAY_VALUE = atoi(BUFFER);
    BUFFER_POS = 0;
    return SEND_INPUT;
}

// запись в буффер
int storeChar(char c) {
    if (BUFFER_POS < MAX_BUFFER_SIZE - 2) {
        BUFFER[BUFFER_POS++] = c;
    }

    // возвращаем новое состояние парсера
    return SEND_DELAY_INPUT;
}

// отправка клавиши
int sendChar(char c) {
    delay(SEND_DELAY_VALUE);
    Keyboard.print(c);
    return SEND_INPUT;
}

// нажатие контрольной клавиши
int sendControlKey(char c) {
    switch (c)
    {
    case CONTROL_KEY_CTRL_CHAR:
        Keyboard.press(KEY_LEFT_CTRL);
        break;
    case CONTROL_KEY_ALT_CHAR:
        Keyboard.press(KEY_LEFT_ALT);
        break;
    case CONTROL_KEY_SHIFT_CHAR:
        Keyboard.press(KEY_LEFT_SHIFT);
        break;
    }
    return SEND_INPUT;
}

// обработка экрана
int processEscape(char c) {
    switch (c)
    {
    case SEND_DELAY_START_CHAR:
        sendChar(c);
        break;
    case SEND_DELAY_END_CHAR:
        sendChar(c);
        break;
    case CONTROL_KEY_CTRL_CHAR:
        sendChar(c);
        break;
    case CONTROL_KEY_ALT_CHAR:
        sendChar(c);
        break;
    case CONTROL_KEY_SHIFT_CHAR:
        sendChar(c);
        break;
    default: {
        // не можем экранировать
        sendChar(ESCAPE_CHAR_VALUE);
        sendChar(c);
    }
    }
    return SEND_INPUT;
}


// сохранение экрана
int storeEscapeChar(char c) {
    ESCAPE_CHAR_VALUE = c;
    return ESCAPE_INPUT;
}

// конец ввода
int stopSend(char c) {
    BUFFER_POS = 0;
    Keyboard.releaseAll();
    return SEND_END;
}



// матрица операций парсера
int(*PARSE_ACTION_MAP[MAX_STATE_INDEX + 1][MAX_INPUT_INDEX + 1])(char) = {
    // SEND_DELAY_INPUT ->
    { NULL, &stopSendDelayInput, NULL, NULL, NULL, NULL, NULL, &storeChar, &stopSend },
    // ESCAPE_INPUT ->
    { &processEscape, &processEscape, &processEscape, &processEscape, &processEscape, &processEscape, &processEscape, &processEscape, &stopSend },
    // SEND_INPUT ->
    { &startSendDelayInput, &sendChar, &sendControlKey, &sendControlKey, &sendControlKey, &storeEscapeChar, &sendChar, &sendChar, &stopSend },
    // SEND_END ->
    { &startSendDelayInput, &sendChar, &sendControlKey, &sendControlKey, &sendControlKey, &storeEscapeChar, &sendChar, &sendChar, &stopSend }
};



// классификатор вводимых символов
int getInput(char c) {
    switch (c)
    {
    case SEND_DELAY_START_CHAR:
        return SEND_DELAY_START_INPUT;
    case SEND_DELAY_END_CHAR:
        return SEND_DELAY_END_INPUT;
    case CONTROL_KEY_CTRL_CHAR:
        return CONTROL_KEY_CTRL_INPUT;
    case CONTROL_KEY_ALT_CHAR:
        return CONTROL_KEY_ALT_INPUT;
    case CONTROL_KEY_SHIFT_CHAR:
        return CONTROL_KEY_SHIFT_INPUT;
    case ESCAPE_CHAR:
        return ESCAPE_CHAR_INPUT;
    case EOF_CHAR:
        return EOF_INPUT;
    default:
        if (isdigit(c))
            return DIGIT_INPUT;
        else
            return CHAR_INPUT;
    }
}



void setup() {
    Serial.begin(SERIAL_PORT);
    Keyboard.begin();
}

void loop() {
    // состояние парсера
    int parserState = SEND_END;

    // если буффер не пустой
    if (Serial.available()) {
        // читаем байт из потока
        char curChar = Serial.read();
        // определяем что пришло
        int input = getInput(curChar);
        // получаем действие
        int(*action)(char) = PARSE_ACTION_MAP[parserState][input];

        // если действие задано
        if (action != NULL)
            parserState = action(curChar);
    }
}

/*
  Keyboard.h
  Copyright (c) 2015, Arduino LLC
  Original code (pre-library): Copyright (c) 2011, Peter Barrett
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef KEYBOARD_h
#define KEYBOARD_h

#include "HID.h"

#if !defined(_USING_HID)

#warning "Using legacy HID core (non pluggable)"

#else

// ================================================================================

// ================================================================================

//  Keyboard

#define KEY_LEFT_CTRL   0x80
#define KEY_LEFT_SHIFT    0x81
#define KEY_LEFT_ALT    0x82
#define KEY_LEFT_GUI    0x83
#define KEY_RIGHT_CTRL    0x84
#define KEY_RIGHT_SHIFT   0x85
#define KEY_RIGHT_ALT   0x86
#define KEY_RIGHT_GUI   0x87

#define KEY_UP_ARROW    0xDA
#define KEY_DOWN_ARROW    0xD9
#define KEY_LEFT_ARROW    0xD8
#define KEY_RIGHT_ARROW   0xD7
#define KEY_BACKSPACE   0xB2
#define KEY_TAB       0xB3
#define KEY_RETURN      0xB0
#define KEY_ESC       0xB1
#define KEY_INSERT      0xD1
#define KEY_DELETE      0xD4
#define KEY_PAGE_UP     0xD3
#define KEY_PAGE_DOWN   0xD6
#define KEY_HOME      0xD2
#define KEY_END       0xD5
#define KEY_CAPS_LOCK   0xC1
#define KEY_F1        0xC2
#define KEY_F2        0xC3
#define KEY_F3        0xC4
#define KEY_F4        0xC5
#define KEY_F5        0xC6
#define KEY_F6        0xC7
#define KEY_F7        0xC8
#define KEY_F8        0xC9
#define KEY_F9        0xCA
#define KEY_F10       0xCB
#define KEY_F11       0xCC
#define KEY_F12       0xCD
#define KEY_F13       0xF0
#define KEY_F14       0xF1
#define KEY_F15       0xF2
#define KEY_F16       0xF3
#define KEY_F17       0xF4
#define KEY_F18       0xF5
#define KEY_F19       0xF6
#define KEY_F20       0xF7
#define KEY_F21       0xF8
#define KEY_F22       0xF9
#define KEY_F23       0xFA
#define KEY_F24       0xFB


//  Low level key report: up to 6 keys and shift, ctrl etc at once
typedef struct
{
  uint8_t modifiers;
  uint8_t reserved;
  uint8_t keys[6];
} KeyReport;

class Keyboard_ : public Print
{
private:
  KeyReport _keyReport;
  void sendReport(KeyReport* keys);
public:
  Keyboard_(void);
  void begin(void);
  void end(void);
  size_t write(uint8_t k);
  size_t write(const uint8_t *buffer, size_t size);
  size_t press(uint8_t k);
  size_t release(uint8_t k);
  void releaseAll(void);
};
extern Keyboard_ Keyboard;

#endif
#endif

local export_array = {}

export_array.com = 5          -- номер порта
export_array.delay_key = 20   -- пауза между нажатиями клавиш. Только чтение, изменение через set_delay_key.
export_array.delay_mouse = 20 -- пауза между нажатием и отпусканием кнопок мыши. Только чтение, изменение через set_delay_mouse.

export_array.mouse_left_button = 1
export_array.mouse_right_button = 2
export_array.mouse_middle_button = 4

export_array.left_ctrl = 0x80
export_array.left_shift = 0x81
export_array.left_alt = 0x82
export_array.left_gui = 0x83
export_array.right_ctrl = 0x84
export_array.right_shift = 0x85
export_array.right_alt = 0x86
export_array.right_gui = 0x87
export_array.up_arrow = 0xDA
export_array.down_arrow = 0xD9
export_array.left_arrow = 0xD8
export_array.right_arrow = 0xD7
export_array.backspace = 0xB2
export_array.tab = 0xB3
export_array["return"] = 0xB0
export_array.esc = 0xB1
export_array.insert = 0xD1
export_array.delete = 0xD4
export_array.page_up = 0xD3
export_array.page_down = 0xD6
export_array.home = 0xD2
export_array["end"] = 0xD5
export_array.caps_lock = 0xC1
export_array.f1 = 0xC2
export_array.f2 = 0xC3
export_array.f3 = 0xC4
export_array.f4 = 0xC5
export_array.f5 = 0xC6
export_array.f6 = 0xC7
export_array.f7 = 0xC8
export_array.f8 = 0xC9
export_array.f9 = 0xCA
export_array.f10 = 0xCB
export_array.f11 = 0xCC
export_array.f12 = 0xCD
export_array.F1 = 0xC2
export_array.F2 = 0xC3
export_array.F3 = 0xC4
export_array.F4 = 0xC5
export_array.F5 = 0xC6
export_array.F6 = 0xC7
export_array.F7 = 0xC8
export_array.F8 = 0xC9
export_array.F9 = 0xCA
export_array.F10 = 0xCB
export_array.F11 = 0xCC
export_array.F12 = 0xCD

local command = function (text)
    local file = io.open("COM" .. tostring(COM),"w")
    if file then
        file:write(text)
        file:close()
        wait(#text * (export_array.delay_key + export_array.delay_key * 0.2))    -- количество символов * пауза + 20%
    else
    log('Порт не открылся, скрипт остановлен')
    end_script()
    end
end


export_array.set_delay_key = function (ms)
    if type(tonumber(ms)) ~= 'number' then return end
    command ('00' .. tostring(ms))
    export_array.delay_key = ms
end

export_array.set_delay_mouse = function (ms)
    if type(tonumber(ms)) ~= 'number' then return end
    command ('01' .. tostring(ms))
    export_array.delay_mouse = ms
end

export_array.key = function (code)
     if type(code) == 'number' then command ('1' .. tostring(tonumber(code)))
     else command ('1' .. tostring(code:byte()))
     end
end


export_array.text = function (text)
     command ('2' .. text)
end


export_array.key_down = function (code)
     if type(code) == 'number' then command ('3' .. tostring(tonumber(code)))
     else command ('3' .. tostring(code:byte()))
     end
end

export_array.key_up = function (code)
     if type(code) == 'number' then command ('4' .. tostring(tonumber(code)))
     else command ('4' .. tostring(code:byte()))
     end
end




export_array.mouse = {}


export_array.mouse.move = function (x, y)
    local mouseX, mouseY = mouse_pos('abs')
    local znakX, znakY = '+', '+'
    if mouseX - x > 0 then znakX = '-' end
    if mouseY - y > 0 then znakY = '-' end
    command ('5' .. znakX .. znakY .. tostring(math.abs(mouseX - x) * 0xFFFF + math.abs(mouseY - y)))
end


export_array.mouse.click = function (x, y, button)
    if button == nil then button = export_array.mouse_left_button end
    export_array.mouse.move(x, y)
    command ('6' .. tostring(button))
end

export_array.mouse.left = function (x, y)
    export_array.mouse.move(x, y)
    command ('6' .. tostring(export_array.mouse_left_button))
end

export_array.mouse.right = function (x, y)
    export_array.mouse.move(x, y)
    command ('6' .. tostring(export_array.mouse_right_button))
end

export_array.mouse.middle = function (x, y)
    export_array.mouse.move(x, y)
    command ('6' .. tostring(export_array.mouse_middle_button))
end



export_array.mouse.dbl = function (x, y, button)
    if button == nil then button = export_array.mouse_left_button end
    export_array.mouse.move(x, y)
    command ('6' .. tostring(button))
    wait(100)
    command ('6' .. tostring(button))
end

export_array.mouse.left_dbl = function (x, y)
    export_array.mouse.move(x, y)
    command ('6' .. tostring(export_array.mouse_left_button))
    wait(100)
    command ('6' .. tostring(export_array.mouse_left_button))
end

export_array.mouse.right_dbl = function (x, y)
    export_array.mouse.move(x, y)
    command ('6' .. tostring(export_array.mouse_right_button))
    wait(100)
    command ('6' .. tostring(export_array.mouse_right_button))
end

export_array.mouse.middle_dbl = function (x, y)
    export_array.mouse.move(x, y)
    command ('6' .. tostring(export_array.mouse_middle_button))
    wait(100)
    command ('6' .. tostring(export_array.mouse_middle_button))
end



export_array.mouse.down = function (x, y, button)
    if button == nil then button = export_array.mouse_left_button end
    export_array.mouse.move(x, y)
    command ('7' .. tostring(button))
end

export_array.mouse.left_down = function (x, y)
    export_array.mouse.move(x, y)
    command ('7' .. tostring(export_array.mouse_left_button))
end

export_array.mouse.right_down = function (x, y)
    export_array.mouse.move(x, y)
    command ('7' .. tostring(export_array.mouse_right_button))
end

export_array.mouse.middle_down = function (x, y)
    export_array.mouse.move(x, y)
    command ('7' .. tostring(export_array.mouse_middle_button))
end



export_array.mouse.up = function (x, y, button)
    if button == nil then button = export_array.mouse_left_button end
    command ('8' .. tostring(button))
end

export_array.mouse.left_up = function (x, y)
    command ('8' .. tostring(export_array.mouse_left_button))
end

export_array.mouse.right_up = function (x, y)
    command ('8' .. tostring(export_array.mouse_right_button))
end

export_array.mouse.middle_up = function (x, y)
    command ('8' .. tostring(export_array.mouse_middle_button))
end


return export_array

-- Номер порта
com = 5
-- Пауза между нажатиями клавиш.
-- Только чтение, изменение через set_delay_key.
delay_key = 20
-- Пауза между нажатием и отпусканием кнопок мыши. 
-- Только чтение, изменение через set_delay_mouse.
delay_mouse = 20

mouse_left_button = 1
mouse_right_button = 2
mouse_middle_button = 4

left_ctrl = 0x80
left_shift = 0x81
left_alt = 0x82
left_gui = 0x83
right_ctrl = 0x84
right_shift = 0x85
right_alt = 0x86
right_gui = 0x87
up_arrow = 0xDA
down_arrow = 0xD9
left_arrow = 0xD8
right_arrow = 0xD7
backspace = 0xB2
tab = 0xB3
return = 0xB0
_return = 0xB0
enter= 0xB0
esc = 0xB1
insert = 0xD1
delete = 0xD4
page_up = 0xD3
page_down = 0xD6
home = 0xD2
end = 0xD5
_end = 0xD5
caps_lock = 0xC1
f1 = 0xC2
f2 = 0xC3
f3 = 0xC4
f4 = 0xC5
f5 = 0xC6
f6 = 0xC7
f7 = 0xC8
f8 = 0xC9
f9 = 0xCA
f10 = 0xCB
f11 = 0xCC
f12 = 0xCD
F1 = 0xC2
F2 = 0xC3
F3 = 0xC4
F4 = 0xC5
F5 = 0xC6
F6 = 0xC7
F7 = 0xC8
F8 = 0xC9
F9 = 0xCA
F10 = 0xCB
F11 = 0xCC
F12 = 0xCD

set_delay_key (ms) -- установить задержку нажатий клавиатуры
set_delay_mouse (ms) -- установить задержку нажатий мыши
key (code) -- нажать клавишу клавиатуры
text (text) -- отослать текст
key_down (code) -- зажать (не отжимая) клавишу клавиатуры
key_up (code) -- отжать клавишу клавиатуры
mouse.move (x, y) -- переместить мышь
mouse.click (x, y, button) -- кликнуть мышью, button должен содержать код клавиши мыши
mouse.left (x, y) -- кликунть левой кнопкой
mouse.right (x, y) -- кликнуть правой кнопкой
mouse.middle (x, y) -- кликнуть средней кнопкой
mouse.dbl (x, y, button) -- двойной клик, button должен содержать код клавиши мыши
mouse.left_dbl (x, y) -- двойной клик левой кнопкой мыши
mouse.right_dbl (x, y) -- двойной клик правой кнопкой мыши
mouse.middle_dbl (x, y) -- двойной клик средней кнопкой мыши
mouse.down (x, y, button) -- зажать (не отжимая) кнопку мыши, button должен содержать код клавиши мыши
mouse.left_down (x, y) -- зажать (не отжимая) левую кнопку мыши
mouse.right_down (x, y) -- зажать (не отжимая) правую кнопку мыши
mouse.middle_down (x, y) -- зажать (не отжимая) среднюю кнопку мыши
mouse.up (x, y, button) -- отжать кнопку мыши, button должен содержать код клавиши мыши
mouse.left_up (x, y) -- отжать левую кнопку мыши
mouse.right_up (x, y) -- отжать правую кнопку мыши
mouse.middle_up (x, y) -- отжать среднюю кнопку мыши

local hw = require'arduino'
hw.key("a")

#include <Keyboard.h>

void setup() {
  Serial.begin(9600);
}

void loop() {
  while (Serial.available() == 0) {
    delay(1);
  }
  int i=0;
  int key[64];
  while (Serial.available() > 0) {
    key[i++] = Serial.read();
    delay(1);
  }
  int len = i;
  for (int i = 0; i < len; i++)
  {
    Keyboard.press(key[i]);
    delay(10);
    Keyboard.release(key[i]);
    delay(10);
  }
}

#include <Mouse.h>
#include <Keyboard.h>
#include <stdlib.h>

// hardware
int KEYBOARD_DELAY = 20;
int MOUSE_DELAY = 20;
const int SERIAL_PORT = 9600;
const int SERIAL_DELAY = 1;
#define MAX_BUFFER_SIZE 65 //null-terminated

// protocol
#define SET_DELAY '0'
#define SET_KEYBOARD_DELAY '0'
#define SET_MOUSE_DELAY '1'
#define PRESS_KEY '1'
#define PRINT_STRING '2'
#define KEY_DOWN '3'
#define KEY_UP '4'
#define MOUSE_MOVE '5'
#define MOUSE_CLICK '6'
#define MOUSE_DOWN '7'
#define MOUSE_UP '8'
#define MOUSE_SCROLL '9'

void setup() {
    Serial.begin(SERIAL_PORT);
    Mouse.begin();
    Keyboard.begin();
}

void loop()
{
    char buffer[MAX_BUFFER_SIZE];
    int buffPos = 0;

    while (!Serial.available()) {
        delay(SERIAL_DELAY);
    }

    while (Serial.available()) {
        if (buffPos <= MAX_BUFFER_SIZE - 2) {
            buffer[buffPos++] = Serial.read();
            buffer[buffPos] = '\0';
        }
    }

    switch (buffer[0]) {
    case SET_DELAY:  // установки паузы для клавиш клавиутуры и мыши
    {
        switch (buffer[1]) {
        case SET_KEYBOARD_DELAY:
            KEYBOARD_DELAY = atoi(&buffer[2]);
            break;
        case SET_MOUSE_DELAY:
            MOUSE_DELAY = atoi(&buffer[2]);
            break;
        }
        break;
    }
    case PRESS_KEY:  // нажатие клавиши
    {
        char key = buffer[1];
        Keyboard.press(key);
        delay(KEYBOARD_DELAY);
        Keyboard.release(key);
        delay(KEYBOARD_DELAY);
        break;
    }
    case PRINT_STRING:  // напечатать строку
    {
        for (int i = 1; i < MAX_BUFFER_SIZE - 1; i++) {
            Keyboard.write(buffer[i]);
            delay(KEYBOARD_DELAY);
        }
        break;
    }
    case KEY_DOWN:  // зажать клавишу
    {
        Keyboard.press(buffer[1]);
        delay(KEYBOARD_DELAY);
        break;
    }
    case KEY_UP:  // отпустить клавишу
    {
        Keyboard.release(buffer[1]);
        delay(KEYBOARD_DELAY);
        break;
    }
    case MOUSE_MOVE:  // переместить курсор мыши
    {
        long coordinate = atoi(&buffer[3]);
        // x и y на сколько пикселей нужно сместить курсор
        long x = coordinate / 65535;
        long y = coordinate % 65535;

        // нужно двигать влево/вправо вверх/вниз
        if (buffer[1] == '-')
            x = -x;
        if (buffer[2] == '-')
            y = -y;

        // сколько нужно сделать шагов
        int count_step;
        int stepX = 127, stepY = 127;        // шаг
        int remainsX, remainsY;  // сколько останется в конце

        if (abs(x) > abs(y))  // если по X больше двигать курсор чем по Y
        {
            count_step = abs(x) / 127;
            if (count_step > 0)
            {
                if (x < 0)stepX = -127;

                if (y > 0)stepY = abs(y) / count_step;
                else stepY = y / count_step;

                if (abs(stepY) > 127)
                {
                    if (stepY > 0)stepY = 127;
                    else stepY = -127;
                }
            }
            remainsX = x % stepX;
            remainsY = y % stepY;
        }
        else
        {
            count_step = abs(y) / 127;
            if (count_step > 0)
            {
                if (y < 0)stepY = -127;
                if (x > 0)stepX = abs(x) / count_step;
                else stepX = x / count_step;

                if (abs(stepX) > 127)
                {
                    if (stepX > 0)stepX = 127;
                    else stepX = -127;
                }
            }
            remainsX = x % stepX;
            remainsY = y % stepY;
        }

        for (int i = 0; i < count_step; i++)  // перемещение курсора
        {
            Mouse.move(stepX, stepY, 0);
        }

        Mouse.move(remainsX, remainsY, 0);  // перемещение в конечную точку
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_CLICK:  // клик кнопкой мыши
    {
        Mouse.click(buffer[1]);
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_DOWN:  // зажать кнопку мыши
    {
        Mouse.press(buffer[1]);
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_UP:  // отпустить кнопку мыши
    {
        Mouse.release(buffer[1]);
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_SCROLL:  // скролл мыши
    {
        char wheel = atoi(&buffer[1]);
        Mouse.move(0, 0, wheel);
        delay(MOUSE_DELAY);
        break;
    }
    default:
        break;
    }

}

#include <Mouse.h>
#include <Keyboard.h>
#include <stdlib.h>

// hardware
int KEYBOARD_DELAY = 20;
int MOUSE_DELAY = 20;
const int SERIAL_PORT = 9600;
const int SERIAL_DELAY = 1;
#define MAX_BUFFER_SIZE 64

// protocol
#define SET_DELAY '0'
#define SET_KEYBOARD_DELAY '0'
#define SET_MOUSE_DELAY '1'
#define PRESS_KEY '1'
#define PRINT_STRING '2'
#define KEY_DOWN '3'
#define KEY_UP '4'
#define MOUSE_MOVE '5'
#define MOUSE_CLICK '6'
#define MOUSE_DOWN '7'
#define MOUSE_UP '8'
#define MOUSE_SCROLL '9'

void setup() {
    Serial.begin(SERIAL_PORT);
    Mouse.begin();
    Keyboard.begin();
}

void loop()
{
    char buffer[MAX_BUFFER_SIZE];
    int buffPos = 0;

    while (!Serial.available()) {
        delay(SERIAL_DELAY);
    }

    while (Serial.available()) {
        if (buffPos < MAX_BUFFER_SIZE - 1) {
            buffer[buffPos++] = Serial.read();
            buffer[buffPos] = '\0';
        }
    }

    switch (buffer[0]) {
    case SET_DELAY:  // установки паузы для клавиш клавиутуры и мыши
    {
        switch (buffer[1]) {
        case SET_KEYBOARD_DELAY:
            KEYBOARD_DELAY = atoi(&buffer[2]);
            break;
        case SET_MOUSE_DELAY:
            MOUSE_DELAY = atoi(&buffer[2]);
            break;
        }
        break;
    }
    case PRESS_KEY:  // нажатие клавиши
    {
        char key = atoi(&buffer[1]);
        Keyboard.press(key);
        delay(KEYBOARD_DELAY);
        Keyboard.release(key);
        delay(KEYBOARD_DELAY);
        break;
    }
    case PRINT_STRING:  // напечатать строку
    {
        for (int i = 1; i < buffPos; i++) {
            Keyboard.write(buffer[i]);
            delay(KEYBOARD_DELAY);
        }
        break;
    }
    case KEY_DOWN:  // зажать клавишу
    {
        Keyboard.press(atoi(&buffer[1]));
        delay(KEYBOARD_DELAY);
        break;
    }
    case KEY_UP:  // отпустить клавишу
    {
        Keyboard.release(atoi(&buffer[1]));
        delay(KEYBOARD_DELAY);
        break;
    }
    case MOUSE_MOVE:  // переместить курсор мыши
    {
        long coordinate = atol(&buffer[3]);

        // x и y на сколько пикселей нужно сместить курсор
        long x = coordinate / 65535;
        long y = coordinate % 65535;

        // нужно двигать влево/вправо вверх/вниз
        if (buffer[1] == '-')
            x = -x;
        if (buffer[2] == '-')
            y = -y;

        // сколько нужно сделать шагов
        int count_step;
        int stepX = 127, stepY = 127;        // шаг
        int remainsX, remainsY;  // сколько останется в конце

        if (abs(x) > abs(y))  // если по X больше двигать курсор чем по Y
        {
            count_step = abs(x) / 127;
            if (count_step > 0)
            {
                if (x < 0)stepX = -127;

                if (y > 0)stepY = abs(y) / count_step;
                else stepY = y / count_step;

                if (abs(stepY) > 127)
                {
                    if (stepY > 0)stepY = 127;
                    else stepY = -127;
                }
            }
            remainsX = x % stepX;
            remainsY = y % stepY;
        }
        else
        {
            count_step = abs(y) / 127;
            if (count_step > 0)
            {
                if (y < 0)stepY = -127;
                if (x > 0)stepX = abs(x) / count_step;
                else stepX = x / count_step;

                if (abs(stepX) > 127)
                {
                    if (stepX > 0)stepX = 127;
                    else stepX = -127;
                }
            }
            remainsX = x % stepX;
            remainsY = y % stepY;
        }

        for (int i = 0; i < count_step; i++)  // перемещение курсора
        {
            Mouse.move(stepX, stepY, 0);
        }

        Mouse.move(remainsX, remainsY, 0);  // перемещение в конечную точку
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_CLICK:  // клик кнопкой мыши
    {
        Mouse.click(buffer[1]);
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_DOWN:  // зажать кнопку мыши
    {
        Mouse.press(buffer[1]);
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_UP:  // отпустить кнопку мыши
    {
        Mouse.release(buffer[1]);
        delay(MOUSE_DELAY);
        break;
    }
    case MOUSE_SCROLL:  // скролл мыши
    {
        char wheel = atoi(&buffer[1]);
        Mouse.move(0, 0, wheel);
        delay(MOUSE_DELAY);
        break;
    }
    default:
        break;
    }
}

--lua
local ffi = require('ffi')
local setupapi = ffi.load('SetupAPI.dll')
local advapi32 = ffi.load('Advapi32.dll')

local DIGCF_ALLCLASSES = 4
local DIGCF_PRESENT = 2
local SPDRP_HARDWAREID = 1
local DICS_FLAG_GLOBAL = 1
local DIREG_DEV = 1
local KEY_READ = 131097
local BUFF_LEN = 20
local ERROR_SUCCESS = 0
local REG_SZ = 1

ffi.cdef[[
struct HWND__ { int unused; }; typedef struct HWND__ *HWND;
struct HKEY__ { int unused; }; typedef struct HKEY__ *HKEY;
typedef HKEY *PHKEY;
typedef unsigned long ULONG;
typedef unsigned long   DWORD;
typedef DWORD         *LPDWORD;
typedef long   LONG;
typedef DWORD *PDWORD;
typedef unsigned char BYTE;
typedef BYTE *PBYTE, *LPBYTE;
typedef wchar_t         WCHAR;
typedef const char      *LPCSTR, *PCSTR;
typedef unsigned long ULONG_PTR, *PULONG_PTR;
typedef void *PVOID;
typedef PVOID HDEVINFO;
typedef ULONG DEVPROPTYPE;
typedef LONG LSTATUS;
typedef DWORD ACCESS_MASK;
typedef ACCESS_MASK REGSAM;

typedef struct _GUID {unsigned long Data1; unsigned short Data2; unsigned short Data3; unsigned char Data4[8];} GUID;
typedef struct _SP_DEVINFO_DATA {DWORD cbSize; GUID ClassGuid; DWORD DevInst; ULONG_PTR Reserved;} SP_DEVINFO_DATA, *PSP_DEVINFO_DATA;

HDEVINFO SetupDiGetClassDevsA(const GUID *ClassGuid, PCSTR Enumerator, HWND hwndParent, DWORD Flags);
bool SetupDiDestroyDeviceInfoList(HDEVINFO DeviceInfoSet);
bool SetupDiEnumDeviceInfo(HDEVINFO DeviceInfoSet, DWORD MemberIndex, PSP_DEVINFO_DATA DeviceInfoData);
bool SetupDiGetDeviceRegistryPropertyA(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property,
    PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize);
HKEY SetupDiOpenDevRegKey(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData,
  DWORD Scope, DWORD HwProfile, DWORD KeyType, REGSAM samDesired);
LSTATUS RegCloseKey(HKEY hKey);
LSTATUS RegQueryValueExA(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType,LPBYTE lpData, LPDWORD lpcbData);
]]


function get_port(vid, pid)
    if vid == nil then return -1 end
    if pid == nil then return -2 end

    local com
    local DeviceInfoSet = ffi.new('HDEVINFO')
    local DeviceIndex = 0
    local DeviceInfoData = ffi.new('SP_DEVINFO_DATA', 0)
    local DevEnum = ffi.new('PCSTR', "USB")
    local ExpectedDeviceId = 'VID_' .. tostring(vid) .. '&PID_' .. tostring(pid)
    local szBuffer = ffi.new('unsigned char[1024]', 0)
    local ulPropertyType = ffi.new('DEVPROPTYPE[1]')
    local dwSize = ffi.new('PDWORD')
    DeviceInfoSet = setupapi.SetupDiGetClassDevsA(nil, DevEnum, nil, bit.bor(DIGCF_ALLCLASSES, DIGCF_PRESENT))
    DeviceInfoData.cbSize = ffi.sizeof(DeviceInfoData)

    while setupapi.SetupDiEnumDeviceInfo(DeviceInfoSet, DeviceIndex, DeviceInfoData) do
        DeviceIndex = DeviceIndex + 1
        if (setupapi.SetupDiGetDeviceRegistryPropertyA(DeviceInfoSet, DeviceInfoData, SPDRP_HARDWAREID, ulPropertyType, szBuffer, ffi.sizeof(szBuffer), dwSize)) then
            if ffi.string(szBuffer):match(ExpectedDeviceId) then
                local hDeviceRegistryKey = ffi.new('HKEY')
                hDeviceRegistryKey = setupapi.SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
                local pszPortName = ffi.new('char[?]', BUFF_LEN)
                local dwSize = ffi.new('DWORD[1]', ffi.sizeof(pszPortName))
                local dwType = ffi.new('DWORD[1]')
                if advapi32.RegQueryValueExA(hDeviceRegistryKey, "PortName", nil, dwType, pszPortName, dwSize) == ERROR_SUCCESS and dwType[0] == REG_SZ then
                    com = tonumber(ffi.string(pszPortName):match('%d+'))
                end
            end
            advapi32.RegCloseKey(hDeviceRegistryKey)
        end
    end
    setupapi.SetupDiDestroyDeviceInfoList(DeviceInfoSet)
    if com then return com end
    return 0
end

-- узнать номер порта, передавать vid, pid
local COM = get_port(2341, 8036)  -- указать нужные vid и pid
log(COM)