ssize_t
usbControlTransfer (
UsbDevice *device,
uint8_t direction,
uint8_t recipient,
uint8_t type,
uint8_t request,
uint16_t value,
uint16_t index,
void *buffer,
uint16_t length,
int timeout
) {
UsbDeviceExtension *devx = device->extension;
if (usbOpenUsbfsFile(devx)) {
union {
struct usbdevfs_ctrltransfer transfer;
UsbSetupPacket setup;
} arg;
memset(&arg, 0, sizeof(arg));
arg.setup.bRequestType = direction | recipient | type;
arg.setup.bRequest = request;
putLittleEndian16(&arg.setup.wValue, value);
putLittleEndian16(&arg.setup.wIndex, index);
putLittleEndian16(&arg.setup.wLength, length);
arg.transfer.data = buffer;
arg.transfer.timeout = timeout;
usbLogSetupPacket(&arg.setup);
if (direction == UsbControlDirection_Output) {
if (length) logBytes(LOG_CATEGORY(USB_IO), "control output", buffer, length);
}
{
int count = ioctl(devx->usbfsFile, USBDEVFS_CONTROL, &arg);
if (count != -1) {
if (direction == UsbControlDirection_Input) {
logBytes(LOG_CATEGORY(USB_IO), "control input", buffer, length);
}
return count;
}
logSystemError("USB control transfer");
}
}
return -1;
}
int binaryLogLuminosity(const unsigned char sensorId, luminosity_t & data)
{
init_data_struct(luminosity_bin_t, ARDUSAT_SENSOR_TYPE_LUMINOSITY)
bin_data.luminosity = data.lux;
return logBytes((unsigned char *) &bin_data, sizeof(luminosity_bin_t));
}
int binaryLogTemperature(const unsigned char sensorId, temperature_t & data)
{
init_data_struct(temperature_bin_t, ARDUSAT_SENSOR_TYPE_TEMPERATURE)
bin_data.temp = data.t;
return logBytes((unsigned char *) &bin_data, sizeof(temperature_bin_t));
}
int binaryLogPressure(const unsigned char sensorId, pressure_t & data)
{
init_data_struct(pressure_bin_t, ARDUSAT_SENSOR_TYPE_PRESSURE)
bin_data.pressure = data.pressure;
return logBytes((unsigned char *) &bin_data, sizeof(pressure_bin_t));
}
static int
readBytes (unsigned char *buffer, int size, size_t *length) {
*length = 0;
while (*length < size) {
unsigned char byte;
if (!serialReadChunk(serialDevice, buffer, length, 1, 0, 100)) {
return 0;
}
byte = buffer[*length - 1];
if ((*length == 1) && (byte == ACK)) {
*length = 0;
continue;
}
if (byte == CR) {
logBytes(LOG_DEBUG, "Read", buffer, *length);
return 1;
}
}
return 0;
}
int
cpbRestore (void) {
int ok = 0;
FILE *stream = cpbOpenFile("r");
if (stream) {
size_t size = 0X1000;
char buffer[size];
size_t length = 0;
cpbClearContent();
ok = 1;
do {
size_t count = fread(&buffer[length], 1, (size - length), stream);
int done = (length += count) < size;
if (ferror(stream)) {
logSystemError("fread");
ok = 0;
} else {
const char *next = buffer;
size_t left = length;
while (left > 0) {
const char *start = next;
wint_t wi = convertUtf8ToWchar(&next, &left);
if (wi == WEOF) {
length = next - start;
if (left > 0) {
logBytes(LOG_ERR, "invalid UTF-8 character", start, length);
ok = 0;
break;
}
memmove(buffer, start, length);
} else {
wchar_t wc = wi;
if (!cpbAddContent(&wc, 1)) {
ok = 0;
break;
}
}
}
}
if (done) break;
} while (ok);
if (fclose(stream) == EOF) {
logSystemError("fclose");
ok = 0;
}
}
return ok;
}
static int
writeBytes (BrailleDisplay *brl, const unsigned char *bytes, int count) {
logBytes(LOG_DEBUG, "Write", bytes, count);
if (serialWriteData(serialDevice, bytes, count) == -1) return 0;
brl->writeDelay += (count * 1000 / charactersPerSecond) + 1;
return 1;
}
int binaryLogUVLight(const unsigned char sensorId, uvlight_t & data)
{
init_data_struct(uv_light_bin_t, ARDUSAT_SENSOR_TYPE_UV)
bin_data.uv = data.uvindex;
return logBytes((unsigned char *) &bin_data, sizeof(uv_light_bin_t));
}
void
usbLogEndpointData (
UsbEndpoint *endpoint, const char *label,
const void *data, size_t size
) {
logBytes(LOG_CATEGORY(USB_IO), "endpoint %02X %s", data, size,
endpoint->descriptor->bEndpointAddress, label);
}
ssize_t
gioReadData (GioEndpoint *endpoint, void *buffer, size_t size, int wait) {
ReadDataMethod *method = endpoint->methods->readData;
if (!method) return logUnsupportedOperation("readData");
{
unsigned char *start = buffer;
unsigned char *next = start;
while (size) {
{
unsigned int count = endpoint->input.to - endpoint->input.from;
if (count) {
if (count > size) count = size;
memcpy(next, &endpoint->input.buffer[endpoint->input.from], count);
endpoint->input.from += count;
next += count;
size -= count;
continue;
}
endpoint->input.from = endpoint->input.to = 0;
}
if (endpoint->input.error) {
if (next != start) break;
errno = endpoint->input.error;
endpoint->input.error = 0;
return -1;
}
{
ssize_t result = method(&endpoint->handle,
&endpoint->input.buffer[endpoint->input.to],
sizeof(endpoint->input.buffer) - endpoint->input.to,
(wait? endpoint->options.inputTimeout: 0), 0);
if (result > 0) {
if (LOG_CATEGORY_FLAG(GENERIC_INPUT)) {
logBytes(categoryLogLevel, "generic input", &endpoint->input.buffer[endpoint->input.to], result);
}
endpoint->input.to += result;
wait = 1;
} else {
if (!result) break;
if (errno == EAGAIN) break;
endpoint->input.error = errno;
}
}
}
if (next == start) errno = EAGAIN;
return next - start;
}
}
int binaryLogMagnetic(const unsigned char sensorId, magnetic_t & data)
{
init_data_struct(magnetic_bin_t, ARDUSAT_SENSOR_TYPE_MAGNETIC)
bin_data.x = data.x;
bin_data.y = data.y;
bin_data.z = data.z;
return logBytes((unsigned char *) &bin_data, sizeof(magnetic_bin_t));
}
int binaryLogAcceleration(const unsigned char sensorId, acceleration_t & data)
{
init_data_struct(acceleration_bin_t, ARDUSAT_SENSOR_TYPE_ACCELERATION)
bin_data.x = data.x;
bin_data.y = data.y;
bin_data.z = data.z;
return logBytes((unsigned char *) &bin_data, sizeof(acceleration_bin_t));
}
int binaryLogGyro(const unsigned char sensorId, gyro_t & data)
{
init_data_struct(gyro_bin_t, ARDUSAT_SENSOR_TYPE_GYRO)
bin_data.x = data.x;
bin_data.y = data.y;
bin_data.z = data.z;
return logBytes((unsigned char *) &bin_data, sizeof(gyro_bin_t));
}
int binaryLogOrientation(const unsigned char sensorId, orientation_t & data)
{
init_data_struct(orientation_bin_t, ARDUSAT_SENSOR_TYPE_ORIENTATION)
bin_data.roll = data.roll;
bin_data.pitch = data.pitch;
bin_data.heading = data.heading;
return logBytes((unsigned char *) &bin_data, sizeof(orientation_bin_t));
}
int _log_binary_time_header(DateTime & now, unsigned long curr_millis)
{
unsigned char buf[10];
unsigned long unixtime = now.unixtime();
buf[0] = 0xFF;
buf[1] = 0xFF;
memcpy(buf + 2, &unixtime, 4);
memcpy(buf + 6, &curr_millis, 4);
return logBytes(buf, 10);
}
int
touchAnalyzePressure (BrailleDisplay *brl, const unsigned char *pressure) {
if (pressure) {
logBytes(LOG_DEBUG, "Touch Pressure", pressure, brl->textColumns*brl->textRows);
} else {
logMessage(LOG_DEBUG, "Touch Pressure off");
}
touchRecropWindow(brl, pressure);
brl->highlightWindow = 1;
return EOF;
}
static int
sendData (unsigned char line, unsigned char column, unsigned char count) {
unsigned char data[5 + count];
unsigned char *target = data;
unsigned char *source = &targetImage[line][column];
*target++ = 0XFF;
*target++ = line + 1;
*target++ = (line == cursorRow)? cursorColumn+1: 0;
*target++ = column + 1;
*target++ = count;
logBytes(LOG_DEBUG, "Output dots", source, count);
target = translateOutputCells(target, source, count);
count = target - data;
logBytes(LOG_DEBUG, "LogText write", data, count);
if (checkData(data, count)) {
if (sendBytes(data, count)) {
return 1;
}
}
return 0;
}
ssize_t
usbControlTransfer (
UsbDevice *device,
uint8_t direction,
uint8_t recipient,
uint8_t type,
uint8_t request,
uint16_t value,
uint16_t index,
void *buffer,
uint16_t length,
int timeout
) {
UsbDeviceExtension *devx = device->extension;
UsbSetupPacket setup;
int result;
usbMakeSetupPacket(&setup, direction, recipient, type, request, value, index, length);
if (direction == UsbControlDirection_Output) {
if (length) logBytes(LOG_CATEGORY(USB_IO), "control output", buffer, length);
}
result = usb_control_msg(devx->handle, setup.bRequestType, setup.bRequest,
getLittleEndian16(setup.wValue),
getLittleEndian16(setup.wIndex), buffer,
getLittleEndian16(setup.wLength), timeout);
if (result >= 0) {
if (direction == UsbControlDirection_Input) {
logBytes(LOG_CATEGORY(USB_IO), "control input", buffer, result);
}
return result;
}
errno = -result;
logSystemError("USB control transfer");
return -1;
}
static int
insertKey_ScreenScreen (ScreenKey key) {
char *sequence;
char buffer[0X10];
setScreenKeyModifiers(&key, 0);
wchar_t character = key & SCR_KEY_CHAR_MASK;
if (isSpecialKey(key)) {
const unsigned char flags = getAuxiliaryData()[1];
#define KEY(key,string) case (key): sequence = (string); break
#define CURSOR_KEY(key,string1,string2) KEY((key), ((flags & 0X01)? (string1): (string2)))
switch (character) {
KEY(SCR_KEY_ENTER, "\r");
KEY(SCR_KEY_TAB, "\t");
KEY(SCR_KEY_BACKSPACE, "\x7f");
KEY(SCR_KEY_ESCAPE, "\x1b");
CURSOR_KEY(SCR_KEY_CURSOR_LEFT , "\x1bOD", "\x1b[D");
CURSOR_KEY(SCR_KEY_CURSOR_RIGHT, "\x1bOC", "\x1b[C");
CURSOR_KEY(SCR_KEY_CURSOR_UP , "\x1bOA", "\x1b[A");
CURSOR_KEY(SCR_KEY_CURSOR_DOWN , "\x1bOB", "\x1b[B");
KEY(SCR_KEY_PAGE_UP, "\x1b[5~");
KEY(SCR_KEY_PAGE_DOWN, "\x1b[6~");
KEY(SCR_KEY_HOME, "\x1b[1~");
KEY(SCR_KEY_END, "\x1b[4~");
KEY(SCR_KEY_INSERT, "\x1b[2~");
KEY(SCR_KEY_DELETE, "\x1b[3~");
KEY(SCR_KEY_FUNCTION+0, "\x1bOP");
KEY(SCR_KEY_FUNCTION+1, "\x1bOQ");
KEY(SCR_KEY_FUNCTION+2, "\x1bOR");
KEY(SCR_KEY_FUNCTION+3, "\x1bOS");
KEY(SCR_KEY_FUNCTION+4, "\x1b[15~");
KEY(SCR_KEY_FUNCTION+5, "\x1b[17~");
KEY(SCR_KEY_FUNCTION+6, "\x1b[18~");
KEY(SCR_KEY_FUNCTION+7, "\x1b[19~");
KEY(SCR_KEY_FUNCTION+8, "\x1b[20~");
KEY(SCR_KEY_FUNCTION+9, "\x1b[21~");
KEY(SCR_KEY_FUNCTION+10, "\x1b[23~");
KEY(SCR_KEY_FUNCTION+11, "\x1b[24~");
KEY(SCR_KEY_FUNCTION+12, "\x1b[25~");
KEY(SCR_KEY_FUNCTION+13, "\x1b[26~");
KEY(SCR_KEY_FUNCTION+14, "\x1b[28~");
KEY(SCR_KEY_FUNCTION+15, "\x1b[29~");
KEY(SCR_KEY_FUNCTION+16, "\x1b[31~");
KEY(SCR_KEY_FUNCTION+17, "\x1b[32~");
KEY(SCR_KEY_FUNCTION+18, "\x1b[33~");
KEY(SCR_KEY_FUNCTION+19, "\x1b[34~");
default:
logMessage(LOG_WARNING, "unsuported key: %04X", key);
return 0;
}
#undef CURSOR_KEY
#undef KEY
} else {
int byte = convertWcharToChar(character);
if (byte == EOF) {
logMessage(LOG_WARNING, "character not supported in local character set: 0X%04X", key);
return 0;
}
STR_BEGIN(buffer, sizeof(buffer));
if (key & SCR_KEY_ALT_LEFT) STR_PRINTF("%c", ESC);
STR_PRINTF("\\%03o", byte);
STR_END;
sequence = buffer;
}
logBytes(LOG_CATEGORY(SCREEN_DRIVER), "insert bytes", sequence, strlen(sequence));
return doScreenCommand("stuff", sequence, NULL);
}
void
logInputProblem (const char *problem, const unsigned char *bytes, size_t count) {
logBytes(LOG_WARNING, "%s", bytes, count, problem);
}
void
logInputPacket (const void *packet, size_t size) {
logBytes(LOG_CATEGORY(INPUT_PACKETS), NULL, packet, size);
}
void
logOutputPacket (const void *packet, size_t size) {
logBytes(LOG_CATEGORY(OUTPUT_PACKETS), "sent", packet, size);
}
static void
logPacket (const char *description, const void *packet, size_t size) {
logBytes(categoryLogLevel, description, packet, size);
}
/**
* Helper function to log null-terminated output buffer string to file.
*
* @param output_buf pointer to output buffer to log.
*
* @return number of bytes written
*/
int logString(const char *output_buf)
{
int buf_len = strlen(output_buf);
return logBytes((const unsigned char *)output_buf, buf_len);
}
