static void
brl_destruct (BrailleDisplay *brl) {
if (serialDevice) {
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
}
static void
brl_destruct (BrailleDisplay *brl) {
#ifdef USE_CURSES
if (ttyScreen) {
endwin();
#ifndef __MINGW32__
delscreen(ttyScreen);
#endif /* __MINGW32__ */
ttyScreen = NULL;
}
#endif /* USE_CURSES */
if (ttyDevice) {
ttyStream = NULL;
serialCloseDevice(ttyDevice);
ttyDevice = NULL;
}
#ifdef HAVE_ICONV_H
if (conversionDescriptor) {
iconv_close(conversionDescriptor);
conversionDescriptor = NULL;
}
#endif /* HAVE_ICONV_H */
}
static void brl_destruct (BrailleDisplay *brl) {
unsigned char *pre_data = (unsigned char *)"\002\033Z"; /* string to send to */
unsigned char *post_data = (unsigned char *)"\001\015";
unsigned char *close_seq = (unsigned char *)"";
rawlen = 0;
if (pre_data[0]) {
memcpy (rawdata + rawlen, pre_data + 1, pre_data[0]);
rawlen += pre_data[0];
}
/* Clear the five status cells and the main display: */
memset (rawdata + rawlen, 0, 5 + 1+ brl->textColumns * brl->textRows);
rawlen += 5 + 1 + brl->textColumns * brl->textRows; /* +1 is for dummy module */
if (post_data[0]) {
memcpy (rawdata + rawlen, post_data + 1, post_data[0]);
rawlen += post_data[0];
}
/* Send closing sequence: */
if (close_seq[0]) {
memcpy (rawdata + rawlen, close_seq + 1, close_seq[0]);
rawlen += close_seq[0];
}
serialWriteData (MB_serialDevice, rawdata, rawlen);
free (prevdata);
free (rawdata);
serialCloseDevice (MB_serialDevice);
}
static void
closeSerialPort (void) {
if (serialDevice) {
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
}
static GioHandle *
connectSerialResource (
const char *identifier,
const GioDescriptor *descriptor
) {
GioHandle *handle = malloc(sizeof(*handle));
if (handle) {
memset(handle, 0, sizeof(*handle));
if ((handle->device = serialOpenDevice(identifier))) {
if (serialSetParameters(handle->device, descriptor->serial.parameters)) {
handle->parameters = *descriptor->serial.parameters;
return handle;
}
serialCloseDevice(handle->device);
}
free(handle);
} else {
logMallocError();
}
return NULL;
}
static void
brl_destruct (BrailleDisplay *brl) {
serialCloseDevice(serialDevice);
serialDevice = NULL;
free(cellBuffer);
cellBuffer = NULL;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
if ((serialDevice = serialOpenDevice(device))) {
if (serialRestartDevice(serialDevice, serialBaud)) {
static const unsigned char request[] = {BNO_DESCRIBE};
charactersPerSecond = serialBaud / 10;
if (writePacket(brl, request, sizeof(request)) != -1) {
while (serialAwaitInput(serialDevice, 100)) {
ResponsePacket response;
int size = getPacket(&response);
if (size) {
if (response.data.code == BNI_DESCRIBE) {
statusCells = response.data.values.description.statusCells;
brl->textColumns = response.data.values.description.textCells;
brl->textRows = 1;
brl->keyBindings = "keys";
if ((statusCells == 5) && (brl->textColumns == 30)) {
statusCells -= 2;
brl->textColumns += 2;
}
dataCells = brl->textColumns * brl->textRows;
cellCount = statusCells + dataCells;
makeOutputTable(dotsTable_ISO11548_1);
makeInputTable();
if ((cellBuffer = malloc(cellCount))) {
memset(cellBuffer, 0, cellCount);
statusArea = cellBuffer;
dataArea = statusArea + statusCells;
refreshCells(brl);
persistentKeyboardMode = KBM_NAVIGATE;
temporaryKeyboardMode = persistentKeyboardMode;
persistentRoutingOperation = BRL_BLK_ROUTE;
temporaryRoutingOperation = persistentRoutingOperation;
return 1;
} else {
logSystemError("cell buffer allocation");
}
} else {
logUnexpectedPacket(response.bytes, size);
}
}
}
}
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static void brl_destruct(BrailleDisplay *brl)
{
free(rawdata);
serialCloseDevice(serialDevice);
#ifdef DEBUG
close(brl_log);
#endif /* DEBUG */
}
SerialDevice *
serialOpenDevice (const char *identifier) {
char **parameters = serialGetDeviceParameters(identifier);
if (parameters) {
SerialDevice *serial;
if ((serial = malloc(sizeof(*serial)))) {
char *path;
{
const char *name = parameters[SERIAL_DEV_NAME];
if (!*name) name = SERIAL_FIRST_DEVICE;
path = getDevicePath(name);
}
if (path) {
int connected;
serial->fileDescriptor = -1;
serial->stream = NULL;
connected = serialConnectDevice(serial, path);
free(path);
path = NULL;
if (connected) {
int ok = 1;
if (!serialConfigureBaud(serial, parameters[SERIAL_DEV_BAUD])) ok = 0;
if (!serialConfigureDataBits(serial, parameters[SERIAL_DEV_DATA_BITS])) ok = 0;
if (!serialConfigureStopBits(serial, parameters[SERIAL_DEV_STOP_BITS])) ok = 0;
if (!serialConfigureParity(serial, parameters[SERIAL_DEV_PARITY])) ok = 0;
if (!serialConfigureFlowControl(serial, parameters[SERIAL_DEV_FLOW_CONTROL])) ok = 0;
deallocateStrings(parameters);
if (ok) return serial;
serialCloseDevice(serial);
return NULL;
}
}
free(serial);
} else {
logMallocError();
}
deallocateStrings(parameters);
}
return NULL;
}
static void
brl_destruct (BrailleDisplay *brl) {
if (outputBuffer) {
free(outputBuffer);
outputBuffer = NULL;
}
if (serialDevice) {
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
{
static const unsigned int baudTable[] = {9600, 19200, 0};
const char *baudParameter = parameters[PARM_BAUD];
if (!*baudParameter ||
!serialValidateBaud(&serialBaud, "baud", baudParameter, baudTable))
serialBaud = baudTable[0];
}
if (!isSerialDeviceIdentifier(&device)) {
unsupportedDeviceIdentifier(device);
return 0;
}
if ((serialDevice = serialOpenDevice(device))) {
if (serialRestartDevice(serialDevice, serialBaud)) {
charactersPerSecond = serialBaud / 10;
writeFunction = NULL;
{
static const TranslationTable outputTable = {
#define MAP(byte,cell) [cell] = byte
#include "brl-out.h"
#undef MAP
};
setOutputTable(outputTable);
}
{
static const int initialCommands[] = {
BRL_CMD_TUNES | BRL_FLG_TOGGLE_OFF,
BRL_CMD_CSRTRK | BRL_FLG_TOGGLE_OFF,
BRL_CMD_CSRVIS | BRL_FLG_TOGGLE_OFF,
BRL_CMD_ATTRVIS | BRL_FLG_TOGGLE_OFF,
EOF
};
initialCommand = initialCommands;
}
brl->textColumns = 80;
return 1;
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
openSerialPort (const char *device) {
if ((serialDevice = serialOpenDevice(device))) {
if (serialRestartDevice(serialDevice, SERIAL_BAUD))
if (serialSetFlowControl(serialDevice, SERIAL_FLOW_HARDWARE))
return 1;
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
openSerialPort (char **parameters, const char *device) {
if ((serialDevice = serialOpenDevice(device))) {
serialSetParity(serialDevice, SERIAL_PARITY_ODD);
if (serialRestartDevice(serialDevice, baud)) {
return 1;
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
if ((serialDevice = serialOpenDevice(device))) {
if (serialRestartDevice(serialDevice, serialBaud)) {
serialCharactersPerSecond = serialBaud / serialGetCharacterBits(serialDevice);
/* hm, how to switch to 38400 ?
static const unsigned char sequence[] = {ESC, 'V', CR};
writeData(brl, sequence, sizeof(sequence));
serialDiscardInput(serialDevice);
serialSetBaud(serialDevice, 38400);
*/
{
static const DotsTable dots = {
0X01, 0X02, 0X04, 0X80, 0X40, 0X20, 0X08, 0X10
};
makeOutputTable(dots);
}
clearCells(textCells, sizeof(textCells));
clearCells(statusCells, sizeof(statusCells));
resetInputMode();
cursorDots = 0XFF;
cursorOffset = sizeof(textCells) / 2;
brl->textColumns = sizeof(textCells);
brl->textRows = 1;
brl->statusColumns = sizeof(statusCells);
brl->statusRows = 1;
beep(brl);
return 1;
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
if ((serialDevice = serialOpenDevice(device))) {
unsigned int baud = 19200;
charactersPerSecond = baud / 11;
if (serialRestartDevice(serialDevice, baud)) {
if (serialSetParity(serialDevice, SERIAL_PARITY_EVEN)) {
if (writePacket(brl, 4, NULL, 0)) {
while (serialAwaitInput(serialDevice, 500)) {
unsigned char response[3];
int size = readPacket(brl, response, sizeof(response));
if (size <= 0) break;
if (response[1] == 4) {
brl->textColumns = response[2];
brl->textRows = 1;
makeOutputTable(dotsTable_ISO11548_1);
makeInputTable();
if (!clearBrailleCells(brl)) break;
if (!clearVisualText(brl)) break;
if (!writeBrailleCells(brl)) break;
return 1;
}
}
}
}
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
if ((serialDevice = serialOpenDevice(device))) {
static const unsigned int baud = 9600;
charactersPerSecond = baud / 10;
if (serialRestartDevice(serialDevice, baud)) {
if (identifyDisplay(brl)) {
{
static const DotsTable dots = {
0X01, 0X02, 0X04, 0X10, 0X20, 0X40, 0X08, 0X80
};
makeOutputTable(dots);
}
if ((outputBuffer = malloc(brl->textColumns))) {
if (setTable(brl, 0)) {
memset(outputBuffer, 0, brl->textColumns);
writeCells(brl);
return 1;
}
free(outputBuffer);
outputBuffer = NULL;
} else {
logSystemError("Output buffer allocation");
}
}
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
{
static TranslationTable outputTable = {
#include "brl-out.h"
};
setOutputTable(outputTable);
makeInputTable();
{
const unsigned char byte = 0XFF;
if (memchr(outputTable, byte, sizeof(outputTable))) {
outputTable[translateInputCell(byte)] = SUB;
}
}
}
if (!isSerialDeviceIdentifier(&device)) {
unsupportedDeviceIdentifier(device);
return 0;
}
makeDownloadFifo();
if ((serialDevice = serialOpenDevice(device))) {
if (serialRestartDevice(serialDevice, 9600)) {
brl->textRows = screenHeight;
brl->textColumns = screenWidth;
brl->buffer = &sourceImage[0][0];
memset(sourceImage, 0, sizeof(sourceImage));
deviceStatus = DEV_ONLINE;
return 1;
}
serialCloseDevice(serialDevice);
serialDevice = NULL;
}
return 0;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
unsigned int ttyBaud = 9600;
char *ttyType = "vt100";
int windowLines = 1;
int windowColumns = 40;
#ifdef HAVE_ICONV_H
const char *characterSet = getLocaleCharset();
#endif /* HAVE_ICONV_H */
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
{
unsigned int baud = ttyBaud;
if (serialValidateBaud(&baud, "TTY baud", parameters[PARM_BAUD], NULL))
ttyBaud = baud;
}
#ifdef USE_CURSES
if (*parameters[PARM_TERM])
ttyType = parameters[PARM_TERM];
#endif /* USE_CURSES */
{
static const int minimum = 1;
static const int maximum = MAX_WINDOW_LINES;
int lines = windowLines;
if (validateInteger(&lines, parameters[PARM_LINES], &minimum, &maximum)) {
windowLines = lines;
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid line count", parameters[PARM_LINES]);
}
}
{
static const int minimum = 1;
static const int maximum = MAX_WINDOW_COLUMNS;
int columns = windowColumns;
if (validateInteger(&columns, parameters[PARM_COLUMNS], &minimum, &maximum)) {
windowColumns = columns;
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid column count", parameters[PARM_COLUMNS]);
}
}
#ifdef HAVE_ICONV_H
if (*parameters[PARM_CHARSET])
characterSet = parameters[PARM_CHARSET];
#endif /* HAVE_ICONV_H */
if (*parameters[PARM_LOCALE])
classificationLocale = parameters[PARM_LOCALE];
#ifdef HAVE_ICONV_H
if ((conversionDescriptor = iconv_open(characterSet, "WCHAR_T")) != (iconv_t)-1) {
#endif /* HAVE_ICONV_H */
if ((ttyDevice = serialOpenDevice(device))) {
if (serialRestartDevice(ttyDevice, ttyBaud)) {
#ifdef USE_CURSES
if ((ttyStream = serialGetStream(ttyDevice))) {
if ((ttyScreen = newterm(ttyType, ttyStream, ttyStream))) {
cbreak();
noecho();
nonl();
nodelay(stdscr, TRUE);
intrflush(stdscr, FALSE);
keypad(stdscr, TRUE);
clear();
refresh();
#endif /* USE_CURSES */
brl->textColumns = windowColumns;
brl->textRows = windowLines;
logMessage(LOG_INFO, "TTY: type=%s baud=%u size=%dx%d",
ttyType, ttyBaud, windowColumns, windowLines);
return 1;
#ifdef USE_CURSES
} else {
logSystemError("newterm");
}
ttyStream = NULL;
}
#endif /* USE_CURSES */
}
serialCloseDevice(ttyDevice);
ttyDevice = NULL;
}
#ifdef HAVE_ICONV_H
iconv_close(conversionDescriptor);
} else {
logSystemError("iconv_open");
}
conversionDescriptor = NULL;
#endif /* HAVE_ICONV_H */
return 0;
}
GioEndpoint *
gioConnectResource (
const char *identifier,
const GioDescriptor *descriptor
) {
GioEndpoint *endpoint;
if ((endpoint = malloc(sizeof(*endpoint)))) {
endpoint->bytesPerSecond = 0;
endpoint->input.error = 0;
endpoint->input.from = 0;
endpoint->input.to = 0;
endpoint->hidReportItems.address = NULL;
endpoint->hidReportItems.size = 0;
if (descriptor->serial.parameters) {
if (isSerialDevice(&identifier)) {
if ((endpoint->handle.serial.device = serialOpenDevice(identifier))) {
if (serialSetParameters(endpoint->handle.serial.device, descriptor->serial.parameters)) {
endpoint->methods = &serialMethods;
endpoint->options = descriptor->serial.options;
setBytesPerSecond(endpoint, descriptor->serial.parameters);
goto connectSucceeded;
}
serialCloseDevice(endpoint->handle.serial.device);
}
goto connectFailed;
}
}
if (descriptor->usb.channelDefinitions) {
if (isUsbDevice(&identifier)) {
if ((endpoint->handle.usb.channel = usbFindChannel(descriptor->usb.channelDefinitions, identifier))) {
endpoint->methods = &usbMethods;
endpoint->options = descriptor->usb.options;
if (!endpoint->options.applicationData) {
endpoint->options.applicationData = endpoint->handle.usb.channel->definition.data;
}
{
UsbChannel *channel = endpoint->handle.usb.channel;
const SerialParameters *parameters = channel->definition.serial;
if (parameters) setBytesPerSecond(endpoint, parameters);
}
goto connectSucceeded;
}
goto connectFailed;
}
}
if (descriptor->bluetooth.channelNumber) {
if (isBluetoothDevice(&identifier)) {
if ((endpoint->handle.bluetooth.connection = bthOpenConnection(identifier, descriptor->bluetooth.channelNumber, 0))) {
endpoint->methods = &bluetoothMethods;
endpoint->options = descriptor->bluetooth.options;
goto connectSucceeded;
}
goto connectFailed;
}
}
errno = ENOSYS;
logMessage(LOG_WARNING, "unsupported input/output resource identifier: %s", identifier);
connectFailed:
free(endpoint);
} else {
logMallocError();
}
return NULL;
connectSucceeded:
{
int delay = endpoint->options.readyDelay;
if (delay) approximateDelay(delay);
}
if (!gioDiscardInput(endpoint)) {
int originalErrno = errno;
gioDisconnectResource(endpoint);
errno = originalErrno;
return NULL;
}
return endpoint;
}
static int
disconnectSerialResource (GioHandle *handle) {
serialCloseDevice(handle->serial.device);
return 1;
}
static int brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
short n, success; /* loop counters, flags, etc. */
unsigned char *init_seq = (unsigned char *)"\002\0330"; /* string to send to Braille to initialise: [ESC][0] */
unsigned char *init_ack = (unsigned char *)"\002\033V"; /* string to expect as acknowledgement: [ESC][V]... */
unsigned char c;
TimePeriod period;
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
brlcols = -1; /* length of braille display (auto-detected) */
prevdata = rawdata = NULL; /* clear pointers */
/* No need to load translation tables, as these are now
* defined in tables.h
*/
/* Now open the Braille display device for random access */
if (!(MB_serialDevice = serialOpenDevice(device))) goto failure;
if (!serialRestartDevice(MB_serialDevice, BAUDRATE)) goto failure;
if (!serialSetFlowControl(MB_serialDevice, SERIAL_FLOW_HARDWARE)) goto failure;
/* MultiBraille initialisation procedure:
* [ESC][V][Braillelength][Software Version][CR]
* I guess, they mean firmware version with software version :*}
* firmware version == [Software Version] / 10.0
*/
success = 0;
if (init_seq[0])
if (serialWriteData (MB_serialDevice, init_seq + 1, init_seq[0]) != init_seq[0])
goto failure;
startTimePeriod (&period, ACK_TIMEOUT); /* initialise timeout testing */
n = 0;
do {
approximateDelay (20);
if (serialReadData (MB_serialDevice, &c, 1, 0, 0) == 0)
continue;
if (n < init_ack[0] && c != init_ack[1 + n])
continue;
if (n == init_ack[0]) {
brlcols = c, success = 1;
/* reading version-info */
/* firmware version == [Software Version] / 10.0 */
serialReadData (MB_serialDevice, &c, 1, 0, 0);
logMessage (LOG_INFO, "MultiBraille: Version: %2.1f", c/10.0);
/* read trailing [CR] */
serialReadData (MB_serialDevice, &c, 1, 0, 0);
}
n++;
}
while (!afterTimePeriod (&period, NULL) && n <= init_ack[0]);
if (success && (brlcols != 25)) {
if ((prevdata = malloc(brl->textColumns * brl->textRows))) {
if ((rawdata = malloc(20 + (brl->textColumns * brl->textRows * 2)))) {
brl->textColumns = brlcols;
brl->textRows = BRLROWS;
brl->statusColumns = 5;
brl->statusRows = 1;
{
static const DotsTable dots = {
0X01, 0X02, 0X04, 0X80, 0X40, 0X20, 0X08, 0X10
};
makeOutputTable(dots);
}
return 1;
} else {
logMallocError();
}
free(prevdata);
} else {
logMallocError();
}
}
failure:
if (MB_serialDevice) {
serialCloseDevice(MB_serialDevice);
MB_serialDevice = NULL;
}
return 0;
}
