hdaps.cc

Go to the documentation of this file.

/*
 * HDAPS Player driver
 */

#include "hdaps.h"


static int hdaps_position(int *x, int *y);

// Driver setup and shutdown

HDAPS::HDAPS(ConfigFile* cf, int section)
    : Driver(cf, section, true, PLAYER_MSGQUEUE_DEFAULT_MAXLEN)
{
   // zero ids, so that we'll know later which interfaces were requested
   memset(&joystick_id, 0, sizeof(joystick_id));

   if (cf->ReadDeviceAddr(&joystick_id, section, "provides",
                          PLAYER_JOYSTICK_CODE, -1, NULL) == 0) {
      if (this->AddInterface(joystick_id) != 0) {
         this->SetError(-1);
         return;
      }
   }
}

int HDAPS::Setup()
{
   int xpos, ypos;

   if (hdaps_position(&xpos, &ypos)) {
      PLAYER_WARN("Failed to read HDAPS position data\n"
                  "Maybe you need to run: modprobe hdaps");
   }

   this->StartThread();
   return 0;
}

int HDAPS::Shutdown()
{
   this->StopThread();
   return 0;
}

HDAPS::~HDAPS (void)
{
}

void
HDAPS::Main()
{
   int xpos, ypos;

   for(;;) {
      pthread_testcancel();

      this->Lock();

      memset(&data, 0, sizeof(data));
      if (hdaps_position(&xpos, &ypos) == 0) {
         data.xpos = (uint32_t) xpos;
         data.ypos = (uint32_t) ypos;
      }

      this->Unlock();

      if (memcmp(&prev_data, &data, sizeof(data))) {
         PutData();
         memcpy(&prev_data, &data, sizeof(data));
      }

      // Handle pending messages
      if (!this->InQueue->Empty()) {
         ProcessMessages();
      }
   }
}


// Message processing

int
HDAPS::ProcessMessage(MessageQueue *queue, player_msghdr *hdr, void *data)
{
   PLAYER_WARN("unknown message");
   return -1;
}


// Publish / Subscribe / Unsubscribe

int
HDAPS::Subscribe(player_devaddr_t id)
{
   return Driver::Subscribe(id);
}

int
HDAPS::Unsubscribe(player_devaddr_t id)
{
   return Driver::Unsubscribe(id);
}

void
HDAPS::PutData(void)
{
   PLAYER_MSG0(1, "Publishing joystick data");
   this->Publish(joystick_id, NULL, PLAYER_MSGTYPE_DATA,
                 PLAYER_JOYSTICK_DATA_STATE,
                 (void *) &data, sizeof(data));
}


// HDAPS position handling

static int hdaps_position(int *x, int *y)
{
   char buf[BUFSIZ];
   int fd, ret;

   fd = open(SYSFS_HDAPS_POSITION, O_RDONLY);
   if (fd < 0) {
      PLAYER_ERROR1("error opening: %s", strerror(errno));
      return fd;
   }

   ret = read(fd, buf, sizeof(buf));
   if (ret > 0) {
      ret = 0;
      if (sscanf (buf, "(%d,%d)\n", x, y) != 2)
         ret = 1;

   } else if (ret < 0) {
      PLAYER_ERROR1("error reading: %s", strerror(errno));

   } else {
      PLAYER_ERROR("Failed to read position");
      ret = 1;
   }

   if (close (fd))
      PLAYER_ERROR1("error closing: %s", strerror(errno));

   return ret;
}


// Driver module registration and initializaion

Driver*
HDAPS_Init(ConfigFile* cf, int section)
{
   return (Driver*)(new HDAPS(cf, section));
}

void HDAPS_Register(DriverTable* table)
{
   table->AddDriver("hdaps", HDAPS_Init);
}

/* Need the extern to avoid C++ name-mangling  */
extern "C" {

int player_driver_init(DriverTable* table)
{
   PLAYER_MSG0(1, "Registering HDAPS driver.");
   HDAPS_Register(table);
   return 0;
}

}

---