lptport.cpp

pc paralel port programming

// LPTPort.cpp: implementation of the CLPTPort class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "LPTPort.h"
#include "BaznaLPTAdresa.h"
#include "RegistarDATA.h"
#include "RegistarSTATUS.h"
#include "RegistarCONTROL.h"


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

CLPTPort::CLPTPortException::CLPTPortException(const std::string& opis)
{
    opisGreske = opis;
}

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

CLPTPort::CLPTPort(int LPTport)
{
    // odredi baznu adresu porta
    int adr;
    try {
        adr = CBaznaLPTAdresa::GetAddressLptPort(LPTport);
    }
    catch (...) {
        throw CLPTPortException("Error : cannot obtain base address !");
    }
    if (adr == -1) {
        throw CLPTPortException("Port does not exists !");
    }

    // inicijalizuj spisak registara
    try {
        registri_m.push_back(new CRegistarDATA(adr));
        registri_m.push_back(new CRegistarSTATUS(adr));
        registri_m.push_back(new CRegistarCONTROL(adr));
    }
    catch (...) {
        IsprazniSpisakRegistara();
        throw CLPTPortException("Error : register creation failed !");
    }

    // sledece dve naredbe ne mogu da bace izuzetak
    this->port_m = LPTport;
    this->baznaAdresa_m = adr;
}

CLPTPort::~CLPTPort()
{
    IsprazniSpisakRegistara();
}

std::string CLPTPort::NazivPorta(int LPTport)
{
    std::string naziv("LPT");

    char pombuff[20];
    sprintf(pombuff, "%d", LPTport);
    naziv += pombuff;

    return naziv;
}

std::string CLPTPort::DajNaziv(void)
{
    return NazivPorta(port_m);
}

int CLPTPort::DajBaznuAdresu(void)
{
    return baznaAdresa_m;
}

int CLPTPort::DajBrojPorta(void)
{
    return port_m;
}

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

int CLPTPort::Postavi(int bitMaska, LPT::ECiljKomande bitPin)
{
    CLPTRegistar* pRegistar;
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        pRegistar = (*r_iter);
        if (pRegistar->AdresiranMaskom(bitMaska)){
            pRegistar->Postavi(bitMaska, PosmatrajPinove(bitPin));
        }
    }

    // citanje vrednosti pinova nakon je izbaceno zbog performansi
//    return (Procitaj(LPT::SVI_BITOVI, bitPin));
    return 0;
}

int CLPTPort::Obori(int bitMaska, LPT::ECiljKomande bitPin)
{
    CLPTRegistar* pRegistar;
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        pRegistar = (*r_iter);
        if (pRegistar->AdresiranMaskom(bitMaska)){
            pRegistar->Obori(bitMaska, PosmatrajPinove(bitPin));
        }
    }

    // citanje vrednosti pinova je izbaceno zbog performansi
//    return (Procitaj(LPT::SVI_BITOVI, bitPin));
    return 0;
}

int CLPTPort::Procitaj(int bitMaska, LPT::ECiljKomande bitPin)
{
    int rezultat = 0;

    CLPTRegistar* pRegistar;
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        pRegistar = (*r_iter);
        if (pRegistar->AdresiranMaskom(bitMaska)){
            pRegistar->Procitaj(PosmatrajPinove(bitPin));
            rezultat |= pRegistar->RasporediBitoveSadrzajaUMasku(PosmatrajPinove(bitPin));
        }
    }

    // vracam samo bitove koji su trazeni(definisani parametrom 'bitMaska')
    return (rezultat & bitMaska);
}

bool CLPTPort::Postavljen(int bitMaska, LPT::ECiljKomande bitPin)
{
    bool bSetovan = false;
    CLPTRegistar* pRegistar;
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        pRegistar = (*r_iter);
        if (pRegistar->AdresiranMaskom(bitMaska)){
            bSetovan = pRegistar->Postavljen(bitMaska, PosmatrajPinove(bitPin));
            break;
        }
    }
    return bSetovan;
}

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

int CLPTPort::PostaviSadrzaj(const std::string& reg, int val, LPT::ECiljKomande bitPin)
{
    CLPTRegistar* pReg = DajRegistar(reg);
    if ( pReg != 0 ){
        pReg->Posalji(val, PosmatrajPinove(bitPin));
    }
    return ProcitajSadrzaj(reg, bitPin);
}

int CLPTPort::ProcitajSadrzaj(const std::string& reg, LPT::ECiljKomande bitPin)
{
    CLPTRegistar* pReg = DajRegistar(reg);
    if ( pReg != 0 ){
        return (pReg->Procitaj(PosmatrajPinove(bitPin)));
    }
    return 0;
}

bool CLPTPort::MoguceCitanje(const std::string& reg)
{
    CLPTRegistar* pReg = DajRegistar(reg);
    if ( pReg != 0 ){
        return (pReg->MoguceCitanje());
    }
    return false;
}

bool CLPTPort::MogucUpis(const std::string& reg)
{
    CLPTRegistar* pReg = DajRegistar(reg);
    if ( pReg != 0 ){
        return (pReg->MogucUpis());
    }
    return false;
}

void CLPTPort::MoguceCitanje(const std::string& reg, bool omoguci)
{
    CLPTRegistar* pReg = DajRegistar(reg);
    if ( pReg != 0 ){
        pReg->MoguceCitanje(omoguci);
    }
}

void CLPTPort::MogucUpis(const std::string& reg, bool omoguci)
{
    CLPTRegistar* pReg = DajRegistar(reg);
    if ( pReg != 0 ){
        pReg->MogucUpis(omoguci);
    }
}

void CLPTPort::ProcitajSadrzajSvihRegistara(LPT::ECiljKomande bitPin)
{
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        (*r_iter)->Procitaj(PosmatrajPinove(bitPin));
    }
}

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

void CLPTPort::IsprazniSpisakRegistara(void)
{
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        delete (*r_iter);
    }
    registri_m.clear();
}

CLPTRegistar* CLPTPort::DajRegistar(std::string naziv)
{
    tSpisakReg::const_iterator regEnd = registri_m.end();
    for (tSpisakReg::iterator r_iter = registri_m.begin(); r_iter != regEnd; ++r_iter) {
        if ((*r_iter)->Naziv() == naziv){
            return (*r_iter);
        }
    }
    return 0;
}

bool CLPTPort::PosmatrajPinove(LPT::ECiljKomande bitPin)
{
    return (bitPin == LPT::PIN);
}