GithubFollow/One-KVM
1
0
Fork 0
mirror of https://github.com/mofeng-git/One-KVM.git synced 2025-12-12 17:20:30 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

adds abstraction for connection (#111)

Browse Source
This commit is contained in:
tomaszduda23 2023-03-04 18:25:16 +01:00 committed by GitHub
parent 1f9e826f2f
commit 52ac8d93a1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 194 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
hid/lib/drivers-avr/factory.cpp
View File

@ -24,6 +24,8 @@
#include "ps2/hid.h"
#include "factory.h"
#include "eeprom.h"
#include "serial.h"
#include "spi.h"
#ifndef ARDUINO_ARCH_AVR
# error "Only AVR is supported"
@ -79,4 +81,14 @@ namespace DRIVERS {
return new Board(DRIVERS::DUMMY);
}
}
Connection* Factory::makeConnection(type _type) {
# ifdef CMD_SERIAL
return new Serial();
# elif defined(CMD_SPI)
return new Spi();
# else
# error CMD phy is not defined
# endif
}
}

26
hid/lib/drivers-avr/spi.cpp
View File

@ -21,7 +21,8 @@
#include "spi.h"
#ifdef CMD_SPI
#include <SPI.h>
static volatile uint8_t _spi_in[8] = {0};
static volatile uint8_t _spi_in_index = 0;
@ -29,28 +30,26 @@ static volatile uint8_t _spi_in_index = 0;
static volatile uint8_t _spi_out[8] = {0};
static volatile uint8_t _spi_out_index = 0;
void spiBegin() {
namespace DRIVERS {
void Spi::begin() {
pinMode(MISO, OUTPUT);
SPCR = (1 << SPE) | (1 << SPIE); // Slave, SPI En, IRQ En
}
}
bool spiReady() {
return (!_spi_out[0] && _spi_in_index == 8);
}
void Spi::periodic() {
if (!_spi_out[0] && _spi_in_index == 8) {
_data_cb((const uint8_t *)_spi_in, 8);
}
}
const uint8_t *spiGet() {
return (const uint8_t *)_spi_in;
}
void spiWrite(const uint8_t *data) {
void Spi::write(const uint8_t *data, size_t size) {
// Меджик в нулевом байте разрешает начать ответ
for (int index = 7; index >= 0; --index) {
_spi_out[index] = data[index];
}
}
}
ISR(SPI_STC_vect) {
uint8_t in = SPDR;
if (_spi_out[0] && _spi_out_index < 8) {
@ -78,3 +77,4 @@ ISR(SPI_STC_vect) {
SPDR = 0;
}
}
#endif

16
hid/lib/drivers/spi.h → hid/lib/drivers-avr/spi.h
View File

@ -23,10 +23,16 @@
#pragma once
#include <Arduino.h>
#include <SPI.h>
#include "connection.h"
namespace DRIVERS {
struct Spi : public Connection {
Spi() : Connection(CONNECTION) {}
void spiBegin();
bool spiReady();
const uint8_t *spiGet();
void spiWrite(const uint8_t *data);
void begin() override;
void periodic() override;
void write(const uint8_t *data, size_t size) override;
};
}

9
hid/lib/drivers-stm32/factory.cpp
View File

@ -27,6 +27,7 @@
#include "usb/mouse-relative-stm32.h"
#include "backup-register.h"
#include "board-stm32.h"
#include "serial.h"
#ifndef __STM32F1__
# error "Only STM32F1 is supported"
@ -82,4 +83,12 @@ namespace DRIVERS {
return new Board(DRIVERS::DUMMY);
}
}
Connection* Factory::makeConnection(type _type) {
# ifdef CMD_SERIAL
return new Serial();
# else
# error CMD phy is not defined
# endif
}
}

53
hid/lib/drivers/connection.h Normal file
View File

@ -0,0 +1,53 @@
/*****************************************************************************
# #
# KVMD - The main PiKVM daemon. #
# #
# Copyright (C) 2018-2022 Maxim Devaev <mdevaev@gmail.com> #
# #
# This program is free software: you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation, either version 3 of the License, or #
# (at your option) any later version. #
# #
# This program 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 General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program. If not, see <https://www.gnu.org/licenses/>. #
# #
*****************************************************************************/
#pragma once
#include "driver.h"
#include "stdint.h"
namespace DRIVERS {
typedef void(*DataHandler)(const uint8_t * data, size_t len);
typedef void(*TimeoutHandler)();
struct Connection : public Driver {
using Driver::Driver;
virtual void begin() {}
virtual void periodic() {}
void onTimeout(TimeoutHandler cb) {
_timeout_cb = cb;
}
void onData(DataHandler cb) {
_data_cb = cb;
}
virtual void write(const uint8_t *data, size_t size) = 0;
protected:
TimeoutHandler _timeout_cb = nullptr;
DataHandler _data_cb = nullptr;
};
}

1
hid/lib/drivers/driver.h
View File

@ -35,6 +35,7 @@ namespace DRIVERS {
PS2_KEYBOARD,
NON_VOLATILE_STORAGE,
BOARD,
CONNECTION,
};
class Driver {

2
hid/lib/drivers/factory.h
View File

@ -25,6 +25,7 @@
#include "mouse.h"
#include "storage.h"
#include "board.h"
#include "connection.h"
namespace DRIVERS {
@ -33,5 +34,6 @@ namespace DRIVERS {
static Mouse *makeMouse(type _type);
static Storage* makeStorage(type _type);
static Board* makeBoard(type _type);
static Connection* makeConnection(type _type);
};
}

66
hid/lib/drivers/serial.h Normal file
View File

@ -0,0 +1,66 @@
/*****************************************************************************
# #
# KVMD - The main PiKVM daemon. #
# #
# Copyright (C) 2018-2022 Maxim Devaev <mdevaev@gmail.com> #
# #
# This program is free software: you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation, either version 3 of the License, or #
# (at your option) any later version. #
# #
# This program 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 General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program. If not, see <https://www.gnu.org/licenses/>. #
# #
*****************************************************************************/
#pragma once
#ifdef CMD_SERIAL
#include "connection.h"
namespace DRIVERS {
#ifdef Serial
#undef Serial
#endif
struct Serial : public Connection {
Serial() : Connection(CONNECTION) {}
void begin() override {
CMD_SERIAL.begin(CMD_SERIAL_SPEED);
}
void periodic() override {
if (CMD_SERIAL.available() > 0) {
_buffer[_index] = (uint8_t)CMD_SERIAL.read();
if (_index == 7) {
_data_cb(_buffer, 8);
_index = 0;
} else {
_last = micros();
++_index;
}
} else if (_index > 0) {
if (is_micros_timed_out(_last, CMD_SERIAL_TIMEOUT)) {
_timeout_cb();
_index = 0;
}
}
}
void write(const uint8_t *data, size_t size) override {
CMD_SERIAL.write(data, size);
}
private:
unsigned long _last = 0;
uint8_t _index = 0;
uint8_t _buffer[8];
};
}
#endif

1
hid/platformio-avr.ini
View File

@ -11,6 +11,7 @@ lib_deps =
git+https://github.com/Harvie/ps2dev#v0.0.3
digitalWriteFast@1.0.0
HID@1.0
SPI
drivers-avr
extra_scripts =
pre:avrdude.py

69
hid/src/main.cpp
View File

@ -20,30 +20,17 @@
*****************************************************************************/
// #define CMD_SERIAL Serial1
// #define CMD_SERIAL_SPEED 115200
// #define CMD_SERIAL_TIMEOUT 100000
// -- OR --
// #define CMD_SPI
#if !(defined(CMD_SERIAL) || defined(CMD_SPI))
# error CMD phy is not defined
#endif
#include <Arduino.h>
#include "tools.h"
#include "proto.h"
#ifdef CMD_SPI
# include "spi.h"
#endif
#ifdef AUM
# include "aum.h"
#endif
#include "board.h"
#include "outputs.h"
static DRIVERS::Connection* _conn;
static DRIVERS::Board* _board;
static Outputs _out;
#ifdef HID_DYNAMIC
@ -123,7 +110,9 @@ static void _cmdMouseWheelEvent(const uint8_t *data) { // 2 bytes
static uint8_t _handleRequest(const uint8_t *data) { // 8 bytes
_board->updateStatus(DRIVERS::RX_DATA);
if (PROTO::crc16(data, 6) == PROTO::merge8(data[6], data[7])) {
// FIXME: See kvmd/kvmd#80
// Should input buffer be cleared in this case?
if (data[0] == PROTO::MAGIC && PROTO::crc16(data, 6) == PROTO::merge8(data[6], data[7])) {
# define HANDLE(_handler) { _handler(data + 2); return PROTO::PONG::OK; }
switch (data[1]) {
case PROTO::CMD::PING: return PROTO::PONG::OK;
@ -224,11 +213,15 @@ static void _sendResponse(uint8_t code) {
}
PROTO::split16(PROTO::crc16(response, 6), &response[6], &response[7]);
# ifdef CMD_SERIAL
CMD_SERIAL.write(response, 8);
# elif defined(CMD_SPI)
spiWrite(response);
# endif
_conn->write(response, 8);
}
static void _onTimeout() {
_sendResponse(PROTO::RESP::TIMEOUT_ERROR);
}
static void _onData(const uint8_t * data, size_t len) {
_sendResponse(_handleRequest(data));
}
void setup() {
@ -238,11 +231,11 @@ void setup() {
aumInit();
# endif
# ifdef CMD_SERIAL
CMD_SERIAL.begin(CMD_SERIAL_SPEED);
# elif defined(CMD_SPI)
spiBegin();
# endif
_conn = DRIVERS::Factory::makeConnection(DRIVERS::CONNECTION);
_conn->onTimeout(_onTimeout);
_conn->onData(_onData);
_conn->begin();
_board = DRIVERS::Factory::makeBoard(DRIVERS::BOARD);
}
@ -254,29 +247,5 @@ void loop() {
_out.kbd->periodic();
_out.mouse->periodic();
_board->periodic();
# ifdef CMD_SERIAL
static unsigned long last = micros();
static uint8_t buffer[8];
static uint8_t index = 0;
if (CMD_SERIAL.available() > 0) {
buffer[index] = (uint8_t)CMD_SERIAL.read();
if (index == 7) {
_sendResponse(_handleRequest(buffer));
index = 0;
} else /*if (buffer[0] == PROTO::MAGIC)*/ { // FIXME: See kvmd/kvmd#80
last = micros();
++index;
}
} else if (index > 0) {
if (is_micros_timed_out(last, CMD_SERIAL_TIMEOUT)) {
_sendResponse(PROTO::RESP::TIMEOUT_ERROR);
index = 0;
}
}
# elif defined(CMD_SPI)
if (spiReady()) {
_sendResponse(_handleRequest(spiGet()));
}
# endif
_conn->periodic();
}