---

sgnlman.cpp

Go to the documentation of this file.

// $Id$

//**********************************************************************
//                                                                     *
//    Description:   'Bell Master' Signalman class.                    *
//                                                                     *
//    Author:        Chris White (whitecf@bcs.org.uk)                  *
//                                                                     *
//    Copyright (C) 2003  Monitor Computing Services Ltd.              *
//                                                                     *
//    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 (http://www.gnu.org/copyleft/gpl.html) along with this   *
//    program; if not, write to:                                       *
//       The Free Software Foundation Inc.,                            *
//       59 Temple Place - Suite 330,                                  *
//       Boston, MA  02111-1307,                                       *
//       USA.                                                          *
//                                                                     *
//**********************************************************************
//                                                                     *
//    Notes:                                                           *
//                                                                     *
//**********************************************************************

#include <mem.h>

#include <bell.h>
#include <callback.h>
#include <mytrace.h>
#include "tapper.h"
#include <timeout.h>
#include <timer.h>

#include "sgnlman.h"



using namespace Monitor::BellMaster;
namespace Ut = Monitor::Utility;



Signalman::Signalman(const string&     newName,
                     const unsigned    newBeatInterval,
                     const unsigned    newSetInterval) :
    name(newName), beatInterval(newBeatInterval), setInterval(newSetInterval),
    ringTimer(0), ringTimeout(0)
{
    _USEMYTRACE_("Signalman::Signalman"
                 "(newName, newBeatInterval, newSetInterval)")
}



Signalman::~Signalman()
{
    _USEMYTRACE_("Signalman::~Signalman()")


    // Destruction shouldn't happen whilst listening to a bell but just in case
    // make sure things are tidied up.
    delete ringTimer, ringTimer = 0;
    delete ringTimeout, ringTimeout = 0;
}



Signalman&
Signalman::operator=(const Signalman&    other)
{
    name         = other.name;
    beatInterval = other.beatInterval;
    setInterval  = other.setInterval;

    return *this;
}



int
Signalman::operator==(const Signalman&    other) const
{
    return ((name         == other.name) &&
            (beatInterval == other.beatInterval) &&
            (setInterval  == other.setInterval));
}



int
Signalman::operator<(const Signalman&    other) const
{
    return name < other.name;
}



void
Signalman::beatSequence(Tapper&    tapper, const string&    sequence) const
{
    _USEMYTRACE_("Signalman::beatSequence(tapper, sequence[])")


    // Count the total number of beats in the sequence
    const unsigned char*
        currentSet = (const unsigned char*)sequence.c_str();
    unsigned
        numberOfBeats = 0;


    while (0 < *currentSet)
    {
        numberOfBeats += *currentSet;
        ++currentSet;
    }

    // Create a nul terminated array of beat interval times
    unsigned    *beatIntervals   = new unsigned[numberOfBeats + 1];
    unsigned    *currentInterval = beatIntervals;

    currentSet = (const unsigned char*)sequence.c_str();

    while (0 < *currentSet)
    {
        char    currentBeats = *currentSet;

        while (1 < currentBeats)
        {
            // Time till next beat = beat interval
            *currentInterval = beatInterval;

            ++currentInterval;
            --currentBeats;
        }

        // End of a set of beats, time till next beat = set interval
        *currentInterval = setInterval;

        ++currentInterval;
        ++currentSet;
    }

    // End of sequence, replace last time till next beat with terminating nul
    --currentInterval;
    *currentInterval = 0;

    tapper.beat(beatIntervals);
}



unsigned
Signalman::getBeatInterval() const
{
    _USEMYTRACE_("Signalman::getBeatInterval()")


    return beatInterval;
}



void
Signalman::setBeatInterval(const unsigned    newInterval)
{
    _USEMYTRACE_("Signalman::setBeatInterval(newInterval)")


    beatInterval = newInterval;
}



unsigned
Signalman::getSetInterval() const
{
    _USEMYTRACE_("Signalman::getSetInterval")


    return setInterval;
}



void
Signalman::setSetInterval(const unsigned    newInterval)
{
    _USEMYTRACE_("Signalman::setSetInterval(newInterval)()")


    setInterval = newInterval;
}



int
Signalman::isBusy()
{
    _USEMYTRACE_("Signalman::isBusy")


    return ((0 != ringTimer) || (0 != ringTimeout));
}



void
Signalman::listenToBell(Bell&                      newBell,
                        const Ut::CallbackBase&    timeoutCallback)
{
    _USEMYTRACE_("Signalman::listenToBell(newBell, timeoutCallback)")


    if (!isBusy())
    {
        ringTimer = new Ut::Timer();

        ringTimeout = new Ut::Timeout(timeoutCallback,
                                      1500,
                                      "ring timeout");

        newBell.addListener(Ut::Callback< Signalman >(*this,
                                                      &Signalman::hearBell));


        for (int index = 0; 64 > index; ++index)
        {
            heardIntervals[index] = 0;
        }
    }
}



void
Signalman::hearBell()
{
    _USEMYTRACE_("Signalman::hearBell()")


    if ((0 != ringTimer) && (0 != ringTimeout))
    {
        ringTimeout->reset(1500);

        for (int index = 0; 64 > index; ++index)
        {
            if (0 == heardIntervals[index])
            {
                heardIntervals[index]     = ringTimer->restart();
                heardIntervals[index + 1] = 0;
                break;
            }
        }
    }
}



const string
Signalman::stopListeningToBell()
{
    _USEMYTRACE_("Signalman::stopListeningToBell()")


    string    heardSequence('\0');


    ringTimeout = 0;

    // Check the signalman is listening to a bell, there will be a ring timer
    if (0 != ringTimer)
    {
        // Destroy the ring interval timer
        delete ringTimer, ringTimer = 0;


        // Count the number of intervals
        int    index = 0;
        while (0 < heardIntervals[index])
        {
            ++index;
        }

        // Size the storage for the sequence of rings
        heardSequence.resize(index + 2);

        // Must have heard at least one ring to have got this far
        heardSequence[0] = 1;
        heardSequence[1] = 0;


        // Check if there was more than one ring
        if (0 < heardIntervals[0])
        {
            // First determine the longest interval in the sequence
            unsigned    maxInterval = 0;

            index = 0;
            while (0 < heardIntervals[index])
            {
                if (maxInterval < heardIntervals[index])
                {
                    maxInterval = heardIntervals[index];
                }

                ++index;
            }

            // Then determine the shortest interval in the sequence
            unsigned    minInterval = maxInterval;

            index = 0;
            while (0 < heardIntervals[index])
            {
                if (minInterval > heardIntervals[index])
                {
                    minInterval = heardIntervals[index];
                }

                ++index;
            }

            // Test if the shortest interval is less than 50% the longest
            if (!(minInterval < (maxInterval >> 1)))
            {
                // It isn't, assume all rings with no pauses
                heardSequence[0] += index;
            }
            else
            {
                // Set the ring / pause threshold to be half the longest
                // interval
                unsigned    ringThreshold = maxInterval >> 1;

                // Then count the rings grouped into sets of rings
                int    ring = 0;

                index = 0;
                while (0 < heardIntervals[index])
                {
                    if (ringThreshold < heardIntervals[index])
                    {
                        // Heard a pause, move to next set of rings
                        ++ring;
                        heardSequence[ring] = 0;
                    }

                    // Heard a ring, increment rings count for set
                    ++heardSequence[ring];

                    ++index;
                }
                
                // Ensure there's a terminating 0 rings
                heardSequence[ring + 1] = 0;
            }
        }
    }

    return heardSequence;
}

---