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;
}
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 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;
}
static int
testSerialIdentifier (const char **identifier) {
return isSerialDevice(identifier);
}