#include "vcl\condefs.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "Metodos.h"
#pragma hdrstop
//----------------------------------------------------------------------------------------------------------
//USERES("Connect.res");
USEUNIT("Metodos.cpp");
//----------------------------------------------------------------------------------------------------------
//Programa exemplo
int main(int argc, char **argv)
{
      TParalela  Lpt;     //Instancia objeto
      cout << "Envio de Arquivo através da Porta Paralela" << endl;
      cout << "------------------------------------------" << endl;
      if(argc < 3)
      {
            cout << "Ajuda:" << endl;
            cout << "Use: CONNECT E Nome_do_Arquivo\n"; //Quem envia
            cout << "Ou" << endl;
            cout << "Use: CONNECT R Nome_do_Arquivo\n"; //Quem recebe
       }
       Lpt.Envia(LPT1,BIT4); //Seta Busy == 0
       if(argv[1][0] == 'R' || argv[1][0] == 'r')
       {
            cout << "Estação pronta para Receber arquivo!" << endl;             
            Lpt.RecebeArquivo(argv[2]);
       }else{
            cout << "Estação pronta para Enviar arquivo!" << endl;
            Lpt.EnviaArquivo(argv[2]);
       }
       return( 0 );
}

#ifndef MetodosH
#define MetodosH
//--------------------------------------------------------------------------------------------------------
#include "vcl\SysUtils.hpp"
#include "vcl\Controls.hpp"
#include "vcl\Classes.hpp"
#define LPT1 0x378 // Endereço da LPT1=0x378, LPT2=0x278
#define BIT0 0x01   //Não usado
#define BIT1 0x02   //Não usado
#define BIT2 0x04   //Não usado
#define BIT3 0x08   //Error
#define BIT4 0x10   //Slct out
#define BIT5 0x20   //Paper end
#define BIT6 0x40   //Ack
#define BIT7 0x80   //Busy
//--------------------------------------------------------------------------------------------------------
class TParalela
{
         public:
                  void Envia(unsigned short int PortaEnd, unsigned char Dado);
                  unsigned char Recebe(unsigned short int PortaEnd);
                  unsigned char RecebeNibble(void);
                  void EnviaNibble(unsigned char Byte);
                  void EnviaByte(unsigned char Byte);
                  unsigned char RecebeByte(void);
                  void EnviaTamanhoArq(long Tama);
                  int EnviaArquivo(char *NomeArquivo);
                  long RecebeTamanhoArq(void);
                  int RecebeArquivo(char *NomeArquivo);
};
#endif

#include "vcl\vcl.h"
#pragma hdrstop
#include "Metodos.h"
#include "stdio.h"
#include "dos.h"
#include "Sys\stat.h"
#include "stdlib.h"
//--------------------------------------------------------------------------------------------------------
// Envia um byte à porta paralela (Hardware)
//--------------------------------------------------------------------------------------------------------
void TParalela::Envia(unsigned short int PortaEnd, unsigned char Dado)
{
      _DX = PortaEnd;
      _AL = Dado;   //_AX = Dado;
      __emit__ (0xEE);
}
//--------------------------------------------------------------------------------------------------------
// Recebe um byte da porta paralela (Hardware)
//--------------------------------------------------------------------------------------------------------
unsigned char TParalela::Recebe(unsigned short int PortaEnd)
{
      _DX = PortaEnd;
      __emit__ (0xEC);
      return (_AL);
}
//--------------------------------------------------------------------------------------------------------
//Método que recebe 4 bits (1 Nibble) da porta paralela
//--------------------------------------------------------------------------------------------------------
unsigned char TParalela::RecebeNibble(void)
{
     unsigned char RetByte; //Byte lido
     unsigned char Byte;
     do{
              RetByte = Recebe(LPT1+1); //0x379 Status
     }while(RetByte & BIT7); //Aguarda Busy ser 1
     Envia(LPT1,0x00); //Seta D4 = 0 (zero)
     do{
           RetByte = Recebe(LPT1+1);
     }while(!(RetByte & BIT7)); // Aguarda Busy ser 0 (zero)
     RetByte = Recebe(LPT1+1); // Le o dado
     Byte = (unsigned char)((RetByte >> 3) & 0x0f); // Decodifica o Nibble
     Envia(LPT1,BIT4); // Sinaliza com D4 = 1 Slct out
     return(Byte); //Retorna o Nibble lido
}
//--------------------------------------------------------------------------------------------------------
//Método que envia 4 bits (1 Nibble) pela porta paralela
//--------------------------------------------------------------------------------------------------------
void TParalela::EnviaNibble(unsigned char Byte)
{
     unsigned char RetByte; //Byte lido
     do {
              RetByte = Recebe(LPT1+1);
     }while(!(RetByte & BIT7)); // Aguarda Busy ser 0 (zero)
     Envia(LPT1,(unsigned char)(Byte & 0x0f)); // Envia dado
     do{
              RetByte = Recebe(LPT1+1);
     }while(RetByte & BIT7); // Aguarda Busy ser 1
     Envia(LPT1,0x10); // Envia D4 = 1
}
//--------------------------------------------------------------------------------------------------------
//Envia um Byte pela porta Paralela
//--------------------------------------------------------------------------------------------------------
void TParalela::EnviaByte(unsigned char Byte)
{
     unsigned char BaixoByte;
     BaixoByte = (unsigned char)(Byte >> 4); // Pega o nibble mais significativo      
     EnviaNibble(Byte); // Envia o nibble menos significativo
     EnviaNibble(BaixoByte); // Envia o nibble mais signivicativo
}
//--------------------------------------------------------------------------------------------------------
//Recebe um byte pela porta Paralela
//--------------------------------------------------------------------------------------------------------
unsigned char TParalela::RecebeByte(void)
{
      unsigned char MontaByte;
      unsigned char NibbleBaixo;
      unsigned char NibbleAuto;
      NibbleBaixo = (unsigned char)(RecebeNibble() & 0x0F); //Le nibble - signifi.
      NibbleAuto = (unsigned char)(RecebeNibble() & 0x0F); //Le nibble + signifi.
      NibbleAuto = (unsigned char)((NibbleAuto << 4) & 0xF0);
      MontaByte = NibbleBaixo | NibbleAuto;
      return(MontaByte);
}
//--------------------------------------------------------------------------------------------------------
//Envia o tamanho do arquivo
//--------------------------------------------------------------------------------------------------------
void TParalela::EnviaTamanhoArq(long Tama)
{
     union {
               unsigned long Tamanho;
               unsigned char TamanhoByte[4];
     }Arquivo;
    Arquivo.Tamanho = Tama;
    EnviaByte(Arquivo.TamanhoByte[0]);
    EnviaByte(Arquivo.TamanhoByte[1]);
    EnviaByte(Arquivo.TamanhoByte[2]);
    EnviaByte(Arquivo.TamanhoByte[3]);
}
//--------------------------------------------------------------------------------------------------------
//Envia os dados do arquivo
//--------------------------------------------------------------------------------------------------------
int TParalela::EnviaArquivo(char *NomeArquivo)
{
      FILE *ArqLer;
      unsigned char Caractere;
      struct stat Buffer;
      long Tamanho;
      if((ArqLer=fopen(NomeArquivo,"rb")) == NULL)
     {
         return(-1); //Erro de leitura do arquivo.
     }
     stat(NomeArquivo,&Buffer);
     Tamanho = Buffer.st_size;
     cout << "Tamanho do arquivo: " << Tamanho;
     EnviaTamanhoArq(Tamanho);
     while(Tamanho--)
     {
         Caractere = (unsigned char)fgetc(ArqLer);
         EnviaByte(Caractere);
     }
     fcloseall();
     return(0); //Ok
}
//--------------------------------------------------------------------------------------------------------
//Recebe o tamanho do arquivo
//--------------------------------------------------------------------------------------------------------
long TParalela::RecebeTamanhoArq(void)
{
     union {     //Divide o long em 4 bytes
            unsigned long Tamanho;
            unsigned char TamanhoByte[4];
     }Arquivo;
     Arquivo.TamanhoByte[0] = RecebeByte(); //byte menos significativo     
     Arquivo.TamanhoByte[1] = RecebeByte(); //do long.
     Arquivo.TamanhoByte[2] = RecebeByte();
     Arquivo.TamanhoByte[3] = RecebeByte(); //byte mais significativo
     return(Arquivo.Tamanho);
}
//--------------------------------------------------------------------------------------------------------
//Recebe um arquivo pela paralela
//--------------------------------------------------------------------------------------------------------
int TParalela::RecebeArquivo(char *NomeArquivo)
{
       FILE *ArqGrava;
       unsigned long tamanho;
       unsigned char RetByte;
       cout << "Ative a estação cliente.";
       do{
            RetByte = Recebe(LPT1+1);
       }while(RetByte & BIT7); //Busy
       if((ArqGrava=fopen(NomeArquivo,"wb")) == NULL)
       {
           return(-1); //Erro ao gravar o arquivo.
       }
       tamanho = RecebeTamanhoArq();
       cout << "\nTamanho do arquivo: " << tamanho;
       while(tamanho)
       {
           RetByte = RecebeByte();
           fputc(RetByte,ArqGrava);
           tamanho--;
       }
       fcloseall();
       return(0); //Ok
}