jaus++/2.0/src/jaus/extras/mcu/microcontroller.cpp

Go to the documentation of this file.

#include "jaus/extras/mcu/microcontroller.h"
#include "jaus/extras/mcu/querymicrocontrollerstate.h"
#include "jaus/extras/mcu/reportmicrocontrollerstate.h"
#include "jaus/extras/mcu/setmicrocontrollerstate.h"

using namespace JAUS;

const std::string Microcontroller::Name = "urn:jaus:jss:jpp:extras:Microcontroller";


Microcontroller::Microcontroller() : Management::Child(Service::ID(Microcontroller::Name),
                                                       Service::ID(Management::Name))
{
}


Microcontroller::~Microcontroller()
{
}


void Microcontroller::SetDigitalInput(const std::string& name, const bool value)
{
    bool signalEvent = false;
    if(name.empty())
    {
        std::cout << "JAUS::Microcontroller::SetDigitalInput - Empty String Argument Error\n";
        return;
    }
    Mutex::ScopedLock lock(&mMcuMutex);
    DigitalStates::iterator pin = mDigitalStates.find(name);
    if(pin == mDigitalStates.end() || pin->second != value)
    {
        signalEvent = true;
    }
    mDigitalStates[name] = value;
    if(signalEvent)
    {
        SignalEvent(true, name);
    }
}


void Microcontroller::SetAnalogInput(const std::string& name, const double value)
{
    if(name.empty())
    {
        std::cout << "JAUS::Microcontroller::SetAnalogInput - Empty String Argument Error\n";
        return;
    }
    if(value < -100.0 || value > 100.0)
    {
        std::cout << "JAUS::Microcontroller::SetAnalogInput - Input Value Out of Bounds\n";
        return;
    }

    bool signalEvent = false;
    Mutex::ScopedLock lock(&mMcuMutex);
    AnalogStates::iterator pin = mAnalogStates.find(name);
    if(pin == mAnalogStates.end() || pin->second != value)
    {
        signalEvent = true;
    }
    mAnalogStates[name] = value;
    if(signalEvent)
    {
        SignalEvent(false, name);
    }
}


bool Microcontroller::GetDigitalState(const std::string& name) const
{
    Mutex::ScopedLock lock(&mMcuMutex);
    DigitalStates::const_iterator digital = mDigitalStates.find(name);
    if(digital != mDigitalStates.end())
    {
        return digital->second;
    }
    return false;
}


double Microcontroller::GetAnalogState(const std::string& name) const
{
    Mutex::ScopedLock lock(&mMcuMutex);
    AnalogStates::const_iterator analog = mAnalogStates.find(name);
    if(analog != mAnalogStates.end())
    {
        return analog->second;
    }
    return 0.0;
}


bool Microcontroller::GenerateEvent(const Events::Subscription& info) const
{
    if(info.mpQueryMessage->GetMessageCode() == QUERY_MICROCONTROLLER_STATE)
    {
        const QueryMicrocontrollerState* query = dynamic_cast<const QueryMicrocontrollerState*>(info.mpQueryMessage);
        Mutex::ScopedLock lock(&mMcuMutex);

        DigitalStates::const_iterator digital;
        AnalogStates::const_iterator analog;

        ReportMicrocontrollerState report;

        if(query->GetDigitalStates()->size() == 0)
        {
            *report.GetDigitalStates() = mDigitalStates;
        }
        else
        {
            std::set<std::string>::const_iterator name;
            for(name = query->GetDigitalStates()->begin();
                name != query->GetDigitalStates()->end();
                name++)
            {
                digital = mDigitalStates.find(*name);
                if(digital != mDigitalStates.end())
                {
                    (*report.GetAnalogStates())[*name] = digital->second;
                }
            }
        }

        if(query->GetAnalogStates()->size() == 0)
        {
            *report.GetAnalogStates() = mAnalogStates;
        }
        else
        {
            std::set<std::string>::const_iterator name;
            for(name = query->GetAnalogStates()->begin();
                name != query->GetAnalogStates()->end();
                name++)
            {
                analog = mAnalogStates.find(*name);
                if(analog!= mAnalogStates.end())
                {
                    (*report.GetAnalogStates())[*name] = analog->second;
                }
            }
        }

        SendEvent(info, &report);
        return true;
    }

    return false;
}


bool Microcontroller::IsEventSupported(const Events::Type type,
                                       const double requestedPeriodicRate,
                                       const Message* queryMessage,
                                       double& confirmedPeriodicRate,
                                       std::string& errorMessage) const
{
    if(queryMessage->GetMessageCode() == QUERY_MICROCONTROLLER_STATE)
    {
        const QueryMicrocontrollerState* query = dynamic_cast<const QueryMicrocontrollerState*>(queryMessage);
        Mutex::ScopedLock lock(&mMcuMutex);

        DigitalStates::const_iterator digital;
        AnalogStates::const_iterator analog;

        ReportMicrocontrollerState report;

        if(query->GetDigitalStates()->size() != 0)
        {
            std::set<std::string>::const_iterator name;
            for(name = query->GetDigitalStates()->begin();
                name != query->GetDigitalStates()->end();
                name++)
            {
                digital = mDigitalStates.find(*name);
                if(digital == mDigitalStates.end())
                {
                    errorMessage = "Digital Device Not Supported."; return false;
                }
            }
        }

        if(query->GetAnalogStates()->size() != 0)
        {
            std::set<std::string>::const_iterator name;
            for(name = query->GetAnalogStates()->begin();
                name != query->GetAnalogStates()->end();
                name++)
            {
                analog = mAnalogStates.find(*name);
                if(analog == mAnalogStates.end())
                {
                    errorMessage = "Analog Device Not Supported."; return false;
                }
            }
        }

        confirmedPeriodicRate = requestedPeriodicRate;

        return true;
    }

    return false;
}


Message* Microcontroller::CreateMessage(const UShort messageCode) const
{
    Message* message;
    switch(messageCode)
    {
    case QUERY_MICROCONTROLLER_STATE:
        message = new QueryMicrocontrollerState();
        break;
    case REPORT_MICROCONTROLLER_STATE:
        message = new ReportMicrocontrollerState();
        break;
    case SET_MICROCONTROLLER_STATE:
        message = new SetMicrocontrollerState();
        break;
    default:
        message = NULL;
        break;
    }
    return message;
}


void Microcontroller::Receive(const Message* message)
{
    switch(message->GetMessageCode())
    {
    case QUERY_MICROCONTROLLER_STATE:
        {
            const QueryMicrocontrollerState* query = dynamic_cast<const QueryMicrocontrollerState*>(message);
            if(query)
            {
                Mutex::ScopedLock lock(&mMcuMutex);

                DigitalStates::const_iterator digital;
                AnalogStates::const_iterator analog;

                ReportMicrocontrollerState report(message->GetSourceID(), GetComponentID());

                if(query->GetDigitalStates()->size() == 0)
                {
                    *report.GetDigitalStates() = mDigitalStates;
                }
                else
                {
                    std::set<std::string>::const_iterator name;
                    for(name = query->GetDigitalStates()->begin();
                        name != query->GetDigitalStates()->end();
                        name++)
                    {
                        digital = mDigitalStates.find(*name);
                        if(digital != mDigitalStates.end())
                        {
                            (*report.GetAnalogStates())[*name] = digital->second;
                        }
                    }
                }

                if(query->GetAnalogStates()->size() == 0)
                {
                    *report.GetAnalogStates() = mAnalogStates;
                }
                else
                {
                    std::set<std::string>::const_iterator name;
                    for(name = query->GetAnalogStates()->begin();
                        name != query->GetAnalogStates()->end();
                        name++)
                    {
                        analog = mAnalogStates.find(*name);
                        if(analog!= mAnalogStates.end())
                        {
                            (*report.GetAnalogStates())[*name] = analog->second;
                        }
                    }
                }
                Send(&report);
            }
        }
        break;
    case SET_MICROCONTROLLER_STATE:
        {
            const SetMicrocontrollerState* command = dynamic_cast<const SetMicrocontrollerState*>(message);
            if(command)
            {
                DigitalStates::const_iterator digital;
                AnalogStates::const_iterator analog;

                for(digital = command->GetDigitalStates()->begin();
                    digital != command->GetDigitalStates()->end();
                    digital++)
                {
                    SetDigitalOut(digital->first,
                                  digital->second);
                    Mutex::ScopedLock lock(&mMcuMutex);
                    mDigitalStates[digital->first] = digital->second;
                    SignalEvent(true,
                                digital->first);
                }

                for(analog = command->GetAnalogStates()->begin();
                    analog != command->GetAnalogStates()->end();
                    analog++)
                {
                    SetAnalogOut(analog->first,
                                 analog->second);
                    Mutex::ScopedLock lock(&mMcuMutex);
                    mAnalogStates[analog->first] = analog->second;
                    SignalEvent(false,
                                analog->first);
                }
            }
        }
        break;
    case REPORT_MICROCONTROLLER_STATE:
        {
            const ReportMicrocontrollerState* report = dynamic_cast<const ReportMicrocontrollerState*>(message);
            if(report && report->GetSourceID() == GetSynchronizeID())
            {
                Mutex::ScopedLock lock(&mMcuMutex);
                mDigitalStates = *report->GetDigitalStates();
                mAnalogStates = *report->GetAnalogStates();
                Events::Child::SignalEvent(REPORT_MICROCONTROLLER_STATE);
            }
        }
        break;
    default:
        break;
    }
}


void Microcontroller::PrintStatus() const
{
    //Mutex::ScopedLock lock(&mMcuMutex);
    if(GetSynchronizeID().IsValid())
    {
        std::cout << "[" << GetServiceID().ToString() << "] - Synchronized to [" << GetSynchronizeID().ToString() << "]:\n";
    }
    else
    {
        std::cout << "[" << GetServiceID().ToString() << "] - Current Pin States:\n";
    }
    mMcuMutex.Lock();
    DigitalStates digitalStates = mDigitalStates;
    AnalogStates analogStates = mAnalogStates;
    mMcuMutex.Unlock();

    DigitalStates::const_iterator digital;
    for(digital = digitalStates.begin();
        digital != digitalStates.end();
        digital++)
    {
        std::cout << "Digital - " << digital->first << " - " << (int)digital->second << std::endl;
    }
    AnalogStates::const_iterator analog;
    for(analog = analogStates.begin();
        analog != analogStates.end();
        analog++)
    {
        std::cout << "Analog - " << analog->first << " - " << analog->second << std::endl;
    }
}


void Microcontroller::CheckServiceSynchronization(const unsigned int timeSinceLastCheckMs)
{
    Address syncID = GetSynchronizeID();
    if(syncID.IsValid())
    {
        // See if we have an active subscription
        if(EventsService()->HaveSubscription(REPORT_MICROCONTROLLER_STATE, syncID) == false)
        {
            QueryMicrocontrollerState query;
            EventsService()->RequestEveryChangeEvent(syncID, &query);
        }
    }
}



void Microcontroller::SignalEvent(const bool digital,
                                  const std::string& name)
{
    // Normally we could use the generic SignalEvent method, however
    // we only want to signal events for a change to this specific
    // data.  That way we don't generate an event for all data when
    // only 1 has updated.
    Events::Subscription::List myEvents = GetComponent()->EventsService()->GetProducedEvents(REPORT_IMAGE);
    Events::Subscription::List::iterator e;
    for(e = myEvents.begin();
        e != myEvents.end();
        e++)
    {
        const QueryMicrocontrollerState* query = dynamic_cast<const QueryMicrocontrollerState*>(e->mpQueryMessage);
        if(query)
        {
            if(digital)
            {
                if(query->GetDigitalStates()->size() == 0 || query->GetDigitalStates()->find(name) != query->GetDigitalStates()->end())
                {
                    Events::Child::SignalEvent((*e));
                }
            }
            else
            {
                if(query->GetAnalogStates()->size() == 0 || query->GetAnalogStates()->find(name) != query->GetAnalogStates()->end())
                {
                    Events::Child::SignalEvent((*e));
                }
            }
        }
    }
}

/*  End of File */