aktivnilptport.cpp

pc paralel port programming

// AktivniLPTPort.cpp: implementation of the CAktivniLPTPort class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "AktivniLPTPort.h"

#include "SpisakLPTPortova.h"
#include "LPTPort.h"
#include "Win32LPT.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

const std::string CAktivniLPTPort::NEDEFINISAN = "LPT undefined";

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAktivniLPTPort::CAktivniLPTPort(bool koristiOS)
: port_m(NEDEFINISAN)
, portPtr_m(0)
, pOSport_m(0)
, koristiOSopen_m(koristiOS)
{
    RadSaPinovima(false);
}

CAktivniLPTPort::~CAktivniLPTPort()
{
    ObrisiPortOS();
}

bool CAktivniLPTPort::Otvori(std::string nazivPorta)
{
    std::string noviPort = ProveriNazivPorta(nazivPorta);
    bool otvorenPortOS = OtvoriPortOS(noviPort);

    if (!otvorenPortOS){
        port_m = NEDEFINISAN;
        portPtr_m = 0;
        return false;
    }
    else {
        port_m = noviPort;
        portPtr_m = CSpisakLPTPortova::Instance()->DajPort(port_m);
        try {
            portPtr_m->ProcitajSadrzajSvihRegistara();
        }
        catch (...) {
        }
        return true;
    }
}

bool CAktivniLPTPort::Zatvori(void)
{
    bool bOK = false;
    if (ObrisiPortOS()){
        port_m = NEDEFINISAN;
        portPtr_m = 0;
        bOK = true;
    }
    return bOK;
}

bool CAktivniLPTPort::Otvoren(void)
{
    return (port_m != NEDEFINISAN);
}

std::string CAktivniLPTPort::Naziv(void)
{
    return port_m;
}

void CAktivniLPTPort::KoristiOSopen(bool aktivan)
{
    // aktiviraj/deaktiviraj otvaranje porta preko OS-a
    koristiOSopen_m = aktivan;

    if (KoristiOSopen()) { // ako je OS aktiviran, kreiraj prateci port i otvori port
        OtvoriPortOS(port_m);
    }
    else { // ako je OS deaktiviran, obrisi i prateci objekat
        ObrisiPortOS();
    }
}

bool CAktivniLPTPort::KoristiOSopen(void)
{
    return koristiOSopen_m;
}

bool CAktivniLPTPort::RadSaPinovima(void)
{
    return (ciljBitKomande_m == LPT::PIN);
}

void CAktivniLPTPort::RadSaPinovima(bool radSaPinovima)
{
    if (radSaPinovima) {
        ciljBitKomande_m = LPT::PIN;
    }
    else {
        ciljBitKomande_m = LPT::REGISTAR;
    }
}

//////////////////////////////////////////////////////////////////////
// Funkcije koje implementiraju 'interfejs' CKontrolaLPTRegistara
//////////////////////////////////////////////////////////////////////

int CAktivniLPTPort::Postavi(int bitMaska, LPT::ECiljKomande bitPin)
{
    return PozoviBitFunkciju(&CLPTPort::Postavi, bitMaska, bitPin);
}

int CAktivniLPTPort::Obori(int bitMaska, LPT::ECiljKomande bitPin)
{
    return PozoviBitFunkciju(&CLPTPort::Obori, bitMaska, bitPin);
}

int CAktivniLPTPort::Procitaj(int bitMaska, LPT::ECiljKomande bitPin)
{
    return PozoviBitFunkciju(&CLPTPort::Procitaj, bitMaska, bitPin);
}

bool CAktivniLPTPort::Postavljen(int bitMaska, LPT::ECiljKomande bitPin)
{
    CLPTPort* LPTport = DajPortPtr();
    if (LPTport != 0){
        LPT::ECiljKomande izborBitPin = ProveriCiljKomande(bitPin);
        return (LPTport->Postavljen(bitMaska, izborBitPin));
    }
    return 0;
}

//////////////////////////////////////////////////////////////////////
// Funkcije za manipulaciju registrima.
//////////////////////////////////////////////////////////////////////

int CAktivniLPTPort::PostaviSadrzaj(const std::string& reg, int val, LPT::ECiljKomande bitPin)
{
    CLPTPort* LPTport = DajPortPtr();
    if (LPTport != 0){
        LPT::ECiljKomande izborBitPin = ProveriCiljKomande(bitPin);
        return (LPTport->PostaviSadrzaj(reg, val, izborBitPin));
    }
    return 0;
}

int CAktivniLPTPort::ProcitajSadrzaj(const std::string& reg, LPT::ECiljKomande bitPin)
{
    CLPTPort* LPTport = DajPortPtr();
    if (LPTport != 0){
        LPT::ECiljKomande izborBitPin = ProveriCiljKomande(bitPin);
        return (LPTport->ProcitajSadrzaj(reg, izborBitPin));
    }
    return 0;
}

bool CAktivniLPTPort::MoguceCitanje(const std::string& reg)
{
    return PozoviGetRegDozvola(&CLPTPort::MoguceCitanje, reg);
}

bool CAktivniLPTPort::MogucUpis(const std::string& reg)
{
    return PozoviGetRegDozvola(&CLPTPort::MogucUpis, reg);
}

void CAktivniLPTPort::MoguceCitanje(const std::string& reg, bool omoguci)
{
    PozoviSetRegDozvola(&CLPTPort::MoguceCitanje, reg, omoguci);
}

void CAktivniLPTPort::MogucUpis(const std::string& reg, bool omoguci)
{
    PozoviSetRegDozvola(&CLPTPort::MogucUpis, reg, omoguci);
}

//////////////////////////////////////////////////////////////////////
// Pomocne funkcije 
//////////////////////////////////////////////////////////////////////

CLPTPort* CAktivniLPTPort::DajPortPtr(void)
{
    return portPtr_m;
}

//////////////////////////////////////////////////////////////////////
// Funkcije za prosledjivanje poziva odgovarajucim funkcijama klase CLPTPort
//////////////////////////////////////////////////////////////////////

int CAktivniLPTPort::PozoviBitFunkciju(t_BitFunkcijaPtr pBitFunkcija, int bitMaska, LPT::ECiljKomande bitPin)
{
    CLPTPort* LPTport = DajPortPtr();
    if (LPTport != 0){
        LPT::ECiljKomande izborBitPin = ProveriCiljKomande(bitPin);
        return ((LPTport->*pBitFunkcija)(bitMaska, izborBitPin));
    }
    return 0;
}

bool CAktivniLPTPort::PozoviGetRegDozvola(t_GetRegDozvolaFunPtr pFun, const std::string& reg)
{
    CLPTPort* LPTport = DajPortPtr();
    if (LPTport != 0){
        return ((LPTport->*pFun)(reg));
    }
    return false;
}

void CAktivniLPTPort::PozoviSetRegDozvola(t_SetRegDozvolaFunPtr pFun, const std::string& reg, bool omoguci)
{
    CLPTPort* LPTport = DajPortPtr();
    if (LPTport != 0){
        ((LPTport->*pFun)(reg, omoguci));
    }
}

std::string CAktivniLPTPort::ProveriNazivPorta(const std::string& nazivPorta)
{
    std::string provereniNaziv = port_m;
    // proveri da li dati port postoji u spisku raspolozivih portova
    if (CSpisakLPTPortova::Instance()->PostojiPort(nazivPorta)) {
        provereniNaziv = nazivPorta;
    }
    else { // ako dati port ne postoji ...
        if (Otvoren()) { // ako je aktivni port vec postavljen ...
            provereniNaziv = port_m; // ... neka ostane taj stari port
        }
        else { // ako aktivni post jos nije postavljen ...
            // .. neka aktivni port bude prvi port iz spiska
            if (!CSpisakLPTPortova::Instance()->DajNazivPrvogPorta(provereniNaziv)){
                provereniNaziv = NEDEFINISAN; // sem ako spisak nije prazan
            }
        }
    }
    return provereniNaziv;
}

bool CAktivniLPTPort::OtvoriPortOS(const std::string& nazivPorta)
{
    bool portOK = true;
    if (KoristiOSopen()) {
        if (nazivPorta == NEDEFINISAN) {
            ObrisiPortOS();
        }
        else {
            if (pOSport_m == 0) { // ako prateci objekat nije kreiran ...
                pOSport_m = new CWin32LPT(); // ... kreiraj ga ...
                portOK = pOSport_m->Open(nazivPorta); // ... i otvori port
            }
            else { // ako je prateci objekat vec bio kreiran ...
                if (pOSport_m->Close()){ // ... zatvori port koji je prethodno bio otvoren ...
                    portOK = pOSport_m->Open(nazivPorta); // ... i otvori novi port
                }
                else {
                    portOK = false;
                }
            }
        }
    }
    return portOK;
}

bool CAktivniLPTPort::ObrisiPortOS(void)
{
    if (pOSport_m != 0){
        try {
            delete pOSport_m; // u destruktoru treba da se odradi i 'Close'
            pOSport_m = 0;
        }
        catch (...) {
            return false;
        }
    }
    return true;
}

LPT::ECiljKomande CAktivniLPTPort::ProveriCiljKomande(LPT::ECiljKomande bitPin)
{
    LPT::ECiljKomande izborBitPin = bitPin;
    if (bitPin == LPT::DEFAULT){
        izborBitPin = ciljBitKomande_m;
    }
    return izborBitPin;
}