hardverrt.cpp

s/w handheld terminal ( based on Cygnal 8051f230)

#include "HardverRT.h"
#include "Komanda.h"

//****************************** KKontrolaEEPROMa << BEGIN >> **************************************
// Konstruktor
KKontrolaEEPROMa::KKontrolaEEPROMa( void ){
    // Memorija je organizovana u 2 banke po 8 modula; adresa modula je 4-bitna : 
    //      - bitovi 0-2 predstavljaju adresu modula u banci;
    //      - bit 3 je adresa banke ( 0 za banku 0, 1 za banku 1 ).
    // Fleg ( true, false ) oznacava da li je modul ugradjen( zalemljen ) na rucnom terminalu.
    Konfiguracija.clear();
    // Memorijska banka 0
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x00, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x01, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x02, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x03, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x04, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x05, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x06, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x07, false ) );
    // Memorijska banka 1
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x08, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x09, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x0A, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x0B, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x0C, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x0D, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x0E, false ) );
    Konfiguracija.push_back( KKonfiguracijaEEPROMa( 0x0F, false ) );
}

// Procedura za pristup jedinom objektu klase
KKontrolaEEPROMa* KKontrolaEEPROMa::Instance( void ){
    static KKontrolaEEPROMa instance;
    return &instance;
}

// Procedura izdvaja banku i modul iz date adrese ( banka je bit 3, modul su bitovi 0-2 )
void KKontrolaEEPROMa::IzdvojiBankuIModul( unsigned int nAdresaEEPROMmodula,
                                     unsigned char& nBanka, unsigned char& nModul ){
    nBanka = ( nAdresaEEPROMmodula & 0x08 )>>4;
    nModul = nAdresaEEPROMmodula & 0x07;
}

// Procedura spaja banku i modul u jednu adresu
unsigned int KKontrolaEEPROMa::SpojiBankuIModul( unsigned char nBanka, unsigned char nModul ){
    unsigned int nAdresaEEPROMmodula = 0;

    // Bit 3 je banka
    nAdresaEEPROMmodula = ( nBanka & 0x01 )<<4;
    // Bitovi 0-2 su adresa modula
    nAdresaEEPROMmodula |= ( nModul & 0x07 );

    return nAdresaEEPROMmodula;
}

// Procedura sracunava sledecu adresu za podatke u EEPROM-u u odnosu na datu adresu.
// U slucaju da nema vise mesta u EEPROM-u vraca false.
bool KKontrolaEEPROMa::DajAdresuSledecegPodatka( const KAdminInfo& adminInfo,
                                                 const KOpisRT& opisRT,
                                                 unsigned int& nAdresaEEPROMmodula, 
                                                 unsigned int& nAdresaPodatakaUEEPROMu ){
    bool izlaz = false;                                            
    unsigned int nAdresaPoslednjegBajta = nVelicinaModula * 1024 - 1;
    unsigned int nBrojBajtovaZaSvePodatke;

    if ( adminInfo.bDodatniOpisRT ) {
        // u novoj verziji, duzina bloka podataka se racuna na osnovu opisa rucnog terminala
        nBrojBajtovaZaSvePodatke = adminInfo.BrojBajtovaZaOpisPodatka() + 
                                   opisRT.DuzinaSvihPodatakaBezOpisa();
    }
    else {
        // stara verzija ( do 1.3 )
        nBrojBajtovaZaSvePodatke = KOpisPodataka::Instance()->BrojBajtovaZaSvePodatke( adminInfo );
    }

    // Najpre 'preskoci' prethodne podatke
    nAdresaPodatakaUEEPROMu += nBrojBajtovaZaSvePodatke;
    // Ispitaj da li ima mesta u tekucem modulu za nove podatke
    if (    nAdresaPodatakaUEEPROMu + nBrojBajtovaZaSvePodatke
          < nAdresaPoslednjegBajta ) {
        izlaz = true;
    }
    else { // ako nema mesta u tekucem modulu

        // Nadji sledeci modul u spisku, za koji je setovan fleg 
        // ( sto znaci da je ugradjen u rucni terminal ) :

        //      - nadji poziciju tekuceg modula u spisku 'Konfiguracija'
        unsigned int nBrElem = Konfiguracija.size();
        unsigned int nTekuciInd = 0xFFFF;
        for ( nTekuciInd=0; nTekuciInd < nBrElem; nTekuciInd++ ) {
            if ( Konfiguracija[ nTekuciInd ].nAdresa == nAdresaEEPROMmodula ) break;
        }

        //      - nadji poziciju sledeceg modula u spisku (ako postoji)
        unsigned int nNoviInd;
        if ( nTekuciInd != 0xFFFF && nTekuciInd < nBrElem ) {
            for ( nNoviInd=nTekuciInd+1; nNoviInd < nBrElem ; nNoviInd++ ) {
                if ( Konfiguracija[ nNoviInd ].bFlag ) {
                    nAdresaEEPROMmodula     = Konfiguracija[ nNoviInd ].nAdresa;
                    nAdresaPodatakaUEEPROMu = 0; // podaci se upisuju na pocetak novog modula
                    izlaz = true;
                    break;
                }
            }
        }
    }

    return izlaz;
}

// Funkcija koja postavlja konfiguraciju EEPROM-a i to :
//  - konfiguracione flegove ( indikacija da li je modul prisutan ) i
//  - velicinu modula u KB
void KKontrolaEEPROMa::PostaviKonfiguraciju( string cFlegovi, unsigned int nVModula,
                                             unsigned int nAdresaSpiskaBrojila ){

    unsigned int nRBrRModula = 0;

    for( int i=0; i<BROJ_MEMORIJSKIH_BANAKA; i++ ){
        unsigned int  cMaska = 0x01;
        unsigned char cBajt = cFlegovi[ i ];
        for ( int j=0; j<BROJ_MODULA_PO_BANCI; j++ ){
            Konfiguracija[ nRBrRModula++ ].bFlag = ( cBajt & cMaska )?true:false;
            cMaska = cMaska << 1;
        }
    }
    nVelicinaModula = nVModula;
    nPocetnaAdresaSpiskaBrojila = nAdresaSpiskaBrojila;
}

// Funkcija vraca adresu 'osnovnog modula' ili OSNOVNI_MODUL_NEDEFINISAN ako modul ne postoji.
// Osnovni modul je prvi koji postoji ( koji je zalemljen ) na plocici rucnog terminala
// racunajuci od modula sa adresom 0 u prvoj banci do modula sa adresom 7 u drugoj banci.
// U osnovnom modulu se cuva spisak brojila i ostavle 'administrativne' informacije.
unsigned int KKontrolaEEPROMa::DajOsnovniModul( void ){
    unsigned int nOsnovniModul = OSNOVNI_MODUL_NEDEFINISAN;
    TKKonfiguracijaEEPROMa::iterator k_iter     = Konfiguracija.begin();
    TKKonfiguracijaEEPROMa::iterator k_iterEnd  = Konfiguracija.end();

    while ( k_iter != k_iterEnd ){
        if ( k_iter->bFlag ){
            nOsnovniModul = k_iter->nAdresa;
            break;
        }
        k_iter++;
    }

    return nOsnovniModul;
}

// Funkcija pakuje adresu podatka u EEPROM-u i 'bank/chip select' u string duzine 3 bajta
// i to na sledeci nacin : 
//  - bajt 0 sadrzi bitove 8-15 adrese podatka
//  - bajt 1 sadrzi bitove 0-7 adrese podatka
//  - bajt 2 sadrzi bitove 16-19 adrese podatka( visi nibl ) i bank/chip select( nizi nibl )
KString KKontrolaEEPROMa::SpakujAdresu( unsigned int nAdresaPodatakaUEEPROMu, 
                                        unsigned int nAdresaEEPROMmodula ){
    KString cOutStr;
    KString cPomStr;
    unsigned char nPomChr;

    // Uzmi 3 bajta adrese :
    cPomStr = KKorisno::Instance()->KonvertIntUNiblString( nAdresaPodatakaUEEPROMu, 3 );

    // Spakuj bitove 0-15 u prvi i drugi bajt :
    cOutStr = cPomStr.substr( 1, 2 );

    // Spakuj bitove 16-19 i bank/chip select u treci bajt :
    nPomChr = (unsigned char)cPomStr[0] & 0x0F;         // bitovi 16-19 adrese podatka
    nPomChr = ( nPomChr << 4 ) & 0xF0;                  // pomeri bitove 16-19 u visi nibl
    nPomChr = nPomChr | ( nAdresaEEPROMmodula & 0x0F ); // spoji sa bank/chip select
    cOutStr.cString.append( 1, nPomChr );

    return cOutStr;
}
//******************************* KKontrolaEEPROMa << END >> **************************************