URL https://opencores.org/ocsvn/modular_oscilloscope/modular_oscilloscope/trunk

Subversion Repositories modular_oscilloscope

[/] [modular_oscilloscope/] [trunk/] [sw/] [src/] [include/] [epp_parallel_use_win.cpp] - Blame information for rev 60

Details | Compare with Previous | View Log


#include "delay.h"
#include "delay.c"
#include "epp_parallel_access_win.h"
#include "epp_parallel_use_win.h"
 
 
//// CONEXI�N //////////////////////////////////////////////////////////////////////////////////////
EppParallelUseWin::EppParallelUseWin()
{
  baseAddress = 0;
  status = loadDLL();
}
 
 
EppParallelUseWin::EppParallelUseWin(const short int &base_address)
{
  status = loadDLL();
  if (status == PP_STATE_IDLE)
  {
    status = negotiateEPP(base_address);
  }
}
 
EppParallelUseWin::~EppParallelUseWin()
{
  closeEPP();
}
 
 
 EppParallelUseWin::PPStatusType EppParallelUseWin::negotiateEPP()
{
 
  switch(status)
  {
/*  case PP_RA_TIME_OUT:
    case PP_WA_TIME_OUT:
    case PP_RB_TIME_OUT:
    case PP_WB_TIME_OUT:
    case PP_RW_TIME_OUT:
    case PP_WW_TIME_OUT:*/
    case PP_TIME_OUT:
    case PP_CONECTED:
      closeEPP();
    case PP_STATE_IDLE:
    case PP_COMUNICATION_FAIL:
    case PP_NEGOTIATION_FAIL:
      char data; // temporales
      int i;
      // Resumen de se�ales de los regisros
      //+1(/Busy, Ackm,   Paper end,  Select,  Error,      nc,     nc,         EPPtimeout?)
      //+1(/Busy, Ackm,   PError,     Select,  nFault,      nc,     nc,         nc)
      //+2(nc,    nc,     PCD,        IRQE,   /SelectIn,  init,   /autofeed,  /strobe)
 
      // Se indican los n�meros de eventos y los nombres de los tiempos de espera seg�n est�ndar
 
      // evento -1
      data = PortIn(baseAddress+2) & 0xDE ;
      PortOut(baseAddress+2, data);
      udelay(1); // Tp
 
      // evento 0
      PortOut(baseAddress, 0x40);
      udelay(1); // Tp
 
      // evento 1
      data = PortIn(baseAddress+2) & 0xF7 | 0x02;
      PortOut(baseAddress+2, data);
 
      // evento 2
      for (i=0; i<35; i++)
      {
          udelay(1000);
          data = PortIn(baseAddress+1);
          if ( (data & 0x78) == 0x38) break;
              //select =1  nFault = 1 nack = 0 perror = 1
      }
      if (i >= 35) status = PP_COMUNICATION_FAIL;
      else
      {
 
          // evento 3
          data = PortIn(baseAddress+2) | 0x01; // nstrobe = 1
          PortOut(baseAddress+2, data);
          udelay(1); // Tp
          //+2(nc,    nc,     PCD,        IRQE,   /SelectIn,  init,   /autofeed,  /strobe)
 
          // evento 4
          data = PortIn(baseAddress+2) & 0xfc; // nstrobe = 0 nautofeed = 0
          PortOut(baseAddress+2, data);
          udelay(1); // Tp
          //+2(nc,    nc,     PCD,        IRQE,   /SelectIn,  init,   /autofeed,  /strobe)
 
          // evento 6
          for (i=0; i<35; i++)
          {
              udelay(1000);
              data = PortIn(baseAddress+1);
              if ( (data & 0x50) == 0x50) break;
                  //nack = 1 select = 1
                  //+1(/Busy, Ackm,   PError,     Select,  nFault,      nc,     nc,         nc)
 
          }
 
          if (i >= 35) status = PP_NEGOTIATION_FAIL;
          else status = PP_CONECTED;
 
      }
      break;
 
    default:
     break;
  }
  return(status);
}
 
 
EppParallelUseWin::PPStatusType EppParallelUseWin::negotiateEPP(const unsigned short int &address)
{
  status = setBaseAddress(address);
  if (status == PP_STATE_IDLE) status = negotiateEPP();
  return(status);
 
}
 
 
void EppParallelUseWin::closeEPP()
{
  char data;
  //+2(nc,    nc,     PCD,        IRQE,   /SelectIn,  init,   /autofeed,  /strobe)
 
 
  // evento initialization
  data = PortIn(baseAddress+2) & 0xFB | 0x08; //ninit=0 nselectin=1
  PortOut(baseAddress+2, data);
  udelay(500); // T_ER
 
  // se realiza dos veces por las dudas
  data = PortIn(baseAddress+2) | 0x04; //ninit=1
  PortOut(baseAddress+2, data);
  udelay(500); // T_ER
 
  status = PP_STATE_IDLE;
}
 
 
 
EppParallelUseWin::PPStatusType EppParallelUseWin::setBaseAddress(const short int &address)
{
 
  if (address == 0x3BC || address == 0x378 || address == 0x278)
  {
    baseAddress = address;
    closeEPP(); // Reinicia interfaz y setea status a PP_STATE_IDLE
  }
  else
  {
    baseAddress = 0;
    status = PP_WRONG_BASE_ADDRESS;
  }
  return(status);
}
 
short int EppParallelUseWin::getBaseAddress() {return(baseAddress);}
 
 
// LECTURA/ESCRITURA DIRECCI�N /////////////////////////////////////////////////////////////////////
 
void EppParallelUseWin::writeAddress(const char &address)
{
  if (testStatusForDataTransfer()) PortOut(baseAddress + 3, address);
 
}
 
 
//EppParallelUseWin::PPStatusType EppParallelUseWin::writeAddress(const char &address)
//{
//  if (testStatusForDataTransfer())
//  {
//      prepareTestDataTransfer();
//      PortOut(baseAddress + 3, address);
//      status = testDataTransfer();
//  }
//  return(status);
//}
 
void EppParallelUseWin::readAddress(char &return_address)
{
  if (testStatusForDataTransfer())  return_address = PortIn(baseAddress + 3);
}
 
//EppParallelUseWin::PPStatusType EppParallelUseWin::readAddress(char &return_address) const
//{
//  if (testStatusForDataTransfer())
//  {
//      prepareTestDataTransfer();
//      return_address = PortIn(baseAddress + 3);
//      status = testDataTransfer();
//  }
//  return(status);
//}
 
// LECTURA/ESCRITURA BYTE //////////////////////////////////////////////////////////////////////////
void EppParallelUseWin::writeByte(const char &byte)
{
  if (testStatusForDataTransfer()) PortOut(baseAddress + 4, byte);
}
 
 
void EppParallelUseWin::writeByte(const char &byte, const char &address)
{
  writeAddress(address);
  if (testStatusForDataTransfer()) PortOut(baseAddress + 4, byte);
}
 
 
//EppParallelUseWin::PPStatusType EppParallelUseWin::writeByte(const char &byte) const
//{
//  if (testStatusForDataTransfer())
//  {
//    prepareTestDataTransfer();
//    PortOut(baseAddress + 4, byte);
//    status = testDataTransfer();
//  }
//  return(status);
//}
//
//
//EppParallelUseWin::PPStatusType EppParallelUseWin::writeByte(const char &byte, const char &address) const
//{
//  status = writeAddress(address);
//  if (status == PP_CONECTED)
//  {
//    prepareTestDataTransfer();
//    PortOut(baseAddress + 4, byte);
//    status = testDataTransfer();
//  }
//  return(status);
//}
 
 
void EppParallelUseWin::readByte(char &return_byte)
{
  if (testStatusForDataTransfer()) return_byte = PortIn(baseAddress+4);
}
 
 
void EppParallelUseWin::readByte(char &return_byte, const char &address)
{
  writeAddress(address);
  if (testStatusForDataTransfer()) return_byte = PortIn(baseAddress + 4);
}
 
 
//EppParallelUseWin::PPStatusType EppParallelUseWin::readByte(char &return_byte) const
//{
//  if (testStatusForDataTransfer())
//  {
//    prepareTestDataTransfer();
//    return_byte = PortIn(baseAddress + 4);
//    status = testDataTransfer();
//  }
//  return(status);
//}
//
//
//EppParallelUseWin::PPStatusType EppParallelUseWin::readByte(char &return_byte, const char &addresss) const
//{
//  status = writeAddress(address);
//  if (status == PP_CONECTED)
//  {
//    prepareTestDataTransfer();
//    return_byte = PortIn(baseAddress + 4);
//    status = testDataTransfer();
//  }
//  return(status);
//}
 
 
// LECTURA/ESCRITURA WORD //////////////////////////////////////////////////////////////////////////
void EppParallelUseWin::writeWord(const unsigned short int &word)
{
  if (testStatusForDataTransfer())
  {
    char data;
    data = word & 0x00FF;
    PortOut(baseAddress + 4, data);
    data = (word & 0xFF00) >> 8;
    PortOut(baseAddress + 4, data);
  }
}
 
 
void EppParallelUseWin::writeWord(const unsigned short int &word, const char &address)
{
  writeAddress(address);
  writeWord(word);
}
 
 
//EppParallelUseWin::PPStatusType EppParallelUseWin::writeWord(const short int &word) const
//{
//  if (testStatusForDataTransfer())
//  {
//    prepareTestDataTransfer();
//    char data;
//    data = word & 0xFF;
//    PortOut(baseAddress + 4, data);
//    data = (word & 0xFF00) >> 8;
//    PortOut(baseAddress + 4, data);
//    status = testDataTransfer();
//  }
//  return(status);
//}
//
//
//EppParallelUseWin::PPStatusType EppParallelUseWin::writeWord(const short int &word, const char &address) const
//{
//  status = writeAddress(address);
//  if (status == PP_CONECTED)
//  {
//    prepareTestDataTransfer();
//    char data;
//    data = word & 0xFF;
//    PortOut(baseAddress + 4, data);
//    data = (word & 0xFF00) >> 8;
//    PortOut(baseAddress + 4, data);
//    status = testDataTransfer();
//  }
//  return(status);
//}
 
 
void EppParallelUseWin::readWord(unsigned  int &return_word)
{
  if (testStatusForDataTransfer())
  {
    unsigned int data;
 
    data = PortIn(baseAddress + 4) & 0x00FF;
    data = (PortIn(baseAddress + 4) << 8) | data;
   // udelay(600);
    return_word = data & 0xFFFF;
  }
}
 
 
void EppParallelUseWin::readWord(unsigned int &return_word, const char &address)
{
  writeAddress(address);
  readWord(return_word);
}
 
 
//EppParallelUseWin::PPStatusType EppParallelUseWin::readWord(short int &return_word) const
//{
//  if (testStatusForDataTransfer())
//  {
//    prepareTestDataTransfer();
//    short int data;
//    data = PortIn(baseAddress + 4);
//    data = PortIn(baseAddress + 4) << 8 | data;
//    return_word = data;
//    status = testDataTransfer();
//  }
//  return(status);
//}
//
//
//EppParallelUseWin::PPStatusType EppParallelUseWin::readWord(short int &return_word, const char &address) const
//{
//  status = writeAddress(address);
//  if (status == PP_CONECTED)
//  {
//    prepareTestDataTransfer();
//    short int data;
//    data = PortIn(baseAddress + 4);
//    data = PortIn(baseAddress + 4) << 8 | data;
//    return_word = data;
//    status = testDataTransfer();
//  }
//  return(status);
//}
 
 
// LECTURA DE ESTADO DE CONEXI�N ///////////////////////////////////////////////////////////////////
EppParallelUseWin::PPStatusType EppParallelUseWin::getStatus() {return(status);}
 
 
// FUNCIONES PRIVADAS //////////////////////////////////////////////////////////////////////////////
EppParallelUseWin::PPStatusType EppParallelUseWin::loadDLL()
{
    int result;
 
    LoadIODLL();
    result = IsDriverInstalled(); // Funcion de testeo
    if (result == 0) {
          LoadIODLL(); // Segundo intento, corrige errores en Windows Vista
          result = IsDriverInstalled();
          if (result == 0) return(PP_LOAD_LIBRARY_FAIL);
          else return(PP_STATE_IDLE);
    }
    else return(PP_STATE_IDLE);
}
 
 
bool EppParallelUseWin::testStatusForDataTransfer()
{
  switch(status)
  {
    case PP_CONECTED:
  /*  case PP_RA_TIME_OUT:
    case PP_WA_TIME_OUT:
    case PP_RB_TIME_OUT:
    case PP_WB_TIME_OUT:
    case PP_RW_TIME_OUT:
    case PP_WW_TIME_OUT:*/
    case PP_TIME_OUT:
      return(1);
      break;
    default:
      return(0);
      break;
  }
}
 
 
void EppParallelUseWin::prepareTestDataTransfer()
{
  char data; // temporal
  data = PortIn(baseAddress + 1) & 0xFE ; //EPP timeout = 0
  PortOut(baseAddress + 1, data);
}
 
 
EppParallelUseWin::PPStatusType EppParallelUseWin::testDataTransfer()
{
  char data;
  //udelay(50);
  data = PortIn(baseAddress + 1) & 0x01 ; // leer EPP timeout
  prepareTestDataTransfer();
  switch (data)
  {
    case 0:
      return(PP_CONECTED);
      break;
    default:
      return(PP_TIME_OUT);
      break;
  }
}

Browse

Tools

Subversion Repositories modular_oscilloscope

[/] [modular_oscilloscope/] [trunk/] [sw/] [src/] [include/] [epp_parallel_use_win.cpp] - Blame information for rev 60

Line No.	Rev	Author	Line
1	60	budinero	`#include "delay.h"`
2			`#include "delay.c"`
3			`#include "epp_parallel_access_win.h"`
4			`#include "epp_parallel_use_win.h"`
5
6
7			`//// CONEXI�N //////////////////////////////////////////////////////////////////////////////////////`
8			`EppParallelUseWin::EppParallelUseWin()`
9			`{`
10			`baseAddress = 0;`
11			`status = loadDLL();`
12			`}`
13
14
15			`EppParallelUseWin::EppParallelUseWin(const short int &base_address)`
16			`{`
17			`status = loadDLL();`
18			`if (status == PP_STATE_IDLE)`
19			`{`
20			`status = negotiateEPP(base_address);`
21			`}`
22			`}`
23
24			`EppParallelUseWin::~EppParallelUseWin()`
25			`{`
26			`closeEPP();`
27			`}`
28
29
30			`EppParallelUseWin::PPStatusType EppParallelUseWin::negotiateEPP()`
31			`{`
32
33			`switch(status)`
34			`{`
35			`/* case PP_RA_TIME_OUT:`
36			`case PP_WA_TIME_OUT:`
37			`case PP_RB_TIME_OUT:`
38			`case PP_WB_TIME_OUT:`
39			`case PP_RW_TIME_OUT:`
40			`case PP_WW_TIME_OUT:*/`
41			`case PP_TIME_OUT:`
42			`case PP_CONECTED:`
43			`closeEPP();`
44			`case PP_STATE_IDLE:`
45			`case PP_COMUNICATION_FAIL:`
46			`case PP_NEGOTIATION_FAIL:`
47			`char data; // temporales`
48			`int i;`
49			`// Resumen de se�ales de los regisros`
50			`//+1(/Busy, Ackm, Paper end, Select, Error, nc, nc, EPPtimeout?)`
51			`//+1(/Busy, Ackm, PError, Select, nFault, nc, nc, nc)`
52			`//+2(nc, nc, PCD, IRQE, /SelectIn, init, /autofeed, /strobe)`
53
54			`// Se indican los n�meros de eventos y los nombres de los tiempos de espera seg�n est�ndar`
55
56			`// evento -1`
57			`data = PortIn(baseAddress+2) & 0xDE ;`
58			`PortOut(baseAddress+2, data);`
59			`udelay(1); // Tp`
60
61			`// evento 0`
62			`PortOut(baseAddress, 0x40);`
63			`udelay(1); // Tp`
64
65			`// evento 1`
66			`data = PortIn(baseAddress+2) & 0xF7 \| 0x02;`
67			`PortOut(baseAddress+2, data);`
68
69			`// evento 2`
70			`for (i=0; i<35; i++)`
71			`{`
72			`udelay(1000);`
73			`data = PortIn(baseAddress+1);`
74			`if ( (data & 0x78) == 0x38) break;`
75			`//select =1 nFault = 1 nack = 0 perror = 1`
76			`}`
77			`if (i >= 35) status = PP_COMUNICATION_FAIL;`
78			`else`
79			`{`
80
81			`// evento 3`
82			`data = PortIn(baseAddress+2) \| 0x01; // nstrobe = 1`
83			`PortOut(baseAddress+2, data);`
84			`udelay(1); // Tp`
85			`//+2(nc, nc, PCD, IRQE, /SelectIn, init, /autofeed, /strobe)`
86
87			`// evento 4`
88			`data = PortIn(baseAddress+2) & 0xfc; // nstrobe = 0 nautofeed = 0`
89			`PortOut(baseAddress+2, data);`
90			`udelay(1); // Tp`
91			`//+2(nc, nc, PCD, IRQE, /SelectIn, init, /autofeed, /strobe)`
92
93			`// evento 6`
94			`for (i=0; i<35; i++)`
95			`{`
96			`udelay(1000);`
97			`data = PortIn(baseAddress+1);`
98			`if ( (data & 0x50) == 0x50) break;`
99			`//nack = 1 select = 1`
100			`//+1(/Busy, Ackm, PError, Select, nFault, nc, nc, nc)`
101
102			`}`
103
104			`if (i >= 35) status = PP_NEGOTIATION_FAIL;`
105			`else status = PP_CONECTED;`
106
107			`}`
108			`break;`
109
110			`default:`
111			`break;`
112			`}`
113			`return(status);`
114			`}`
115
116
117			`EppParallelUseWin::PPStatusType EppParallelUseWin::negotiateEPP(const unsigned short int &address)`
118			`{`
119			`status = setBaseAddress(address);`
120			`if (status == PP_STATE_IDLE) status = negotiateEPP();`
121			`return(status);`
122
123			`}`
124
125
126			`void EppParallelUseWin::closeEPP()`
127			`{`
128			`char data;`
129			`//+2(nc, nc, PCD, IRQE, /SelectIn, init, /autofeed, /strobe)`
130
131
132			`// evento initialization`
133			`data = PortIn(baseAddress+2) & 0xFB \| 0x08; //ninit=0 nselectin=1`
134			`PortOut(baseAddress+2, data);`
135			`udelay(500); // T_ER`
136
137			`// se realiza dos veces por las dudas`
138			`data = PortIn(baseAddress+2) \| 0x04; //ninit=1`
139			`PortOut(baseAddress+2, data);`
140			`udelay(500); // T_ER`
141
142			`status = PP_STATE_IDLE;`
143			`}`
144
145
146
147			`EppParallelUseWin::PPStatusType EppParallelUseWin::setBaseAddress(const short int &address)`
148			`{`
149
150			`if (address == 0x3BC \|\| address == 0x378 \|\| address == 0x278)`
151			`{`
152			`baseAddress = address;`
153			`closeEPP(); // Reinicia interfaz y setea status a PP_STATE_IDLE`
154			`}`
155			`else`
156			`{`
157			`baseAddress = 0;`
158			`status = PP_WRONG_BASE_ADDRESS;`
159			`}`
160			`return(status);`
161			`}`
162
163			`short int EppParallelUseWin::getBaseAddress() {return(baseAddress);}`
164
165
166			`// LECTURA/ESCRITURA DIRECCI�N /////////////////////////////////////////////////////////////////////`
167
168			`void EppParallelUseWin::writeAddress(const char &address)`
169			`{`
170			`if (testStatusForDataTransfer()) PortOut(baseAddress + 3, address);`
171
172			`}`
173
174
175			`//EppParallelUseWin::PPStatusType EppParallelUseWin::writeAddress(const char &address)`
176			`//{`
177			`// if (testStatusForDataTransfer())`
178			`// {`
179			`// prepareTestDataTransfer();`
180			`// PortOut(baseAddress + 3, address);`
181			`// status = testDataTransfer();`
182			`// }`
183			`// return(status);`
184			`//}`
185
186			`void EppParallelUseWin::readAddress(char &return_address)`
187			`{`
188			`if (testStatusForDataTransfer()) return_address = PortIn(baseAddress + 3);`
189			`}`
190
191			`//EppParallelUseWin::PPStatusType EppParallelUseWin::readAddress(char &return_address) const`
192			`//{`
193			`// if (testStatusForDataTransfer())`
194			`// {`
195			`// prepareTestDataTransfer();`
196			`// return_address = PortIn(baseAddress + 3);`
197			`// status = testDataTransfer();`
198			`// }`
199			`// return(status);`
200			`//}`
201
202			`// LECTURA/ESCRITURA BYTE //////////////////////////////////////////////////////////////////////////`
203			`void EppParallelUseWin::writeByte(const char &byte)`
204			`{`
205			`if (testStatusForDataTransfer()) PortOut(baseAddress + 4, byte);`
206			`}`
207
208
209			`void EppParallelUseWin::writeByte(const char &byte, const char &address)`
210			`{`
211			`writeAddress(address);`
212			`if (testStatusForDataTransfer()) PortOut(baseAddress + 4, byte);`
213			`}`
214
215
216			`//EppParallelUseWin::PPStatusType EppParallelUseWin::writeByte(const char &byte) const`
217			`//{`
218			`// if (testStatusForDataTransfer())`
219			`// {`
220			`// prepareTestDataTransfer();`
221			`// PortOut(baseAddress + 4, byte);`
222			`// status = testDataTransfer();`
223			`// }`
224			`// return(status);`
225			`//}`
226			`//`
227			`//`
228			`//EppParallelUseWin::PPStatusType EppParallelUseWin::writeByte(const char &byte, const char &address) const`
229			`//{`
230			`// status = writeAddress(address);`
231			`// if (status == PP_CONECTED)`
232			`// {`
233			`// prepareTestDataTransfer();`
234			`// PortOut(baseAddress + 4, byte);`
235			`// status = testDataTransfer();`
236			`// }`
237			`// return(status);`
238			`//}`
239
240
241			`void EppParallelUseWin::readByte(char &return_byte)`
242			`{`
243			`if (testStatusForDataTransfer()) return_byte = PortIn(baseAddress+4);`
244			`}`
245
246
247			`void EppParallelUseWin::readByte(char &return_byte, const char &address)`
248			`{`
249			`writeAddress(address);`
250			`if (testStatusForDataTransfer()) return_byte = PortIn(baseAddress + 4);`
251			`}`
252
253
254			`//EppParallelUseWin::PPStatusType EppParallelUseWin::readByte(char &return_byte) const`
255			`//{`
256			`// if (testStatusForDataTransfer())`
257			`// {`
258			`// prepareTestDataTransfer();`
259			`// return_byte = PortIn(baseAddress + 4);`
260			`// status = testDataTransfer();`
261			`// }`
262			`// return(status);`
263			`//}`
264			`//`
265			`//`
266			`//EppParallelUseWin::PPStatusType EppParallelUseWin::readByte(char &return_byte, const char &addresss) const`
267			`//{`
268			`// status = writeAddress(address);`
269			`// if (status == PP_CONECTED)`
270			`// {`
271			`// prepareTestDataTransfer();`
272			`// return_byte = PortIn(baseAddress + 4);`
273			`// status = testDataTransfer();`
274			`// }`
275			`// return(status);`
276			`//}`
277
278
279			`// LECTURA/ESCRITURA WORD //////////////////////////////////////////////////////////////////////////`
280			`void EppParallelUseWin::writeWord(const unsigned short int &word)`
281			`{`
282			`if (testStatusForDataTransfer())`
283			`{`
284			`char data;`
285			`data = word & 0x00FF;`
286			`PortOut(baseAddress + 4, data);`
287			`data = (word & 0xFF00) >> 8;`
288			`PortOut(baseAddress + 4, data);`
289			`}`
290			`}`
291
292
293			`void EppParallelUseWin::writeWord(const unsigned short int &word, const char &address)`
294			`{`
295			`writeAddress(address);`
296			`writeWord(word);`
297			`}`
298
299
300			`//EppParallelUseWin::PPStatusType EppParallelUseWin::writeWord(const short int &word) const`
301			`//{`
302			`// if (testStatusForDataTransfer())`
303			`// {`
304			`// prepareTestDataTransfer();`
305			`// char data;`
306			`// data = word & 0xFF;`
307			`// PortOut(baseAddress + 4, data);`
308			`// data = (word & 0xFF00) >> 8;`
309			`// PortOut(baseAddress + 4, data);`
310			`// status = testDataTransfer();`
311			`// }`
312			`// return(status);`
313			`//}`
314			`//`
315			`//`
316			`//EppParallelUseWin::PPStatusType EppParallelUseWin::writeWord(const short int &word, const char &address) const`
317			`//{`
318			`// status = writeAddress(address);`
319			`// if (status == PP_CONECTED)`
320			`// {`
321			`// prepareTestDataTransfer();`
322			`// char data;`
323			`// data = word & 0xFF;`
324			`// PortOut(baseAddress + 4, data);`
325			`// data = (word & 0xFF00) >> 8;`
326			`// PortOut(baseAddress + 4, data);`
327			`// status = testDataTransfer();`
328			`// }`
329			`// return(status);`
330			`//}`
331
332
333			`void EppParallelUseWin::readWord(unsigned int &return_word)`
334			`{`
335			`if (testStatusForDataTransfer())`
336			`{`
337			`unsigned int data;`
338
339			`data = PortIn(baseAddress + 4) & 0x00FF;`
340			`data = (PortIn(baseAddress + 4) << 8) \| data;`
341			`// udelay(600);`
342			`return_word = data & 0xFFFF;`
343			`}`
344			`}`
345
346
347			`void EppParallelUseWin::readWord(unsigned int &return_word, const char &address)`
348			`{`
349			`writeAddress(address);`
350			`readWord(return_word);`
351			`}`
352
353
354			`//EppParallelUseWin::PPStatusType EppParallelUseWin::readWord(short int &return_word) const`
355			`//{`
356			`// if (testStatusForDataTransfer())`
357			`// {`
358			`// prepareTestDataTransfer();`
359			`// short int data;`
360			`// data = PortIn(baseAddress + 4);`
361			`// data = PortIn(baseAddress + 4) << 8 \| data;`
362			`// return_word = data;`
363			`// status = testDataTransfer();`
364			`// }`
365			`// return(status);`
366			`//}`
367			`//`
368			`//`
369			`//EppParallelUseWin::PPStatusType EppParallelUseWin::readWord(short int &return_word, const char &address) const`
370			`//{`
371			`// status = writeAddress(address);`
372			`// if (status == PP_CONECTED)`
373			`// {`
374			`// prepareTestDataTransfer();`
375			`// short int data;`
376			`// data = PortIn(baseAddress + 4);`
377			`// data = PortIn(baseAddress + 4) << 8 \| data;`
378			`// return_word = data;`
379			`// status = testDataTransfer();`
380			`// }`
381			`// return(status);`
382			`//}`
383
384
385			`// LECTURA DE ESTADO DE CONEXI�N ///////////////////////////////////////////////////////////////////`
386			`EppParallelUseWin::PPStatusType EppParallelUseWin::getStatus() {return(status);}`
387
388
389			`// FUNCIONES PRIVADAS //////////////////////////////////////////////////////////////////////////////`
390			`EppParallelUseWin::PPStatusType EppParallelUseWin::loadDLL()`
391			`{`
392			`int result;`
393
394			`LoadIODLL();`
395			`result = IsDriverInstalled(); // Funcion de testeo`
396			`if (result == 0) {`
397			`LoadIODLL(); // Segundo intento, corrige errores en Windows Vista`
398			`result = IsDriverInstalled();`
399			`if (result == 0) return(PP_LOAD_LIBRARY_FAIL);`
400			`else return(PP_STATE_IDLE);`
401			`}`
402			`else return(PP_STATE_IDLE);`
403			`}`
404
405
406			`bool EppParallelUseWin::testStatusForDataTransfer()`
407			`{`
408			`switch(status)`
409			`{`
410			`case PP_CONECTED:`
411			`/* case PP_RA_TIME_OUT:`
412			`case PP_WA_TIME_OUT:`
413			`case PP_RB_TIME_OUT:`
414			`case PP_WB_TIME_OUT:`
415			`case PP_RW_TIME_OUT:`
416			`case PP_WW_TIME_OUT:*/`
417			`case PP_TIME_OUT:`
418			`return(1);`
419			`break;`
420			`default:`
421			`return(0);`
422			`break;`
423			`}`
424			`}`
425
426
427			`void EppParallelUseWin::prepareTestDataTransfer()`
428			`{`
429			`char data; // temporal`
430			`data = PortIn(baseAddress + 1) & 0xFE ; //EPP timeout = 0`
431			`PortOut(baseAddress + 1, data);`
432			`}`
433
434
435			`EppParallelUseWin::PPStatusType EppParallelUseWin::testDataTransfer()`
436			`{`
437			`char data;`
438			`//udelay(50);`
439			`data = PortIn(baseAddress + 1) & 0x01 ; // leer EPP timeout`
440			`prepareTestDataTransfer();`
441			`switch (data)`
442			`{`
443			`case 0:`
444			`return(PP_CONECTED);`
445			`break;`
446			`default:`
447			`return(PP_TIME_OUT);`
448			`break;`
449			`}`
450			`}`