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 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 (!isSerialDevice(&device)) {
unsupportedDevice(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;
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
if (!allocateCommandDescriptors()) return 0;
inputLength = 0;
inputStart = 0;
inputEnd = 0;
outputLength = 0;
if (isQualifiedDevice(&device, "client")) {
static const ModeEntry clientModeEntry = {
#ifdef AF_LOCAL
requestLocalConnection,
#endif /* AF_LOCAL */
#ifdef __MINGW32__
requestNamedPipeConnection,
#endif /* __MINGW32__ */
requestInetConnection
};
mode = &clientModeEntry;
} else if (isQualifiedDevice(&device, "server")) {
static const ModeEntry serverModeEntry = {
#ifdef AF_LOCAL
acceptLocalConnection,
#endif /* AF_LOCAL */
#ifdef __MINGW32__
acceptNamedPipeConnection,
#endif /* __MINGW32__ */
acceptInetConnection
};
mode = &serverModeEntry;
} else {
unsupportedDevice(device);
goto failed;
}
if (!*device) device = VR_DEFAULT_SOCKET;
#ifdef AF_LOCAL
if (device[0] == '/') {
struct sockaddr_un address;
if (setLocalAddress(device, &address)) {
fileDescriptor = mode->getLocalConnection(&address);
}
} else
#endif /* AF_LOCAL */
#ifdef __MINGW32__
if (device[0] == '\\') {
fileDescriptor = mode->getNamedPipeConnection(device);
} else {
static WSADATA wsadata;
if (WSAStartup(MAKEWORD(1, 1), &wsadata)) {
logWindowsSystemError("socket library start");
goto failed;
}
}
#endif /* __MINGW32__ */
{
struct sockaddr_in address;
if (setInetAddress(device, &address)) {
fileDescriptor = mode->getInetConnection(&address);
}
}
if (fileDescriptor != -1) {
char *line = NULL;
while (1) {
if (line) free(line);
if ((line = readCommandLine())) {
const char *word;
logMessage(LOG_DEBUG, "command received: %s", line);
if ((word = strtok(line, inputDelimiters))) {
if (testWord(word, "cells")) {
if (dimensionsChanged(brl)) {
free(line);
return 1;
}
} else if (testWord(word, "quit")) {
break;
} else {
logMessage(LOG_WARNING, "unexpected command: %s", word);
}
}
} else {
asyncWait(1000);
}
}
if (line) free(line);
close(fileDescriptor);
fileDescriptor = -1;
}
failed:
deallocateCommandDescriptors();
return 0;
}
static int brl_construct(BrailleDisplay *brl, char **parameters, const char *device)
{
short ModelID = MODEL;
unsigned char buffer[DIM_BRL_ID + 6];
if (!isSerialDevice(&device)) {
unsupportedDevice(device);
return 0;
}
rawdata = NULL; /* clear pointers */
/* Open the Braille display device */
if (!(serialDevice = serialOpenDevice(device))) goto failure;
#ifdef DEBUG
brl_log = open("/tmp/brllog", O_CREAT | O_WRONLY);
if(brl_log < 0){
goto failure;
}
#endif /* DEBUG */
/* autodetecting ECO model */
do{
/* DTR back on */
serialRestartDevice(serialDevice, BAUDRATE); /* activate new settings */
/* The 2 next lines can be commented out to try autodetect once anyway */
if(ModelID != ECO_AUTO){
break;
}
if(serialReadData(serialDevice, &buffer, DIM_BRL_ID + 6, 600, 100) == DIM_BRL_ID + 6){
if(memcmp (buffer, BRL_ID, DIM_BRL_ID) == 0){
/* Possible values; 0x20, 0x40, 0x80 */
int tmpModel=buffer[DIM_BRL_ID] / 0x20;
switch(tmpModel){
case 1: ModelID=0;
break;
case 2: ModelID=1;
break;
case 4: ModelID=2;
break;
default: ModelID=1;
}
}
}
}while(ModelID == ECO_AUTO);
if(ModelID >= NB_MODEL || ModelID < 0){
goto failure; /* unknown model */
}
/* Need answer to BR */
/*do{*/
serialWriteData(serialDevice, SYS_READY, DIM_SYS_READY);
serialReadData(serialDevice, &buffer, DIM_BRL_READY + 6, 100, 100);
/*}while(strncmp (buffer, BRL_READY, DIM_BRL_READY));*/
logMessage(LOG_DEBUG, "buffer is: %s",buffer);
/* Set model params */
model = &Models[ModelID];
brl->textColumns = model->Cols; /* initialise size of main display */
brl->textRows = BRLROWS; /* ever is 1 in this type of braille lines */
MAKE_OUTPUT_TABLE(0X10, 0X20, 0X40, 0X01, 0X02, 0X04, 0X80, 0X08);
/* Need to calculate the size; Cols + Status + 1 (space between) */
BrailleSize = brl->textColumns + model->NbStCells + 1;
/* Allocate space for buffers */
rawdata = malloc(BrailleSize); /* Phisical size */
if(!rawdata){
goto failure;
}
/* Empty buffers */
memset(rawdata, 0, BrailleSize);
memset(Status, 0, MAX_STCELLS);
return 1;
failure:;
if(rawdata){
free(rawdata);
}
return 0;
}
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;
}