// slugbee.cc
// This file is part of SlugBee; see http://chezphil.org/slugbee
// (C) 2006 Philip Endecott

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

// Utility to communicate with SlugBee peripherals.

#include <assert.h>
#include <iostream>
#include <unistd.h>

#include <boost/lexical_cast.hpp>

#include "SerialPort.hh"
#include "Exception.hh"

#include "SippPacket.hh"

using namespace std;
using namespace pbe;


void cmd_reply(SerialPort& port, SippPacket pkt)
{
  cout << "Sending packet: " << pkt << "\n";
  pkt.send(port);

  bool readable = port.wait_until_readable_or_timeout(2);
  if (readable) {
    SippPacket resp;
    resp.rcv(port);
    cout << "Got packet: " << resp << "\n";
  } else {
    cout << "No reply\n";
  }
}


void ping(SerialPort& port, int destination)
{
  while (1) {
    SippPacket ping;
    ping.source_id=1;
    ping.destination_id=destination;
    ping.command=0xA0;
    cmd_reply(port,ping);

    sleep(1);
  }
}


void measureenergy(SerialPort& port, int destination)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xA5;
  cmd_reply(port,pkt);
}


void setupadc(SerialPort& port, int destination, int channel, int state)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xAD;
  pkt.data.push_back(channel);
  pkt.data.push_back(state);
  cmd_reply(port,pkt);
}


void readadc(SerialPort& port, int destination, int channel)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xAE;
  pkt.data.push_back(channel);
  cmd_reply(port,pkt);
}


void setiopindir(SerialPort& port, int destination, int pin, int dir)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xAB;
  pkt.data.push_back(pin);
  pkt.data.push_back(dir);
  cmd_reply(port,pkt);
}


void readiopin(SerialPort& port, int destination, int pin)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xAA;
  pkt.data.push_back(pin);
  cmd_reply(port,pkt);
}


void writeiopin(SerialPort& port, int destination, int pin, int val)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xAC;
  pkt.data.push_back(pin);
  pkt.data.push_back(val);
  cmd_reply(port,pkt);
}


void readeeprom(SerialPort& port, int destination, int addr)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xA8;
  pkt.data.push_back(addr);
  cmd_reply(port,pkt);
}


void writeeeprom(SerialPort& port, int destination, int addr, int data)
{
  SippPacket pkt;
  pkt.source_id=1;
  pkt.destination_id=destination;
  pkt.command=0xA9;
  pkt.data.push_back(addr);
  pkt.data.push_back(data);
  cmd_reply(port,pkt);
}


void flash(void)
{
}


void usage(void)
{
  cout << "Usage: slugbee <port> <destination> <command> [args...]\n"
       << "  commands are:  ping\n"
       << "                 measureenergy\n"
       << "                 setupadc <channel> <state>\n"
       << "                 readadc  <channel>\n"
       << "                 setiopindir <pin> <1=out, 0=in>\n"
       << "                 readiopin <pin>\n"
       << "                 writeiopin <pin> <val>\n"
       << "                 readeeprom <addr>\n"
       << "                 writeeeprom <addr> <data>\n";
}


int main(int argc, char* argv[])
{
  try { try {
    if (argc<3) {
      usage();
      exit(1);
    }

    string port_fn = argv[1];
    SerialPort port(port_fn, FileDescriptor::read_write);
    port.set_serial_mode(9600);

    int destination = boost::lexical_cast<int>(argv[2]);

    string cmd = argv[3];
    if (cmd=="ping") {
      if (argc!=4) {
        usage();
        exit(1);
      }
      ping(port,destination);

    } else if (cmd=="measureenergy") {
      if (argc!=4) {
        usage();
        exit(1);
      }
      measureenergy(port,destination);

    } else if (cmd=="setupadc") {
      if (argc!=6) {
        usage();
        exit(1);
      }
      int channel     = boost::lexical_cast<int>(argv[4]);
      int state       = boost::lexical_cast<int>(argv[5]);
      setupadc(port,destination,channel,state);

    } else if (cmd=="readadc") {
      if (argc!=5) {
        usage();
        exit(1);
      }
      int channel = boost::lexical_cast<int>(argv[4]);
      readadc(port,destination,channel);

    } else if (cmd=="setiopindir") {
      if (argc!=6) {
        usage();
        exit(1);
      }
      int pin = boost::lexical_cast<int>(argv[4]);
      int dir = boost::lexical_cast<int>(argv[5]);
      setiopindir(port,destination,pin,dir);

    } else if (cmd=="readiopin") {
      if (argc!=5) {
        usage();
        exit(1);
      }
      int pin = boost::lexical_cast<int>(argv[4]);
      readadc(port,destination,pin);

    } else if (cmd=="writeiopin") {
      if (argc!=6) {
        usage();
        exit(1);
      }
      int pin = boost::lexical_cast<int>(argv[4]);
      int val = boost::lexical_cast<int>(argv[5]);
      writeiopin(port,destination,pin,val);

    } else if (cmd=="readeeprom") {
      if (argc!=5) {
        usage();
        exit(1);
      }
      int addr = boost::lexical_cast<int>(argv[4]);
      readeeprom(port,destination,addr);

    } else if (cmd=="writeeeprom") {
      if (argc!=6) {
        usage();
        exit(1);
      }
      int addr = boost::lexical_cast<int>(argv[4]);
      int data = boost::lexical_cast<int>(argv[5]);
      writeeeprom(port,destination,addr,data);

    } else {
      usage();
      exit(1);
    }

    exit(0);
  } RETHROW_MISC_EXCEPTIONS }
  catch (Exception& E) {
    E.report(cerr);
  }
}