¿interfaz por puerto paralelo en MSDOS? SI, SE PUEDE!

¿Os habeis fijado, que en las fotos del tutorial que ha posteado leo, aparece el "Zunchadores mega arcade" de Macarro? je je.

Edito: Macarro, has respondido mientras yo escribía, jeje

AJAJAJAAAA ¿Tú eres Macarro Martín?

Yo es que flipo... Spain is different y aquí queremos reinventar todos la rueda. Con lo fácil que sería enlazar a marcianitos...

Originalmente publicado por Paul Sernine

¿Os habeis fijado, que en las fotos del tutorial que ha posteado leo, aparece el "Zunchadores mega arcade" de Macarro? je je.

Edito: Macarro, has respondido mientras yo escribía, jeje

Perdon pero yo no lo cree al tutorial, solo lo encontre navegando y puse el link por si era de interes, no sabia que era de alguien de esta comunidad y le copiaron las imagenes para posearlo en dicha pagina, disculpas si hubo un malentendido.

oye manofwar.. no pillo el link para bajarlo y probarlo, ande para ?
estoyyy perdioooo y esta noche despedia de soltero.. (pobre ingenuo jajaa)

No, si a mi no me molesta para nada, al contrario, me alegra.

Mi pequeña crítica no era hacia ti, sino a ese sitio. Desde luego, veo bien cualquier iniciativa creadora, sin embargo creo que en internet, y en especialmente españoles y latinoamericanos, somos muy dados a estar reinventando la rueda constantemente. Y de ese modo se "pierde" mucho trabajo.

Aunque por otro lado, es lo que a mi me gustaría hacer con marcianitos, convertirla en el portal de emulación en español por excelencia

ManofWar, aunque veo que vas empezando te pongo mi idea de la implementación del driver a ver que te parece

Array (dinámico?) DATA para guardar los valores del LPT, sería algo como:

int Data[12]
        1 (10)  |  2 (11)  |  3 (12)  | 4 (13)  | 5 (15)   |
(2)  1   0      |    1    |    0     |    1   |    1    |   <=== 1
(3)  2   0      |    0    |    1     |    0   |    1    |   <=== 1
(4)  3   0      |    0    |    0     |    0   |    0    |   <=== 1
(5)  4 ....
(6)  5 ....
(7)  6 ....
(8)  7 ....
(9)  8 ....
(1)  9   0      |    0    |    1     |    1   |    1    |   <=== 1
(14) 10   0      |    0    |    0     |    0   |    1    |   <=== 1
(16) 11   1      |    0    |    0     |    0   |    0    |   <=== 1
(17) 12   1      |    0    |    1     |    0   |    1    |   <=== 1

La idea inicial es solo enviar señal ( <=== 1 ) a las ramas que el usuario haya configurado, de esa forma nos evitamos enviar y comprobar zonas innecesarias. Eso sí como un solo botón este configurado en cualquier rama ya habría que enviar la señal a todas.

En el ejemplo del data, las lineas 8 y 9 no se comprueban ni se mandan señales, sin embargo en la 17 imagenemos que hemos puesto un boton de pinball que no nos cabía en la rama 16 entonces tendremos que enviar la señal a toda la rama, aun cuando solo necesitamos comprobar si se ha pulsado algo en la posición 17-1 del LPT.

Para saber las ramas que el usuario necesita tengo una variable llamada ramas que contendría algo como:

int ramas [ 1, 2, 3, 9, 10, 11, 12 ]

Por último tengo una estructura llamada USERDATA que guarda el dispositivo (esto en msdos sobrará), el boton que representa (o tecla en tu caso) y la posición de su estado en el array DATA. Queda algo como:

userdata
[  dev  ]  [  boton  ] [ dpos ]
  Joy1       BTN_15      23

Finalmente con una funcion llamada sendButton le paso el userdata y envia la pulsación...

Bueno esta es más o menos la idea, ya me comentas compa

Un Saludo!

Hola D_Skywalk

Justamente todo lo que propones es como lo he hecho, excepto la parte de no comprobar rama, ya que el código para ver si esa rama debía comprobarla o no era más largo (lento) que directamente comprobar si la rama a cambiado. Por lo que me he decantado por esto último, compruebo si ha cambiado algo en la rama (XOR Estado, Estado_Anterior); si no hay cambio me voy a la siguiente rama o si ha cambiado compruebo pin a pin.

Saludos

Tio, tenemos que hablar por MSN o Jabber, vamos a terminar antes , pasame el tuyo por mensaje o algo xd

Por lo que he entendido compruebas pin a pin si hay cambio, pero tio eso es muy pesado (creo yo), en mi opinión es mucho más rápido simplemente enviar señales por los ramales que el usuario está usando y enviar pulsado si está en uso...

Ej:

for ( nSignal = 0; nSignal < RAMA_MAX_CONFIGURADA; nSignal ++ )
{
     sendsignal(rama[nSignal],&data[nSignal]); //data será modificado con los valores actuales.
     for(nCheck=0; nCheck < 5; nCheck ++ )
     {
         if( data[nSignal][nCheck] == PULSADO_CONFIGURADO )
             sendButton(userdata[nSignal][nCheck]);
     }
}

RAMA_MAX_CONFIGURADA, son las ramas totales que se usan y PULSADO_CONFIGURADO, serían cuando se supone que un boton estaría pulsado ¿cuando sea 0 o 1?

Un Saludo y a ver que te parece, de todas formas por msn seguro que charlamos más activamente y nos enteramos cada uno de la idea del otro mejor xD

[Update]
Añado una posible implementación de la función sendButton, por si se entiende mejor, aunque estoy programando a cabeza, habrá cosas mejorables, sure xD

void sendButton (userdata * buttonInfo){
 osSendButton(buttonInfo->dev, buttonInfo->boton)
 //imagina que esa función existiera, es solo un ejemplo de como se usaria esa estructura :)
}

Entonces por lo que leo lo estas haciendo bit a bit? o con arrays? yo en principio me decanto por array por que es más legible, pero creo que tu idea es mirar bit a bit :?

Pega algo de tu code, que me entere io :b

Nos leemos

Hola D_Skywalk

El procedimiento que utilizao para comprobar si se ha pulsado un botón o no es el siguiente:

- En principio todos los pines de Datos y Control están a 1.
- Pongo a 0 el pin de la rama a comprobar
- Si ha cambiado algún pin del Estado desde la última vez que se interrogó (XOR Estado, Estado_anterior) entonces es cuando se mira pin a pin los 5 bits del byte de Estado.

Aquí te pongo la parte de código que hace esto, espero que se entiendan los comentarios.

Saludos

LeePuertoP proc
                MOV     pb cs:[Fila], 0
                MOV     pw cs:[Puerto_Fila], 0FFEh;Cargamos el valor para interrogar la primera fila
                LEA     BX, Offset_Estados
                MOV     pw cs:[Estados_ant], BX
                LEA     BX, ConfBoton;            ;Ponemos en BX el inicio de la configuración de teclas
                MOV     pw cs:[Mapa],BX
BucleFila:      MOV     AX, pw cs:[Puerto_Fila] ;Cargamos AX con la fila que vamos a interrogar
                MOV     DX, 378h       		;pasamos a datos el valor de la fila que 
                OUT     DX, AL                  ;vamos a interrogar
                MOV     DX, 37Ah                ;pasamos a control el valor de la fila que vamos a interrogar 
                XOR     AH, 00001011b		;invertimos los bits necesarios
                XCHG    AH,AL
                OUT     DX, AL                  ;
		MOV 	DX, 379h		;Leemos el estado de los 
		IN  	AL, DX			;botones conectados
                XOR     AL, 10000000b   	;Invertimos el bit 7 al registro de estado
                OR      AL, 00000111b   	;Ponemos a 1 los bits que no utilizamos(algunos pc los ponen a 1 y otros a 0)
                MOV     pb cs:[estado], AL      ;Guardamos el estado del puerto paralelo
                MOV     BX, pw cs:[Estados_ant] ;Cargamos el estado anterior de la fila actual
                XOR     AL, pb cs:[BX]    	;Comprobamos si ha cambiado alguna columna
                JZ      FinBucleFila            ;Si no ha habido cambios comprobamos la siguiente fila
                        MOV     pb cs:[cambios], AL		;Si hay cambios los guardamos para comprobar que pines (botones) han cambiado
                        MOV     pb cs:[Puerto_Columna],8       	;Cargamos el valor para interrogar la primera columna 
                        MOV     BX, pw cs:[Mapa]                ;Ponemos en BX el inicio del mapa de teclas
        BucleColumna:   MOV     AL, pb cs:[cambios]
                        TEST    AL, pb cs:[Puerto_Columna]      ;Comprobamos si ha cambiado esta columna (botón)
                        JZ      FinBucleColumna         	;Si no ha cambiado saltamos a la siguiente columna (botón)
                                mov  al, pb cs:[MODO]
                                CMP  al, 1
                                JNE      comp_estad
                                SUB     BX,offset ConfBoton
                                MOV    EDITADO, BL
                                RET                     ;BX-offset ConfBoton=Boton
                 comp_estad:    MOV     AL, pb cs:[estado]
                                TEST    AL, pb cs:[Puerto_Columna]	;Comprobamos si ha sido pulsado
                                MOV     AL, pb cs:[BX]			;o soltado el botón
                                JZ      pulsada
                                ADD     AL, 128
                 pulsada:       CALL    TeclaPS2
       FinBucleColumna: SHL     pb cs:[Puerto_Columna], 1       ;Desplazamos la variable para más tarde
                                                       	 	;interrogar la siguiente columna
                        INC     BX                     		;Nos posicionamos al principio del scancode del próximo botón
                        CMP     pb cs:[Puerto_Columna],0	;Vemos si hemos comprobado todas las columnas
                        JNZ     BucleColumna
FinBucleFila:   SHL     pw cs:[Puerto_Fila], 1  ;Desplazamos la variable para más
                OR      pw cs:[Puerto_Fila], 1  ;tarde interrogar la siguiente fila
		MOV     AL, pb cs:[estado]	;Guardamos el valor actual
                MOV     BX, pw cs:[Estados_Ant]	;del estado del puerto
                MOV     pb cs:[BX], AL		;para comprobar la próxima vez
                add     pw cs:[Mapa], 5		;Nos posicionamos en la siguiente fila (ScanCode)
                inc     pb cs:[Estados_ant]	;Nos posicionamos en la siguiente fila (Estados)
                INC     byte ptr cs:[Fila]
                cmp     byte ptr cs:[Fila], 12
                JNZ     SaltaBucleFila;
                JMP     Salir
SaltaBucleFila: JMP     BucleFila
Salir: 		RET