Example #1
0
/*----------------------------------------------------------------------------*/
static size_t interfaceWrite(void *object, const void *buffer, size_t length)
{
  struct InterfaceWrapper * const interface = object;

  pinSet(interface->tx);
  return ifWrite(interface->pipe, buffer, length);
}
Example #2
0
bool RTIMUHal::HALWrite(unsigned char slaveAddr, unsigned char regAddr,
                   unsigned char length, unsigned char const *data, const char *errorMsg)
{
    int result;
    unsigned char txBuff[MAX_WRITE_LEN + 1];
    char *ifType;

    if (m_busIsI2C) {
        if (!I2CSelectSlave(slaveAddr, errorMsg))
            return false;
        ifType = (char *)"I2C";
    } else {
        ifType = (char *)"SPI";
    }

    if (length == 0) {
        result = ifWrite(&regAddr, 1);

        if (result < 0) {
            if (strlen(errorMsg) > 0)
                HAL_ERROR2("%s write of regAddr failed - %s\n", ifType, errorMsg);
            return false;
        } else if (result != 1) {
            if (strlen(errorMsg) > 0)
                HAL_ERROR2("%s write of regAddr failed (nothing written) - %s\n", ifType, errorMsg);
            return false;
        }
    } else {
        txBuff[0] = regAddr;
        memcpy(txBuff + 1, data, length);

        result = ifWrite(txBuff, length + 1);

        if (result < 0) {
            if (strlen(errorMsg) > 0)
                HAL_ERROR3("%s data write of %d bytes failed - %s\n", ifType, length, errorMsg);
            return false;
        } else if (result < (int)length) {
            if (strlen(errorMsg) > 0)
                HAL_ERROR4("%s data write of %d bytes failed, only %d written - %s\n", ifType, length, result, errorMsg);
            return false;
        }
    }
    return true;
}
Example #3
0
/*----------------------------------------------------------------------------*/
int main(void)
{
  static const char separator[] = "-----------------------\r\n";

  struct Interface * const ow = init(OneWireSsp, &owConfig);
  assert(ow);

  struct Interface * const serial = init(Serial, &serialConfig);
  assert(serial);

  struct Timer * const timer = init(GpTimer, &timerConfig);
  assert(timer);
  timerSetOverflow(timer, 2000);

  bool busEvent = false;
  ifSetCallback(ow, onBusEvent, &busEvent);

  bool timerEvent = false;
  timerSetCallback(timer, onTimerOverflow, &timerEvent);
  timerEnable(timer);

  while (1)
  {
    while (!timerEvent)
      barrier();
    timerEvent = false;

    enum Result res;

    res = ifSetParam(ow, IF_ONE_WIRE_START_SEARCH, 0);
    assert(res == E_OK);

    do
    {
      while (!busEvent)
        barrier();
      busEvent = false;

      res = ifGetParam(ow, IF_STATUS, 0);
      if (res != E_OK)
        break;

      uint64_t address;

      res = ifGetParam(ow, IF_ADDRESS, &address);
      assert(res == E_OK);

      printAddress(serial, address);
    }
    while (ifSetParam(ow, IF_ONE_WIRE_FIND_NEXT, 0) == E_OK);

    ifWrite(serial, separator, sizeof(separator) - 1);
  }

  return 0;
}
Example #4
0
/*----------------------------------------------------------------------------*/
static void deviceWrite(struct DeviceDriver *device)
{
  deviceConfigIO(device, false);

  device->change = !device->change;
  memcpy(device->buffer, &device->localAddress, MEMORY_ADDRESS_SIZE);
  for (size_t i = 0; i < sizeof(device->buffer) - MEMORY_ADDRESS_SIZE; ++i)
    device->buffer[i + MEMORY_ADDRESS_SIZE] = device->change ? ~i : i;

  pinSet(device->led);
  device->state = DEVICE_PH2_DATA;

#ifdef TEST_ZEROCOPY
  ifWrite(device->interface, device->buffer, sizeof(device->buffer));
#else
  const size_t bytesWritten = ifWrite(device->interface,
      device->buffer, sizeof(device->buffer));

  if (bytesWritten == sizeof(device->buffer))
    pinReset(device->led);
#endif
}
Example #5
0
/*----------------------------------------------------------------------------*/
static enum Result program(struct Interface *flash, const uint8_t *buffer,
    size_t length, size_t address)
{
  enum Result res;

  if ((res = ifSetParam(flash, IF_POSITION, &address)) != E_OK)
    return res;

  if (ifWrite(flash, buffer, length) != length)
    return E_INTERFACE;

  return E_OK;
}
Example #6
0
/*----------------------------------------------------------------------------*/
static void deviceRead(struct DeviceDriver *device)
{
  deviceConfigIO(device, true);

  pinSet(device->led);
  device->state = DEVICE_PH1_ADDRESS;

#ifdef TEST_ZEROCOPY
  ifWrite(device->interface, &device->localAddress, MEMORY_ADDRESS_SIZE);
#else
  const size_t bytesWritten = ifWrite(device->interface,
      &device->localAddress, MEMORY_ADDRESS_SIZE);

  if (bytesWritten == MEMORY_ADDRESS_SIZE)
  {
    const size_t bytesRead = ifRead(device->interface, device->buffer,
        sizeof(device->buffer) - MEMORY_ADDRESS_SIZE);

    if (bytesRead == sizeof(device->buffer) - MEMORY_ADDRESS_SIZE)
      pinReset(device->led);
  }
#endif
}
Example #7
0
/*----------------------------------------------------------------------------*/
void usbTrace(const char *format, ...)
{
  if (!traceInterface)
    return;

  va_list arguments;
  int length;

  va_start(arguments, format);
  length = vsnprintf(traceBuffer, CONFIG_TRACE_BUFFER_SIZE - 2,
      format, arguments);
  va_end(arguments);

  memcpy(traceBuffer + length, "\r\n", 2);

  ifWrite(traceInterface, traceBuffer, (size_t)(length + 2));
}
Example #8
0
/*----------------------------------------------------------------------------*/
static void printAddress(struct Interface *serial, uint64_t address)
{
  const uint8_t * const overlay = (const uint8_t *)&address;
  uint8_t serialized[25];
  uint8_t *position = serialized;

  for (unsigned int i = 0; i < 8; ++i)
  {
    if (i > 0)
      *position++ = ' ';

    *position++ = binToHex(overlay[i] >> 4);
    *position++ = binToHex(overlay[i] & 0x0F);
  }
  *position++ = '\r';
  *position = '\n';

  ifWrite(serial, serialized, sizeof(serialized));
}