File content as of revision 6:88cc04eb613a:

#include "AferoCommHndlr.h"

Necochan *Necochan::ref = NULL;

Necochan::Necochan()
{
    if(ref==NULL)
    {
        ref = this;
    }
    out = new DigitalOut(PTB8,1);
}

void Necochan::release()
{
    DigitalOut *p = ref->out;
    *p = 1;
}

void Necochan::push()
{
    SERIAL_PRINT_DBG("push meow\n");
    *out = 0;
    timeout.attach(&release,1);
}

static AferoCommHndlr *self = NULL;

AferoCommHndlr::AferoCommHndlr() : flowControlEnabled(false)
{
    necochan = new Necochan();
    deathWish = new Timeout();
}

void
AferoCommHndlr::kick_the_bucket()
{
    SERIAL_PRINT_DBG("bucket kicked!!\n");
    wtd.kick_the_bucket();   
}

void
AferoCommHndlr::loop()
{
    piafLib->loop();
    todoQ->loop();
}

AferoCommHndlr*
AferoCommHndlr::create(Timer *timer, mbedSPI *spi)
{
     SERIAL_PRINT_DBG("HELLO\n");
     self = new AferoCommHndlr();
     self->timer = timer;
     self->piafLib = iafLib::create((PinName)PINS::ASR_1::SPI::SR,
       AferoCommHndlr::fco_irq_fall,
       AferoCommHndlr::myOnAttributeSet,
       AferoCommHndlr::myOnAttributeSetComplete, spi);
     self->todoQ = ToDoQ::create(AferoCommHndlr::onGetTodo);
     SERIAL_PRINT_DBG("AferoCommHndlr init done\n");
     self->piafLib->setAttribute8(1,1) != afSUCCESS ? SERIAL_PRINT_DBG("set attr failed!!\n") : NULL ;
     
     return self;
}

void
AferoCommHndlr::myOnAttributeSet(
    const uint8_t requestId,
    const uint16_t attributeId,
    const uint16_t valueLen,
    const uint8_t *value)
{
    self->piafLib->setAttributeComplete(requestId, attributeId, valueLen, value) != afSUCCESS ? SERIAL_PRINT_DBG("set attr failed!!\n") : NULL ;
}

int32_t
AferoCommHndlr::sanitizeSensingInterval(uint16_t attributeId, int32_t interval)
{
    if(interval < 5)
    {
        interval = 5;
        self->piafLib->setAttribute32(attributeId, interval) != afSUCCESS ? SERIAL_PRINT_DBG("set attr failed!!\n") : NULL ;
    }
    return interval;
}

void
AferoCommHndlr::myOnAttributeSetComplete(
    const uint8_t requestId,
    const uint16_t attributeId,
    const uint16_t valueLen,
    const uint8_t *value)
{
//    uint8_t *buf = new uint8_t[valueLen+1];
//    memset(buf,'\0',valueLen+1);
//    memcpy(buf, value, valueLen);
//    SERIAL_PRINT_DBG("attr id:%d value:%s\n",attributeId,buf);
//    delete[] buf;
//    buf = NULL;
    
    //self->deathWish->attach(&AferoCommHndlr::kick_the_bucket,10);
    
    int32_t sensing_interval;
    char *buf = NULL;
    if(attributeId >= 4 && attributeId <= 8)
    {
        sensing_interval = *((int32_t*)value);
    }
    
    if(attributeId==2)
    {
        PREFERENCES::CRC32.ui32 = *((uint32_t*)value);
    }
    else if(attributeId==4)
    {
        buf = "PREFERENCES::SENSING_INTERVAL[SENSORS::ACCELEROMETER]";
        PREFERENCES::SENSING_INTERVAL[SENSORS::ACCELEROMETER] = self->sanitizeSensingInterval(attributeId,sensing_interval);
    }
    else if(attributeId==5)
    {
        buf = "PREFERENCES::SENSING_INTERVAL[SENSORS::COLOR]";
        PREFERENCES::SENSING_INTERVAL[SENSORS::COLOR] = self->sanitizeSensingInterval(attributeId,sensing_interval);
    }
    else if(attributeId==6)
    {
        buf = "PREFERENCES::SENSING_INTERVAL[SENSORS::PRESSURE]";
        PREFERENCES::SENSING_INTERVAL[SENSORS::PRESSURE] = self->sanitizeSensingInterval(attributeId,sensing_interval);
    }
    else if(attributeId==7)
    {
        buf = "PREFERENCES::SENSING_INTERVAL[SENSORS::CURRENT_TRANS]";
        PREFERENCES::SENSING_INTERVAL[SENSORS::CURRENT_TRANS] = self->sanitizeSensingInterval(attributeId,sensing_interval);
    }
    else if(attributeId==8)
    {
        buf = "PREFERENCES::SENSING_INTERVAL[SENSORS::TEMPERATURE]";
        PREFERENCES::SENSING_INTERVAL[SENSORS::TEMPERATURE] = self->sanitizeSensingInterval(attributeId,sensing_interval);
    }
    else if(attributeId==9)
    {
        SERIAL_PRINT_DBG("time stamp:%ld\n", *((uint32_t*)value));
        time_t t;
        RTC_GET_UTC(t);
        if(*((uint32_t*)value) > ((uint32_t)t))
        {
            RTC_Handler::getInstance()->setUTC(*((uint32_t*)value));
        }
    }
    else if(attributeId==1024)
    {
        self->necochan->push();
    }
    
    if(attributeId >= 4 && attributeId <= 8)
    {
        SERIAL_PRINT_DBG("%s=%ld\n",buf,sensing_interval);
    }
    
}

void
AferoCommHndlr::fco_irq_fall()
{
    if(self->piafLib)
    {
        self->piafLib->mcuISR();
    }
}

void
AferoCommHndlr::onGetTodo(ToDo *todo)
{
    char buf[255];
    memset(buf,'\0',sizeof(buf));
    if(todo!=NULL)
    {
        if(PREFERENCES::FLOW_CONTROL==true)
        {
            PREFERENCES::_crc32 crc32;
            todo->toBASE64(buf,&crc32);
            self->piafLib->setAttribute(ATTR_ID_SENSE_VAL,strlen(buf),buf) != afSUCCESS ? SERIAL_PRINT_DBG("set attr failed!!\n") : NULL ;
            self->piafLib->setAttribute64(3,crc32.ui32) != afSUCCESS ? SERIAL_PRINT_DBG("set attr failed!!\n") : NULL ;
        }
        else
        {
            todo->toJSON(buf);
            SERIAL_PRINT_DBG("%s\n",buf);
            self->piafLib->setAttribute(ATTR_ID_SENSE_VAL,strlen(buf),buf) != afSUCCESS ? SERIAL_PRINT_DBG("set attr failed!!\n") : NULL ;
        }
    }
}