Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-01 02:41:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove OS Serial Port (#1141)

Browse Source 
It was done as a shim fix around some VISA issues that don't seem to exist anymore. Was never really tested, and I don't think ever actually worked.
This commit is contained in:
Thad House
2018-06-07 20:51:26 -07:00
committed by Peter Johnson
parent 0cde67143a
commit f6e4df6a18
9 changed files with 0 additions and 752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
hal/src/main/native/athena/HAL.cpp
View File

@@ -61,7 +61,6 @@ void InitializeHAL() {
InitializeI2C();
InitialzeInterrupts();
InitializeNotifier();
InitializeOSSerialPort();
InitializePCMInternal();
InitializePDP();
InitializePorts();

1
hal/src/main/native/athena/HALInitializer.h
View File

@@ -39,7 +39,6 @@ extern void InitializeHAL();
extern void InitializeI2C();
extern void InitialzeInterrupts();
extern void InitializeNotifier();
extern void InitializeOSSerialPort();
extern void InitializePCMInternal();
extern void InitializePDP();
extern void InitializePorts();

246
hal/src/main/native/athena/OSSerialPort.cpp
View File

@@ -1,246 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 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. */
/*----------------------------------------------------------------------------*/
#include "HAL/OSSerialPort.h"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>
#include <chrono>
#include <cstring>
#include <string>
#include "HAL/Errors.h"
#include "HAL/cpp/SerialHelper.h"
#include "HALInitializer.h"
static int portHandles[4]{-1, -1, -1, -1};
static std::chrono::milliseconds portTimeouts[4]{
std::chrono::milliseconds(0), std::chrono::milliseconds(0),
std::chrono::milliseconds(0), std::chrono::milliseconds(0)};
namespace hal {
namespace init {
void InitializeOSSerialPort() {
for (int i = 0; i < 4; i++) {
portHandles[i] = -1;
portTimeouts[i] = std::chrono::milliseconds(0);
}
}
} // namespace init
} // namespace hal
extern "C" {
void HAL_InitializeOSSerialPort(HAL_SerialPort port, int32_t* status) {
hal::init::CheckInit();
std::string portName;
hal::SerialHelper serialHelper;
portName = serialHelper.GetOSSerialPortName(port, status);
if (*status < 0) {
return;
}
int fs = open(portName.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
if (fs == -1) {
*status = HAL_SERIAL_PORT_OPEN_ERROR;
return;
}
portHandles[port] = fs;
struct termios options;
tcgetattr(fs, &options);
options.c_cflag = B9600 | CS8 | CLOCAL | CREAD;
options.c_iflag = 0;
options.c_oflag = 0;
options.c_lflag = 0;
tcflush(fs, TCIFLUSH);
tcsetattr(fs, TCSANOW, &options);
}
void HAL_SetOSSerialBaudRate(HAL_SerialPort port, int32_t baud,
int32_t* status) {
int baudRate = -1;
switch (baud) {
case 9600:
baudRate = B9600;
break;
case 19200:
baudRate = B19200;
break;
case 38400:
baudRate = B38400;
break;
case 57600:
baudRate = B57600;
break;
case 115200:
baudRate = B115200;
break;
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
struct termios options;
tcgetattr(portHandles[port], &options);
auto set = cfsetospeed(&options, baudRate);
if (set != 0) {
*status = HAL_SERIAL_PORT_ERROR;
return;
}
set = tcsetattr(portHandles[port], TCSANOW, &options);
if (set != 0) {
*status = HAL_SERIAL_PORT_ERROR;
return;
}
}
void HAL_SetOSSerialDataBits(HAL_SerialPort port, int32_t bits,
int32_t* status) {
int numBits = -1;
switch (bits) {
case 5:
numBits = CS5;
break;
case 6:
numBits = CS6;
break;
case 7:
numBits = CS7;
break;
case 8:
numBits = CS8;
break;
default:
*status = PARAMETER_OUT_OF_RANGE;
return;
}
struct termios options;
tcgetattr(portHandles[port], &options);
options.c_cflag &= ~CSIZE;
options.c_cflag |= numBits;
auto set = tcsetattr(portHandles[port], TCSANOW, &options);
if (set != 0) {
*status = HAL_SERIAL_PORT_ERROR;
return;
}
}
void HAL_SetOSSerialParity(HAL_SerialPort port, int32_t parity,
int32_t* status) {
// Just set none parity
struct termios options;
tcgetattr(portHandles[port], &options);
options.c_cflag &= ~PARENB;
auto set = tcsetattr(portHandles[port], TCSANOW, &options);
if (set != 0) {
*status = HAL_SERIAL_PORT_ERROR;
return;
}
}
void HAL_SetOSSerialStopBits(HAL_SerialPort port, int32_t stopBits,
int32_t* status) {
// Force 1 stop bit
struct termios options;
tcgetattr(portHandles[port], &options);
options.c_cflag &= ~CSTOPB;
auto set = tcsetattr(portHandles[port], TCSANOW, &options);
if (set != 0) {
*status = HAL_SERIAL_PORT_ERROR;
return;
}
}
void HAL_SetOSSerialWriteMode(HAL_SerialPort port, int32_t mode,
int32_t* status) {
// No op
}
void HAL_SetOSSerialFlowControl(HAL_SerialPort port, int32_t flow,
int32_t* status) {
// No op
}
void HAL_SetOSSerialTimeout(HAL_SerialPort port, double timeout,
int32_t* status) {
// Convert to millis
int t = timeout / 1000;
portTimeouts[port] = std::chrono::milliseconds(t);
}
void HAL_EnableOSSerialTermination(HAL_SerialPort port, char terminator,
int32_t* status) {
// \n is hardcoded for now. Will fix later
// Seems like a VISA only setting, need to check
}
void HAL_DisableOSSerialTermination(HAL_SerialPort port, int32_t* status) {
// Seems like a VISA only setting, need to check
}
void HAL_SetOSSerialReadBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status) {
// No op
}
void HAL_SetOSSerialWriteBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status) {
// No op
}
int32_t HAL_GetOSSerialBytesReceived(HAL_SerialPort port, int32_t* status) {
int bytes = 0;
ioctl(portHandles[port], FIONREAD, &bytes);
return bytes;
}
int32_t HAL_ReadOSSerial(HAL_SerialPort port, char* buffer, int32_t count,
int32_t* status) {
auto endTime = std::chrono::steady_clock::now() + portTimeouts[port];
int bytesRead = 0;
unsigned char buf[256];
do {
int rx = read(portHandles[port], buf, count - bytesRead);
std::memcpy(&buffer[bytesRead], buf, rx);
bytesRead += rx;
if (bytesRead >= count) break;
wpi::StringRef tmp(buffer, bytesRead);
auto loc = tmp.find('\n');
if (loc != wpi::StringRef::npos) {
bytesRead = loc;
break;
}
} while (std::chrono::steady_clock::now() < endTime);
return bytesRead;
}
int32_t HAL_WriteOSSerial(HAL_SerialPort port, const char* buffer,
int32_t count, int32_t* status) {
return write(portHandles[port], buffer, count);
}
void HAL_FlushOSSerial(HAL_SerialPort port, int32_t* status) {
tcdrain(portHandles[port]);
}
void HAL_ClearOSSerial(HAL_SerialPort port, int32_t* status) {
tcflush(portHandles[port], TCIOFLUSH);
}
void HAL_CloseOSSerial(HAL_SerialPort port, int32_t* status) {
close(portHandles[port]);
}
} // extern "C"

350
hal/src/main/native/cpp/jni/OSSerialPortJNI.cpp
View File

@@ -1,350 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2016-2018 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. */
/*----------------------------------------------------------------------------*/
#include <jni.h>
#include <cassert>
#include <wpi/jni_util.h>
#include "HAL/OSSerialPort.h"
#include "HAL/cpp/Log.h"
#include "HALUtil.h"
#include "edu_wpi_first_wpilibj_hal_OSSerialPortJNI.h"
using namespace frc;
using namespace wpi::java;
// set the logging level
TLogLevel osserialJNILogLevel = logWARNING;
#define SERIALJNI_LOG(level) \
if (level > osserialJNILogLevel) \
; \
else \
Log().Get(level)
extern "C" {
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialInitializePort
* Signature: (B)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialInitializePort
(JNIEnv* env, jclass, jbyte port)
{
SERIALJNI_LOG(logDEBUG) << "Calling Serial Initialize";
SERIALJNI_LOG(logDEBUG) << "Port = " << (jint)port;
int32_t status = 0;
HAL_InitializeOSSerialPort(static_cast<HAL_SerialPort>(port), &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatusForceThrow(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetBaudRate
* Signature: (BI)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetBaudRate
(JNIEnv* env, jclass, jbyte port, jint rate)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Baud Rate";
SERIALJNI_LOG(logDEBUG) << "Baud: " << rate;
int32_t status = 0;
HAL_SetOSSerialBaudRate(static_cast<HAL_SerialPort>(port), rate, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetDataBits
* Signature: (BB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetDataBits
(JNIEnv* env, jclass, jbyte port, jbyte bits)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Data Bits";
SERIALJNI_LOG(logDEBUG) << "Data Bits: " << bits;
int32_t status = 0;
HAL_SetOSSerialDataBits(static_cast<HAL_SerialPort>(port), bits, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetParity
* Signature: (BB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetParity
(JNIEnv* env, jclass, jbyte port, jbyte parity)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Parity";
SERIALJNI_LOG(logDEBUG) << "Parity: " << parity;
int32_t status = 0;
HAL_SetOSSerialParity(static_cast<HAL_SerialPort>(port), parity, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetStopBits
* Signature: (BB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetStopBits
(JNIEnv* env, jclass, jbyte port, jbyte bits)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Stop Bits";
SERIALJNI_LOG(logDEBUG) << "Stop Bits: " << bits;
int32_t status = 0;
HAL_SetOSSerialStopBits(static_cast<HAL_SerialPort>(port), bits, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetWriteMode
* Signature: (BB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetWriteMode
(JNIEnv* env, jclass, jbyte port, jbyte mode)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Write Mode";
SERIALJNI_LOG(logDEBUG) << "Write mode: " << mode;
int32_t status = 0;
HAL_SetOSSerialWriteMode(static_cast<HAL_SerialPort>(port), mode, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetFlowControl
* Signature: (BB)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetFlowControl
(JNIEnv* env, jclass, jbyte port, jbyte flow)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Flow Control";
SERIALJNI_LOG(logDEBUG) << "Flow Control: " << flow;
int32_t status = 0;
HAL_SetOSSerialFlowControl(static_cast<HAL_SerialPort>(port), flow, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetTimeout
* Signature: (BD)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetTimeout
(JNIEnv* env, jclass, jbyte port, jdouble timeout)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Timeout";
SERIALJNI_LOG(logDEBUG) << "Timeout: " << timeout;
int32_t status = 0;
HAL_SetOSSerialTimeout(static_cast<HAL_SerialPort>(port), timeout, &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialEnableTermination
* Signature: (BC)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialEnableTermination
(JNIEnv* env, jclass, jbyte port, jchar terminator)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Enable Termination";
SERIALJNI_LOG(logDEBUG) << "Terminator: " << terminator;
int32_t status = 0;
HAL_EnableOSSerialTermination(static_cast<HAL_SerialPort>(port), terminator,
&status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialDisableTermination
* Signature: (B)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialDisableTermination
(JNIEnv* env, jclass, jbyte port)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Disable termination";
int32_t status = 0;
HAL_DisableOSSerialTermination(static_cast<HAL_SerialPort>(port), &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetReadBufferSize
* Signature: (BI)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetReadBufferSize
(JNIEnv* env, jclass, jbyte port, jint size)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Read Buffer Size";
SERIALJNI_LOG(logDEBUG) << "Size: " << size;
int32_t status = 0;
HAL_SetOSSerialReadBufferSize(static_cast<HAL_SerialPort>(port), size,
&status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialSetWriteBufferSize
* Signature: (BI)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialSetWriteBufferSize
(JNIEnv* env, jclass, jbyte port, jint size)
{
SERIALJNI_LOG(logDEBUG) << "Setting Serial Write Buffer Size";
SERIALJNI_LOG(logDEBUG) << "Size: " << size;
int32_t status = 0;
HAL_SetOSSerialWriteBufferSize(static_cast<HAL_SerialPort>(port), size,
&status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialGetBytesReceived
* Signature: (B)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialGetBytesReceived
(JNIEnv* env, jclass, jbyte port)
{
SERIALJNI_LOG(logDEBUG) << "Serial Get Bytes Received";
int32_t status = 0;
jint retVal =
HAL_GetOSSerialBytesReceived(static_cast<HAL_SerialPort>(port), &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
return retVal;
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialRead
* Signature: (B[BI)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialRead
(JNIEnv* env, jclass, jbyte port, jbyteArray dataReceived, jint size)
{
SERIALJNI_LOG(logDEBUG) << "Serial Read";
wpi::SmallVector<char, 128> recvBuf;
recvBuf.resize(size);
int32_t status = 0;
jint retVal = HAL_ReadOSSerial(static_cast<HAL_SerialPort>(port),
recvBuf.data(), size, &status);
env->SetByteArrayRegion(dataReceived, 0, size,
reinterpret_cast<const jbyte*>(recvBuf.data()));
SERIALJNI_LOG(logDEBUG) << "ReturnValue = " << retVal;
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
return retVal;
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialWrite
* Signature: (B[BI)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialWrite
(JNIEnv* env, jclass, jbyte port, jbyteArray dataToSend, jint size)
{
SERIALJNI_LOG(logDEBUG) << "Serial Write";
int32_t status = 0;
jint retVal =
HAL_WriteOSSerial(static_cast<HAL_SerialPort>(port),
reinterpret_cast<const char*>(
JByteArrayRef(env, dataToSend).array().data()),
size, &status);
SERIALJNI_LOG(logDEBUG) << "ReturnValue = " << retVal;
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
return retVal;
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialFlush
* Signature: (B)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialFlush
(JNIEnv* env, jclass, jbyte port)
{
SERIALJNI_LOG(logDEBUG) << "Serial Flush";
int32_t status = 0;
HAL_FlushOSSerial(static_cast<HAL_SerialPort>(port), &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialClear
* Signature: (B)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialClear
(JNIEnv* env, jclass, jbyte port)
{
SERIALJNI_LOG(logDEBUG) << "Serial Clear";
int32_t status = 0;
HAL_ClearOSSerial(static_cast<HAL_SerialPort>(port), &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_wpilibj_hal_OSSerialPortJNI
* Method: serialClose
* Signature: (B)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_OSSerialPortJNI_serialClose
(JNIEnv* env, jclass, jbyte port)
{
SERIALJNI_LOG(logDEBUG) << "Serial Close";
int32_t status = 0;
HAL_CloseOSSerial(static_cast<HAL_SerialPort>(port), &status);
SERIALJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
}
} // extern "C"

50
hal/src/main/native/include/HAL/OSSerialPort.h
View File

@@ -1,50 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2016-2018 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. */
/*----------------------------------------------------------------------------*/
#pragma once
#include <stdint.h>
#include "SerialPort.h"
#ifdef __cplusplus
extern "C" {
#endif
void HAL_InitializeOSSerialPort(HAL_SerialPort port, int32_t* status);
void HAL_SetOSSerialBaudRate(HAL_SerialPort port, int32_t baud,
int32_t* status);
void HAL_SetOSSerialDataBits(HAL_SerialPort port, int32_t bits,
int32_t* status);
void HAL_SetOSSerialParity(HAL_SerialPort port, int32_t parity,
int32_t* status);
void HAL_SetOSSerialStopBits(HAL_SerialPort port, int32_t stopBits,
int32_t* status);
void HAL_SetOSSerialWriteMode(HAL_SerialPort port, int32_t mode,
int32_t* status);
void HAL_SetOSSerialFlowControl(HAL_SerialPort port, int32_t flow,
int32_t* status);
void HAL_SetOSSerialTimeout(HAL_SerialPort port, double timeout,
int32_t* status);
void HAL_EnableOSSerialTermination(HAL_SerialPort port, char terminator,
int32_t* status);
void HAL_DisableOSSerialTermination(HAL_SerialPort port, int32_t* status);
void HAL_SetOSSerialReadBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status);
void HAL_SetOSSerialWriteBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status);
int32_t HAL_GetOSSerialBytesReceived(HAL_SerialPort port, int32_t* status);
int32_t HAL_ReadOSSerial(HAL_SerialPort port, char* buffer, int32_t count,
int32_t* status);
int32_t HAL_WriteOSSerial(HAL_SerialPort port, const char* buffer,
int32_t count, int32_t* status);
void HAL_FlushOSSerial(HAL_SerialPort port, int32_t* status);
void HAL_ClearOSSerial(HAL_SerialPort port, int32_t* status);
void HAL_CloseOSSerial(HAL_SerialPort port, int32_t* status);
#ifdef __cplusplus
} // extern "C"
#endif

1
hal/src/main/native/sim/HAL.cpp
View File

@@ -61,7 +61,6 @@ void InitializeHAL() {
InitializeInterrupts();
InitializeMockHooks();
InitializeNotifier();
InitializeOSSerialPort();
InitializePDP();
InitializePorts();
InitializePower();

1
hal/src/main/native/sim/HALInitializer.h
View File

@@ -57,7 +57,6 @@ extern void InitializeI2C();
extern void InitializeInterrupts();
extern void InitializeMockHooks();
extern void InitializeNotifier();
extern void InitializeOSSerialPort();
extern void InitializePDP();
extern void InitializePorts();
extern void InitializePower();

56
hal/src/main/native/sim/OSSerialPort.cpp
View File

@@ -1,56 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 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. */
/*----------------------------------------------------------------------------*/
#include "HAL/SerialPort.h"
#include "HALInitializer.h"
namespace hal {
namespace init {
void InitializeOSSerialPort() {}
} // namespace init
} // namespace hal
extern "C" {
void HAL_InitializeOSSerialPort(HAL_SerialPort port, int32_t* status) {
hal::init::CheckInit();
}
void HAL_SetOSSerialBaudRate(HAL_SerialPort port, int32_t baud,
int32_t* status) {}
void HAL_SetOSSerialDataBits(HAL_SerialPort port, int32_t bits,
int32_t* status) {}
void HAL_SetOSSerialParity(HAL_SerialPort port, int32_t parity,
int32_t* status) {}
void HAL_SetOSSerialStopBits(HAL_SerialPort port, int32_t stopBits,
int32_t* status) {}
void HAL_SetOSSerialWriteMode(HAL_SerialPort port, int32_t mode,
int32_t* status) {}
void HAL_SetOSSerialFlowControl(HAL_SerialPort port, int32_t flow,
int32_t* status) {}
void HAL_SetOSSerialTimeout(HAL_SerialPort port, double timeout,
int32_t* status) {}
void HAL_EnableOSSerialTermination(HAL_SerialPort port, char terminator,
int32_t* status) {}
void HAL_DisableOSSerialTermination(HAL_SerialPort port, int32_t* status) {}
void HAL_SetOSSerialReadBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status) {}
void HAL_SetOSSerialWriteBufferSize(HAL_SerialPort port, int32_t size,
int32_t* status) {}
int32_t HAL_GetOSSerialBytesReceived(HAL_SerialPort port, int32_t* status) {
return 0;
}
int32_t HAL_ReadOSSerial(HAL_SerialPort port, char* buffer, int32_t count,
int32_t* status) {
return 0;
}
int32_t HAL_WriteOSSerial(HAL_SerialPort port, const char* buffer,
int32_t count, int32_t* status) {
return 0;
}
void HAL_FlushOSSerial(HAL_SerialPort port, int32_t* status) {}
void HAL_ClearOSSerial(HAL_SerialPort port, int32_t* status) {}
void HAL_CloseOSSerial(HAL_SerialPort port, int32_t* status) {}
} // extern "C"