Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-04 03:11:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use OS for serial port instead of NI VISA (#1875)

Browse Source
This commit is contained in:
Thad House
2019-09-28 16:49:11 -07:00
committed by Peter Johnson
parent b23baf611a
commit 9f740e5905
10 changed files with 703 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

547
hal/src/main/native/athena/SerialPort.cpp
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2016-2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -7,168 +7,493 @@
#include "hal/SerialPort.h"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>
#include <cerrno>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stdexcept>
#include <string>
#include <thread>
#include "HALInitializer.h"
#include "hal/cpp/SerialHelper.h"
#include "visa/visa.h"
#include "hal/handles/HandlesInternal.h"
#include "hal/handles/IndexedHandleResource.h"
static int32_t resourceManagerHandle{0};
static HAL_SerialPort portHandles[4];
namespace {
struct SerialPort {
int portId;
struct termios tty;
int baudRate;
double timeout = 0;
bool termination = false;
char terminationChar = '\n';
};
} // namespace
namespace hal {
IndexedHandleResource<HAL_SerialPortHandle, SerialPort, 4,
HAL_HandleEnum::SerialPort>* serialPortHandles;
} // namespace hal
namespace hal {
namespace init {
void InitializeSerialPort() {}
void InitializeSerialPort() {
static IndexedHandleResource<HAL_SerialPortHandle, SerialPort, 4,
HAL_HandleEnum::SerialPort>
spH;
serialPortHandles = &spH;
}
} // namespace init
} // namespace hal
using namespace hal;
extern "C" {
void HAL_InitializeSerialPort(HAL_SerialPort port, int32_t* status) {
hal::init::CheckInit();
std::string portName;
if (resourceManagerHandle == 0)
viOpenDefaultRM(reinterpret_cast<ViSession*>(&resourceManagerHandle));
HAL_SerialPortHandle HAL_InitializeSerialPort(HAL_SerialPort port,
int32_t* status) {
// hal::init::CheckInit();
hal::SerialHelper serialHelper;
portName = serialHelper.GetVISASerialPortName(port, status);
std::string portName = serialHelper.GetOSSerialPortName(port, status);
if (*status < 0) {
return HAL_kInvalidHandle;
}
return HAL_InitializeSerialPortDirect(port, portName.c_str(), status);
}
HAL_SerialPortHandle HAL_InitializeSerialPortDirect(HAL_SerialPort port,
const char* portName,
int32_t* status) {
auto handle = serialPortHandles->Allocate(static_cast<int16_t>(port), status);
if (*status != 0) {
return HAL_kInvalidHandle;
}
auto serialPort = serialPortHandles->Get(handle);
if (serialPort == nullptr) {
*status = HAL_HANDLE_ERROR;
return HAL_kInvalidHandle;
}
serialPort->portId = open(portName, O_RDWR | O_NOCTTY);
if (serialPort->portId < 0) {
*status = errno;
serialPortHandles->Free(handle);
return HAL_kInvalidHandle;
}
std::memset(&serialPort->tty, 0, sizeof(serialPort->tty));
serialPort->baudRate = B9600;
cfsetospeed(&serialPort->tty, static_cast<speed_t>(serialPort->baudRate));
cfsetispeed(&serialPort->tty, static_cast<speed_t>(serialPort->baudRate));
serialPort->tty.c_cflag &= ~PARENB;
serialPort->tty.c_cflag &= ~CSTOPB;
serialPort->tty.c_cflag &= ~CSIZE;
serialPort->tty.c_cflag |= CS8;
serialPort->tty.c_cc[VMIN] = 0;
serialPort->tty.c_cc[VTIME] = 10;
serialPort->tty.c_cflag |= CREAD | CLOCAL;
serialPort->tty.c_lflag &= ~(ICANON | ECHO | ISIG);
serialPort->tty.c_iflag &= ~(IXON | IXOFF | IXANY);
/* Raw output mode, sends the raw and unprocessed data (send as it is).
* If it is in canonical mode and sending new line char then CR
* will be added as prefix and send as CR LF
*/
serialPort->tty.c_oflag = ~OPOST;
tcflush(serialPort->portId, TCIOFLUSH);
if (tcsetattr(serialPort->portId, TCSANOW, &serialPort->tty) != 0) {
*status = errno;
close(serialPort->portId);
serialPortHandles->Free(handle);
return HAL_kInvalidHandle;
}
return handle;
}
void HAL_CloseSerial(HAL_SerialPortHandle handle, int32_t* status) {
auto port = serialPortHandles->Get(handle);
serialPortHandles->Free(handle);
if (port) {
close(port->portId);
}
}
int HAL_GetSerialFD(HAL_SerialPortHandle handle, int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return -1;
}
return port->portId;
}
#define BAUDCASE(BAUD) \
case BAUD: \
port->baudRate = B##BAUD; \
break;
void HAL_SetSerialBaudRate(HAL_SerialPortHandle handle, int32_t baud,
int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
*status = viOpen(resourceManagerHandle, const_cast<char*>(portName.c_str()),
VI_NULL, VI_NULL,
reinterpret_cast<ViSession*>(&portHandles[port]));
if (*status > 0) *status = 0;
switch (baud) {
BAUDCASE(50)
BAUDCASE(75)
BAUDCASE(110)
BAUDCASE(134)
BAUDCASE(150)
BAUDCASE(200)
BAUDCASE(300)
BAUDCASE(600)
BAUDCASE(1200)
BAUDCASE(1800)
BAUDCASE(2400)
BAUDCASE(4800)
BAUDCASE(9600)
BAUDCASE(19200)
BAUDCASE(38400)
BAUDCASE(57600)
BAUDCASE(115200)
BAUDCASE(230400)
BAUDCASE(460800)
BAUDCASE(500000)
BAUDCASE(576000)
BAUDCASE(921600)
BAUDCASE(1000000)
BAUDCASE(1152000)
BAUDCASE(1500000)
BAUDCASE(2000000)
BAUDCASE(2500000)
BAUDCASE(3000000)
BAUDCASE(3500000)
BAUDCASE(4000000)
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
int err = cfsetospeed(&port->tty, static_cast<speed_t>(port->baudRate));
if (err < 0) {
*status = errno;
return;
}
err = cfsetispeed(&port->tty, static_cast<speed_t>(port->baudRate));
if (err < 0) {
*status = errno;
return;
}
err = tcsetattr(port->portId, TCSANOW, &port->tty);
if (err < 0) {
*status = errno;
}
}
void HAL_InitializeSerialPortDirect(HAL_SerialPort port, const char* portName,
int32_t* status) {
*status = viOpen(resourceManagerHandle, const_cast<char*>(portName), VI_NULL,
VI_NULL, reinterpret_cast<ViSession*>(&portHandles[port]));
if (*status > 0) *status = 0;
}
void HAL_SetSerialBaudRate(HAL_SerialPort port, int32_t baud, int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_ASRL_BAUD, baud);
if (*status > 0) *status = 0;
}
void HAL_SetSerialDataBits(HAL_SerialPort port, int32_t bits, int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_ASRL_DATA_BITS, bits);
if (*status > 0) *status = 0;
}
void HAL_SetSerialParity(HAL_SerialPort port, int32_t parity, int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_ASRL_PARITY, parity);
if (*status > 0) *status = 0;
}
void HAL_SetSerialStopBits(HAL_SerialPort port, int32_t stopBits,
void HAL_SetSerialDataBits(HAL_SerialPortHandle handle, int32_t bits,
int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_ASRL_STOP_BITS, stopBits);
if (*status > 0) *status = 0;
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
int bitFlag = -1;
switch (bits) {
case 5:
bitFlag = CS5;
break;
case 6:
bitFlag = CS6;
break;
case 7:
bitFlag = CS7;
break;
case 8:
bitFlag = CS8;
break;
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
port->tty.c_cflag &= ~CSIZE;
port->tty.c_cflag |= bitFlag;
int err = tcsetattr(port->portId, TCSANOW, &port->tty);
if (err < 0) {
*status = errno;
}
}
void HAL_SetSerialWriteMode(HAL_SerialPort port, int32_t mode,
void HAL_SetSerialParity(HAL_SerialPortHandle handle, int32_t parity,
int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
switch (parity) {
case 0: // None
port->tty.c_cflag &= ~PARENB;
port->tty.c_cflag &= ~CMSPAR;
break;
case 1: // Odd
port->tty.c_cflag |= PARENB;
port->tty.c_cflag &= ~CMSPAR;
port->tty.c_cflag &= ~PARODD;
break;
case 2: // Even
port->tty.c_cflag |= PARENB;
port->tty.c_cflag &= ~CMSPAR;
port->tty.c_cflag |= PARODD;
break;
case 3: // Mark
port->tty.c_cflag |= PARENB;
port->tty.c_cflag |= CMSPAR;
port->tty.c_cflag |= PARODD;
break;
case 4: // Space
port->tty.c_cflag |= PARENB;
port->tty.c_cflag |= CMSPAR;
port->tty.c_cflag &= ~PARODD;
break;
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
int err = tcsetattr(port->portId, TCSANOW, &port->tty);
if (err < 0) {
*status = errno;
}
}
void HAL_SetSerialStopBits(HAL_SerialPortHandle handle, int32_t stopBits,
int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
switch (stopBits) {
case 10: // 1
port->tty.c_cflag &= ~CSTOPB;
break;
case 15: // 1.5
case 20: // 2
port->tty.c_cflag |= CSTOPB;
break;
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
int err = tcsetattr(port->portId, TCSANOW, &port->tty);
if (err < 0) {
*status = errno;
}
}
void HAL_SetSerialWriteMode(HAL_SerialPortHandle handle, int32_t mode,
int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_WR_BUF_OPER_MODE, mode);
if (*status > 0) *status = 0;
// This seems to be a no op on the NI serial port driver
}
void HAL_SetSerialFlowControl(HAL_SerialPort port, int32_t flow,
void HAL_SetSerialFlowControl(HAL_SerialPortHandle handle, int32_t flow,
int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_ASRL_FLOW_CNTRL, flow);
if (*status > 0) *status = 0;
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
switch (flow) {
case 0:
port->tty.c_cflag &= ~CRTSCTS;
break;
case 1:
port->tty.c_cflag &= ~CRTSCTS;
port->tty.c_iflag &= IXON | IXOFF;
break;
case 2:
port->tty.c_cflag |= CRTSCTS;
break;
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
int err = tcsetattr(port->portId, TCSANOW, &port->tty);
if (err < 0) {
*status = errno;
}
}
void HAL_SetSerialTimeout(HAL_SerialPort port, double timeout,
void HAL_SetSerialTimeout(HAL_SerialPortHandle handle, double timeout,
int32_t* status) {
*status = viSetAttribute(portHandles[port], VI_ATTR_TMO_VALUE,
static_cast<uint32_t>(timeout * 1e3));
if (*status > 0) *status = 0;
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
port->timeout = timeout;
port->tty.c_cc[VTIME] = static_cast<int>(timeout * 10);
int err = tcsetattr(port->portId, TCSANOW, &port->tty);
if (err < 0) {
*status = errno;
}
}
void HAL_EnableSerialTermination(HAL_SerialPort port, char terminator,
void HAL_EnableSerialTermination(HAL_SerialPortHandle handle, char terminator,
int32_t* status) {
viSetAttribute(portHandles[port], VI_ATTR_TERMCHAR_EN, VI_TRUE);
viSetAttribute(portHandles[port], VI_ATTR_TERMCHAR, terminator);
*status = viSetAttribute(portHandles[port], VI_ATTR_ASRL_END_IN,
VI_ASRL_END_TERMCHAR);
if (*status > 0) *status = 0;
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
port->termination = true;
port->terminationChar = terminator;
}
void HAL_DisableSerialTermination(HAL_SerialPort port, int32_t* status) {
viSetAttribute(portHandles[port], VI_ATTR_TERMCHAR_EN, VI_FALSE);
*status =
viSetAttribute(portHandles[port], VI_ATTR_ASRL_END_IN, VI_ASRL_END_NONE);
if (*status > 0) *status = 0;
}
void HAL_SetSerialReadBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status) {
*status = viSetBuf(portHandles[port], VI_READ_BUF, size);
if (*status > 0) *status = 0;
}
void HAL_SetSerialWriteBufferSize(HAL_SerialPort port, int32_t size,
void HAL_DisableSerialTermination(HAL_SerialPortHandle handle,
int32_t* status) {
*status = viSetBuf(portHandles[port], VI_WRITE_BUF, size);
if (*status > 0) *status = 0;
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
port->termination = false;
}
int32_t HAL_GetSerialBytesReceived(HAL_SerialPort port, int32_t* status) {
int32_t bytes = 0;
void HAL_SetSerialReadBufferSize(HAL_SerialPortHandle handle, int32_t size,
int32_t* status) {
// NO OP currently
}
*status = viGetAttribute(portHandles[port], VI_ATTR_ASRL_AVAIL_NUM, &bytes);
if (*status > 0) *status = 0;
void HAL_SetSerialWriteBufferSize(HAL_SerialPortHandle handle, int32_t size,
int32_t* status) {
// NO OP currently
}
int32_t HAL_GetSerialBytesReceived(HAL_SerialPortHandle handle,
int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return -1;
}
int bytes = 0;
int err = ioctl(port->portId, FIONREAD, &bytes);
if (err < 0) {
*status = errno;
}
return bytes;
}
int32_t HAL_ReadSerial(HAL_SerialPort port, char* buffer, int32_t count,
int32_t HAL_ReadSerial(HAL_SerialPortHandle handle, char* buffer, int32_t count,
int32_t* status) {
uint32_t retCount = 0;
// Don't do anything if 0 bytes were requested
if (count == 0) return 0;
*status =
viRead(portHandles[port], (ViPBuf)buffer, count, (ViPUInt32)&retCount);
if (*status == VI_ERROR_IO || *status == VI_ERROR_ASRL_OVERRUN ||
*status == VI_ERROR_ASRL_FRAMING || *status == VI_ERROR_ASRL_PARITY) {
int32_t localStatus = 0;
HAL_ClearSerial(port, &localStatus);
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return -1;
}
if (*status == VI_ERROR_TMO || *status > 0) *status = 0;
return static_cast<int32_t>(retCount);
int n = 0, loc = 0;
char buf = '\0';
std::memset(buffer, '\0', count);
*status = 0;
do {
n = read(port->portId, &buf, 1);
if (n == 1) {
buffer[loc] = buf;
loc++;
// If buffer is full, return
if (loc == count) {
return loc;
}
// If terminating, and termination was hit return;
if (port->termination && buf == port->terminationChar) {
return loc;
}
} else if (n == -1) {
// ERROR
*status = errno;
return loc;
} else {
// If nothing read, timeout
return loc;
}
} while (true);
}
int32_t HAL_WriteSerial(HAL_SerialPort port, const char* buffer, int32_t count,
int32_t* status) {
uint32_t retCount = 0;
int32_t HAL_WriteSerial(HAL_SerialPortHandle handle, const char* buffer,
int32_t count, int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return -1;
}
*status =
viWrite(portHandles[port], (ViPBuf)buffer, count, (ViPUInt32)&retCount);
if (*status > 0) *status = 0;
return static_cast<int32_t>(retCount);
int written = 0, spot = 0;
do {
written = write(port->portId, buffer + spot, count - spot);
if (written < 0) {
*status = errno;
return spot;
}
spot += written;
} while (spot < count);
return spot;
}
void HAL_FlushSerial(HAL_SerialPort port, int32_t* status) {
*status = viFlush(portHandles[port], VI_WRITE_BUF);
if (*status > 0) *status = 0;
void HAL_FlushSerial(HAL_SerialPortHandle handle, int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
int err = tcdrain(port->portId);
if (err < 0) {
*status = errno;
}
}
void HAL_ClearSerial(HAL_SerialPort port, int32_t* status) {
*status = viClear(portHandles[port]);
if (*status > 0) *status = 0;
void HAL_ClearSerial(HAL_SerialPortHandle handle, int32_t* status) {
auto port = serialPortHandles->Get(handle);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
int err = tcflush(port->portId, TCIOFLUSH);
if (err < 0) {
*status = errno;
}
}
void HAL_CloseSerial(HAL_SerialPort port, int32_t* status) {
*status = viClose(portHandles[port]);
if (*status > 0) *status = 0;
}
} // extern "C"

132
hal/src/main/native/cpp/jni/SerialPortJNI.cpp
View File

@@ -23,185 +23,197 @@ extern "C" {
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialInitializePort
* Signature: (B)V
* Signature: (B)I
*/
JNIEXPORT void JNICALL
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialInitializePort
(JNIEnv* env, jclass, jbyte port)
{
int32_t status = 0;
HAL_InitializeSerialPort(static_cast<HAL_SerialPort>(port), &status);
auto handle =
HAL_InitializeSerialPort(static_cast<HAL_SerialPort>(port), &status);
CheckStatusForceThrow(env, status);
return static_cast<jint>(handle);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialInitializePortDirect
* Signature: (BLjava/lang/String;)V
* Signature: (BLjava/lang/String;)I
*/
JNIEXPORT void JNICALL
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialInitializePortDirect
(JNIEnv* env, jclass, jbyte port, jstring portName)
{
JStringRef portNameRef{env, portName};
int32_t status = 0;
HAL_InitializeSerialPortDirect(static_cast<HAL_SerialPort>(port),
portNameRef.c_str(), &status);
auto handle = HAL_InitializeSerialPortDirect(
static_cast<HAL_SerialPort>(port), portNameRef.c_str(), &status);
CheckStatusForceThrow(env, status);
return static_cast<jint>(handle);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetBaudRate
* Signature: (BI)V
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetBaudRate
(JNIEnv* env, jclass, jbyte port, jint rate)
(JNIEnv* env, jclass, jint handle, jint rate)
{
int32_t status = 0;
HAL_SetSerialBaudRate(static_cast<HAL_SerialPort>(port), rate, &status);
HAL_SetSerialBaudRate(static_cast<HAL_SerialPortHandle>(handle), rate,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetDataBits
* Signature: (BB)V
* Signature: (IB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetDataBits
(JNIEnv* env, jclass, jbyte port, jbyte bits)
(JNIEnv* env, jclass, jint handle, jbyte bits)
{
int32_t status = 0;
HAL_SetSerialDataBits(static_cast<HAL_SerialPort>(port), bits, &status);
HAL_SetSerialDataBits(static_cast<HAL_SerialPortHandle>(handle), bits,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetParity
* Signature: (BB)V
* Signature: (IB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetParity
(JNIEnv* env, jclass, jbyte port, jbyte parity)
(JNIEnv* env, jclass, jint handle, jbyte parity)
{
int32_t status = 0;
HAL_SetSerialParity(static_cast<HAL_SerialPort>(port), parity, &status);
HAL_SetSerialParity(static_cast<HAL_SerialPortHandle>(handle), parity,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetStopBits
* Signature: (BB)V
* Signature: (IB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetStopBits
(JNIEnv* env, jclass, jbyte port, jbyte bits)
(JNIEnv* env, jclass, jint handle, jbyte bits)
{
int32_t status = 0;
HAL_SetSerialStopBits(static_cast<HAL_SerialPort>(port), bits, &status);
HAL_SetSerialStopBits(static_cast<HAL_SerialPortHandle>(handle), bits,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetWriteMode
* Signature: (BB)V
* Signature: (IB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetWriteMode
(JNIEnv* env, jclass, jbyte port, jbyte mode)
(JNIEnv* env, jclass, jint handle, jbyte mode)
{
int32_t status = 0;
HAL_SetSerialWriteMode(static_cast<HAL_SerialPort>(port), mode, &status);
HAL_SetSerialWriteMode(static_cast<HAL_SerialPortHandle>(handle), mode,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetFlowControl
* Signature: (BB)V
* Signature: (IB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetFlowControl
(JNIEnv* env, jclass, jbyte port, jbyte flow)
(JNIEnv* env, jclass, jint handle, jbyte flow)
{
int32_t status = 0;
HAL_SetSerialFlowControl(static_cast<HAL_SerialPort>(port), flow, &status);
HAL_SetSerialFlowControl(static_cast<HAL_SerialPortHandle>(handle), flow,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetTimeout
* Signature: (BD)V
* Signature: (ID)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetTimeout
(JNIEnv* env, jclass, jbyte port, jdouble timeout)
(JNIEnv* env, jclass, jint handle, jdouble timeout)
{
int32_t status = 0;
HAL_SetSerialTimeout(static_cast<HAL_SerialPort>(port), timeout, &status);
HAL_SetSerialTimeout(static_cast<HAL_SerialPortHandle>(handle), timeout,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialEnableTermination
* Signature: (BC)V
* Signature: (IC)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialEnableTermination
(JNIEnv* env, jclass, jbyte port, jchar terminator)
(JNIEnv* env, jclass, jint handle, jchar terminator)
{
int32_t status = 0;
HAL_EnableSerialTermination(static_cast<HAL_SerialPort>(port), terminator,
&status);
HAL_EnableSerialTermination(static_cast<HAL_SerialPortHandle>(handle),
terminator, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialDisableTermination
* Signature: (B)V
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialDisableTermination
(JNIEnv* env, jclass, jbyte port)
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_DisableSerialTermination(static_cast<HAL_SerialPort>(port), &status);
HAL_DisableSerialTermination(static_cast<HAL_SerialPortHandle>(handle),
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetReadBufferSize
* Signature: (BI)V
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetReadBufferSize
(JNIEnv* env, jclass, jbyte port, jint size)
(JNIEnv* env, jclass, jint handle, jint size)
{
int32_t status = 0;
HAL_SetSerialReadBufferSize(static_cast<HAL_SerialPort>(port), size, &status);
HAL_SetSerialReadBufferSize(static_cast<HAL_SerialPortHandle>(handle), size,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialSetWriteBufferSize
* Signature: (BI)V
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialSetWriteBufferSize
(JNIEnv* env, jclass, jbyte port, jint size)
(JNIEnv* env, jclass, jint handle, jint size)
{
int32_t status = 0;
HAL_SetSerialWriteBufferSize(static_cast<HAL_SerialPort>(port), size,
HAL_SetSerialWriteBufferSize(static_cast<HAL_SerialPortHandle>(handle), size,
&status);
CheckStatus(env, status);
}
@@ -209,15 +221,15 @@ Java_edu_wpi_first_hal_SerialPortJNI_serialSetWriteBufferSize
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialGetBytesReceived
* Signature: (B)I
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialGetBytesReceived
(JNIEnv* env, jclass, jbyte port)
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
jint retVal =
HAL_GetSerialBytesReceived(static_cast<HAL_SerialPort>(port), &status);
jint retVal = HAL_GetSerialBytesReceived(
static_cast<HAL_SerialPortHandle>(handle), &status);
CheckStatus(env, status);
return retVal;
}
@@ -225,16 +237,16 @@ Java_edu_wpi_first_hal_SerialPortJNI_serialGetBytesReceived
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialRead
* Signature: (B[BI)I
* Signature: (I[BI)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialRead
(JNIEnv* env, jclass, jbyte port, jbyteArray dataReceived, jint size)
(JNIEnv* env, jclass, jint handle, jbyteArray dataReceived, jint size)
{
wpi::SmallVector<char, 128> recvBuf;
recvBuf.resize(size);
int32_t status = 0;
jint retVal = HAL_ReadSerial(static_cast<HAL_SerialPort>(port),
jint retVal = HAL_ReadSerial(static_cast<HAL_SerialPortHandle>(handle),
recvBuf.data(), size, &status);
env->SetByteArrayRegion(dataReceived, 0, size,
reinterpret_cast<const jbyte*>(recvBuf.data()));
@@ -245,15 +257,15 @@ Java_edu_wpi_first_hal_SerialPortJNI_serialRead
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialWrite
* Signature: (B[BI)I
* Signature: (I[BI)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialWrite
(JNIEnv* env, jclass, jbyte port, jbyteArray dataToSend, jint size)
(JNIEnv* env, jclass, jint handle, jbyteArray dataToSend, jint size)
{
int32_t status = 0;
jint retVal =
HAL_WriteSerial(static_cast<HAL_SerialPort>(port),
HAL_WriteSerial(static_cast<HAL_SerialPortHandle>(handle),
reinterpret_cast<const char*>(
JByteArrayRef(env, dataToSend).array().data()),
size, &status);
@@ -264,42 +276,42 @@ Java_edu_wpi_first_hal_SerialPortJNI_serialWrite
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialFlush
* Signature: (B)V
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialFlush
(JNIEnv* env, jclass, jbyte port)
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_FlushSerial(static_cast<HAL_SerialPort>(port), &status);
HAL_FlushSerial(static_cast<HAL_SerialPortHandle>(handle), &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialClear
* Signature: (B)V
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialClear
(JNIEnv* env, jclass, jbyte port)
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_ClearSerial(static_cast<HAL_SerialPort>(port), &status);
HAL_ClearSerial(static_cast<HAL_SerialPortHandle>(handle), &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_SerialPortJNI
* Method: serialClose
* Signature: (B)V
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_SerialPortJNI_serialClose
(JNIEnv* env, jclass, jbyte port)
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_CloseSerial(static_cast<HAL_SerialPort>(port), &status);
HAL_CloseSerial(static_cast<HAL_SerialPortHandle>(handle), &status);
CheckStatus(env, status);
}

116
hal/src/main/native/include/hal/SerialPort.h
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2016-2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2016-2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -38,39 +38,51 @@ extern "C" {
*
* @param port the serial port to initialize
*/
void HAL_InitializeSerialPort(HAL_SerialPort port, int32_t* status);
HAL_SerialPortHandle HAL_InitializeSerialPort(HAL_SerialPort port,
int32_t* status);
/**
* Initializes a serial port with a direct name.
*
* This name is the VISA name for a specific port (find this in the web dash).
* This name is the /dev name for a specific port.
* Note these are not always consistent between roboRIO reboots.
*
* @param port the serial port to initialize
* @param portName the VISA port name
* @param portName the dev port name
*/
void HAL_InitializeSerialPortDirect(HAL_SerialPort port, const char* portName,
int32_t* status);
HAL_SerialPortHandle HAL_InitializeSerialPortDirect(HAL_SerialPort port,
const char* portName,
int32_t* status);
/**
* Gets the raw serial port file descriptor from a handle.
*
* @param handle the serial port handle
* @return the raw port descriptor
*/
int HAL_GetSerialFD(HAL_SerialPortHandle handle, int32_t* status);
/**
* Sets the baud rate of a serial port.
*
* Any value between 0 and 0xFFFFFFFF may be used. Default is 9600.
*
* @param port the serial port
* @param baud the baud rate to set
* @param handle the serial port handle
* @param baud the baud rate to set
*/
void HAL_SetSerialBaudRate(HAL_SerialPort port, int32_t baud, int32_t* status);
void HAL_SetSerialBaudRate(HAL_SerialPortHandle handle, int32_t baud,
int32_t* status);
/**
* Sets the number of data bits on a serial port.
*
* Defaults to 8.
*
* @param port the serial port
* @param bits the number of data bits (5-8)
* @param handle the serial port handle
* @param bits the number of data bits (5-8)
*/
void HAL_SetSerialDataBits(HAL_SerialPort port, int32_t bits, int32_t* status);
void HAL_SetSerialDataBits(HAL_SerialPortHandle handle, int32_t bits,
int32_t* status);
/**
* Sets the number of parity bits on a serial port.
@@ -82,10 +94,11 @@ void HAL_SetSerialDataBits(HAL_SerialPort port, int32_t bits, int32_t* status);
* 3: Mark - Means exists and always 1
* 4: Space - Means exists and always 0
*
* @param port the serial port
* @param handle the serial port handle
* @param parity the parity bit mode (see remarks for valid values)
*/
void HAL_SetSerialParity(HAL_SerialPort port, int32_t parity, int32_t* status);
void HAL_SetSerialParity(HAL_SerialPortHandle handle, int32_t parity,
int32_t* status);
/**
* Sets the number of stop bits on a serial port.
@@ -95,10 +108,10 @@ void HAL_SetSerialParity(HAL_SerialPort port, int32_t parity, int32_t* status);
* 15: One and a half stop bits
* 20: Two stop bits
*
* @param port the serial port
* @param handle the serial port handle
* @param stopBits the stop bit value (see remarks for valid values)
*/
void HAL_SetSerialStopBits(HAL_SerialPort port, int32_t stopBits,
void HAL_SetSerialStopBits(HAL_SerialPortHandle handle, int32_t stopBits,
int32_t* status);
/**
@@ -108,10 +121,11 @@ void HAL_SetSerialStopBits(HAL_SerialPort port, int32_t stopBits,
* 1: Flush on access
* 2: Flush when full (default)
*
* @param port the serial port
* @param mode the mode to set (see remarks for valid values)
* @param handle the serial port handle
* @param mode the mode to set (see remarks for valid values)
*/
void HAL_SetSerialWriteMode(HAL_SerialPort port, int32_t mode, int32_t* status);
void HAL_SetSerialWriteMode(HAL_SerialPortHandle handle, int32_t mode,
int32_t* status);
/**
* Sets the flow control mode of a serial port.
@@ -122,63 +136,65 @@ void HAL_SetSerialWriteMode(HAL_SerialPort port, int32_t mode, int32_t* status);
* 2: RTS-CTS
* 3: DTR-DSR
*
* @param port the serial port
* @param flow the mode to set (see remarks for valid values)
* @param handle the serial port handle
* @param flow the mode to set (see remarks for valid values)
*/
void HAL_SetSerialFlowControl(HAL_SerialPort port, int32_t flow,
void HAL_SetSerialFlowControl(HAL_SerialPortHandle handle, int32_t flow,
int32_t* status);
/**
* Sets the minimum serial read timeout of a port.
*
* @param port the serial port
* @param handle the serial port handle
* @param timeout the timeout in milliseconds
*/
void HAL_SetSerialTimeout(HAL_SerialPort port, double timeout, int32_t* status);
void HAL_SetSerialTimeout(HAL_SerialPortHandle handle, double timeout,
int32_t* status);
/**
* Sets the termination character that terminates a read.
*
* By default this is disabled.
*
* @param port the serial port
* @param handle the serial port handle
* @param terminator the termination character to set
*/
void HAL_EnableSerialTermination(HAL_SerialPort port, char terminator,
void HAL_EnableSerialTermination(HAL_SerialPortHandle handle, char terminator,
int32_t* status);
/**
* Disables a termination character for reads.
*
* @param port the serial port
* @param handle the serial port handle
*/
void HAL_DisableSerialTermination(HAL_SerialPort port, int32_t* status);
void HAL_DisableSerialTermination(HAL_SerialPortHandle handle, int32_t* status);
/**
* Sets the size of the read buffer.
*
* @param port the serial port
* @param size the read buffer size
* @param handle the serial port handle
* @param size the read buffer size
*/
void HAL_SetSerialReadBufferSize(HAL_SerialPort port, int32_t size,
void HAL_SetSerialReadBufferSize(HAL_SerialPortHandle handle, int32_t size,
int32_t* status);
/**
* Sets the size of the write buffer.
*
* @param port the serial port
* @param size the write buffer size
* @param handle the serial port handle
* @param size the write buffer size
*/
void HAL_SetSerialWriteBufferSize(HAL_SerialPort port, int32_t size,
void HAL_SetSerialWriteBufferSize(HAL_SerialPortHandle handle, int32_t size,
int32_t* status);
/**
* Gets the number of bytes currently in the read buffer.
*
* @param port the serial port
* @return the number of bytes in the read buffer
* @param handle the serial port handle
* @return the number of bytes in the read buffer
*/
int32_t HAL_GetSerialBytesReceived(HAL_SerialPort port, int32_t* status);
int32_t HAL_GetSerialBytesReceived(HAL_SerialPortHandle handle,
int32_t* status);
/**
* Reads data from the serial port.
@@ -186,44 +202,44 @@ int32_t HAL_GetSerialBytesReceived(HAL_SerialPort port, int32_t* status);
* Will wait for either timeout (if set), the termination char (if set), or the
* count to be full. Whichever one comes first.
*
* @param port the serial port
* @param count the number of bytes maximum to read
* @return the number of bytes actually read
* @param handle the serial port handle
* @param count the number of bytes maximum to read
* @return the number of bytes actually read
*/
int32_t HAL_ReadSerial(HAL_SerialPort port, char* buffer, int32_t count,
int32_t HAL_ReadSerial(HAL_SerialPortHandle handle, char* buffer, int32_t count,
int32_t* status);
/**
* Writes data to the serial port.
*
* @param port the serial port
* @param handle the serial port handle
* @param buffer the buffer to write
* @param count the number of bytes to write from the buffer
* @return the number of bytes actually written
*/
int32_t HAL_WriteSerial(HAL_SerialPort port, const char* buffer, int32_t count,
int32_t* status);
int32_t HAL_WriteSerial(HAL_SerialPortHandle handle, const char* buffer,
int32_t count, int32_t* status);
/**
* Flushes the serial write buffer out to the port.
*
* @param port the serial port
* @param handle the serial port handle
*/
void HAL_FlushSerial(HAL_SerialPort port, int32_t* status);
void HAL_FlushSerial(HAL_SerialPortHandle handle, int32_t* status);
/**
* Clears the receive buffer of the serial port.
*
* @param port the serial port
* @param handle the serial port handle
*/
void HAL_ClearSerial(HAL_SerialPort port, int32_t* status);
void HAL_ClearSerial(HAL_SerialPortHandle handle, int32_t* status);
/**
* Closes a serial port.
*
* @param port the serial port to close
* @param handle the serial port handle to close
*/
void HAL_CloseSerial(HAL_SerialPort port, int32_t* status);
void HAL_CloseSerial(HAL_SerialPortHandle handle, int32_t* status);
#ifdef __cplusplus
} // extern "C"
#endif

2
hal/src/main/native/include/hal/Types.h
View File

@@ -49,6 +49,8 @@ typedef HAL_Handle HAL_RelayHandle;
typedef HAL_Handle HAL_SolenoidHandle;
typedef HAL_Handle HAL_SerialPortHandle;
typedef HAL_Handle HAL_CANHandle;
typedef HAL_CANHandle HAL_PDPHandle;

3
hal/src/main/native/include/hal/handles/HandlesInternal.h
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2016-2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2016-2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -65,6 +65,7 @@ enum class HAL_HandleEnum {
Vendor = 17,
SimulationJni = 18,
CAN = 19,
SerialPort = 20,
};
/**

68
hal/src/main/native/sim/SerialPort.cpp
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2017-2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -16,62 +16,72 @@ void InitializeSerialPort() {}
} // namespace hal
extern "C" {
void HAL_InitializeSerialPort(HAL_SerialPort port, int32_t* status) {
HAL_SerialPortHandle HAL_InitializeSerialPort(HAL_SerialPort port,
int32_t* status) {
hal::init::CheckInit();
return HAL_kInvalidHandle;
}
void HAL_InitializeSerialPortDirect(HAL_SerialPort port, const char* portName,
int32_t* status) {}
void HAL_SetSerialBaudRate(HAL_SerialPort port, int32_t baud, int32_t* status) {
HAL_SerialPortHandle HAL_InitializeSerialPortDirect(HAL_SerialPort port,
const char* portName,
int32_t* status) {
hal::init::CheckInit();
return HAL_kInvalidHandle;
}
void HAL_SetSerialDataBits(HAL_SerialPort port, int32_t bits, int32_t* status) {
}
int HAL_GetSerialFD(HAL_SerialPortHandle handle, int32_t* status) { return -1; }
void HAL_SetSerialParity(HAL_SerialPort port, int32_t parity, int32_t* status) {
}
void HAL_SetSerialStopBits(HAL_SerialPort port, int32_t stopBits,
void HAL_SetSerialBaudRate(HAL_SerialPortHandle handle, int32_t baud,
int32_t* status) {}
void HAL_SetSerialWriteMode(HAL_SerialPort port, int32_t mode,
void HAL_SetSerialDataBits(HAL_SerialPortHandle handle, int32_t bits,
int32_t* status) {}
void HAL_SetSerialParity(HAL_SerialPortHandle handle, int32_t parity,
int32_t* status) {}
void HAL_SetSerialStopBits(HAL_SerialPortHandle handle, int32_t stopBits,
int32_t* status) {}
void HAL_SetSerialWriteMode(HAL_SerialPortHandle handle, int32_t mode,
int32_t* status) {}
void HAL_SetSerialFlowControl(HAL_SerialPort port, int32_t flow,
void HAL_SetSerialFlowControl(HAL_SerialPortHandle handle, int32_t flow,
int32_t* status) {}
void HAL_SetSerialTimeout(HAL_SerialPort port, double timeout,
void HAL_SetSerialTimeout(HAL_SerialPortHandle handle, double timeout,
int32_t* status) {}
void HAL_EnableSerialTermination(HAL_SerialPort port, char terminator,
void HAL_EnableSerialTermination(HAL_SerialPortHandle handle, char terminator,
int32_t* status) {}
void HAL_DisableSerialTermination(HAL_SerialPort port, int32_t* status) {}
void HAL_SetSerialReadBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status) {}
void HAL_SetSerialWriteBufferSize(HAL_SerialPort port, int32_t size,
void HAL_DisableSerialTermination(HAL_SerialPortHandle handle,
int32_t* status) {}
int32_t HAL_GetSerialBytesReceived(HAL_SerialPort port, int32_t* status) {
void HAL_SetSerialReadBufferSize(HAL_SerialPortHandle handle, int32_t size,
int32_t* status) {}
void HAL_SetSerialWriteBufferSize(HAL_SerialPortHandle handle, int32_t size,
int32_t* status) {}
int32_t HAL_GetSerialBytesReceived(HAL_SerialPortHandle handle,
int32_t* status) {
return 0;
}
int32_t HAL_ReadSerial(HAL_SerialPort port, char* buffer, int32_t count,
int32_t HAL_ReadSerial(HAL_SerialPortHandle handle, char* buffer, int32_t count,
int32_t* status) {
return 0;
}
int32_t HAL_WriteSerial(HAL_SerialPort port, const char* buffer, int32_t count,
int32_t* status) {
int32_t HAL_WriteSerial(HAL_SerialPortHandle handle, const char* buffer,
int32_t count, int32_t* status) {
return 0;
}
void HAL_FlushSerial(HAL_SerialPort port, int32_t* status) {}
void HAL_FlushSerial(HAL_SerialPortHandle handle, int32_t* status) {}
void HAL_ClearSerial(HAL_SerialPort port, int32_t* status) {}
void HAL_ClearSerial(HAL_SerialPortHandle handle, int32_t* status) {}
void HAL_CloseSerial(HAL_SerialPort port, int32_t* status) {}
void HAL_CloseSerial(HAL_SerialPortHandle handle, int32_t* status) {}
} // extern "C"