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); }