Este foro usa cookies
Este foro utiliza cookies para almacenar su información de inicio de sesión si está registrado y su última visita si no lo está. Las cookies son pequeños documentos de texto almacenados en su computadora; las cookies establecidas por este foro solo se pueden usar en este sitio web y no representan ningún riesgo de seguridad. Las cookies en este foro también rastrean los temas específicos que ha leído y la última vez que los leyó. Si Ud. continúa navegando, entenderemos que acepta todas las cookies.

Se almacenará una cookie en su navegador, independientemente de la elección, para evitar que se le vuelva a hacer esta pregunta. Podrá cambiar la configuración de sus cookies en cualquier momento utilizando el enlace en el pie de página.

El foro antiguo se encuentra accesible desde https://foro.gambas-es.org en modo de solo lectura.

Calificación:
  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5

Puerto Paralelo y Gambas3 + USB
#1

Hola: Hace casi un año que estuve realizando algunos programas en Gambas3 sobre Ubuntu 18.xx para controlar algunos de mis diseños con Microcontroladores PIC a traves del Puerto Paralelo. (Esto le vengo haciendo en Windows, sin problemas desde hace años). En Ubuntu y Gambas se me ha complicado demasiado. Dejé de usar las instrucciones convencionales de hPort = Open "/dev/parport0"...bla bla bla y en su lugar busqué otro método. Encontré lo siguiente:

Buscando en la WEB, encontré que ioport es requerido para ganar control del o los puertos paralelo de la PC, por lo que lo instalé con:

sudo apt-get install ioport

Una vez instalado, se prueba con el siguiente comando:

sudo outb --hex 0x378 0x32

Por supuesto, hay que tener un cable conectado al puerto paralelo de la PC y un proto-board donde se hayan conectado 8 leds a los pines D0-D7, y GND, con lo que se podrá ver el resultado en los leds encendidos y los apagados.

En Gambas3 se debe hacer uso de la instrucción Exec de la siguiente manera:

Dim Proc as Procces
-
Proc = Exec ["outb", "--hex", "0x378", "0x32"] For Output


Si se requiere enviar una variable al Puerto Paralelo, hacer los siguiente:

Dim Proc as Procces
-
variable = &h32
Proc = Exec ["outb", "--hex", "0x378", variable] For Output

donde variable se escribe sin comillas.

Como se requieren permisos para ejecutar la instrucción outb, Gambas3 debe ejecutarse con permisos de root.

Espero que esto les sea de utilidad a quienes siguen usando el Puerto Paralelo.....Saludos.
#2

Hola y gracias por el aporte.

Mi duda es cuánta gente sigue usando el puerto paralelo. De hecho las PC modernas ya no lo incorporan, al menos físicamente en sus placas madre, de manera que si necesitamos disponer de uno, hemos de comprar una placa PCI o PCIe que lo provea.

Pero la mayoría de los microcontroladores hoy en día se programan vía USB/RS-232 y el Parallel Port sigue en su camino de extinción aunque aún se siga utilizando en máquinas y desarrollos más o menos antiguos o quizás en aplicaciones más industriales.

Saludos y bienvenido

Por favor, usa el corrector ortográfico antes de pulsar el botón 'Enviar'
#3

Hola:

Yo me muevo en el ámbito de las radiocomunicaciones y la electrónica de control Efectivamente aún se utiliza mucho el Puerto Serial (no el paralelo) para programar equipos de radiocomunicación como Kenwood y Motorola. Así que debemos seguir conservando en buen estado nuestras antiguas PCs, que tienen puertos serie y paralelo.

Como mi hobby es la electrónica pura y dura, me gusta mucho la experimentación RETRO, es decir, rescatar componentes electrónicos de algunos aparatos inservibles y hacerlos funcionar, programando en VB o Gambas. Por ejemplo:

- Display inteligente (con Chip PT6959) de un dañado reproductor de DVD/CD, el cual puede ser "resucitado" bajo programación y conectado al puerto paralelo, hacer que muestra textos, la hora de la PC, el contenido de un archivo de texto que pasa con scroll.

- Tarjeta de sonido de una vieja máquina de juegos Road Riot, conteniendo un sintetizador YM2151 y RAM y ROM de aquellas épocas, que he "resucitado" y bajo programación en VB y Gambas he logrado reproducir todos sus sonidos con diferentes comandos que yo mismo me he inventado, usando el puerto paralelo, y también el serial rs-232....

- Un diseño de DMX-512 en VB y tarjeta que yo he diseñado y fabricado, para controla Luces y Motores, usando como siempre el puerto serial, bajo los mismo principios que el estándar original DMX....

Por supuesto que he realizado varios proyectos con USB/RS232 y otros mas con USB/HID, sobre windows. Pero cuando quiero hacer lo mismo en Gambas3 con Linux, ahí tengo por ahora una barrera.

Pregunta: ¿Tiene Gambas3 un componente para manejar USB?....quizá en gb.net?...

Saludos...

PD...Como ya soy un viejo de 62 años, me he quedado un poco en las tecnologías del pasado, pero estoy descubriendo lo nuevo, y estoy practicando, bajo el mismo tenor de las IoT, con java, javascript, python, C++, VB.net, Gambas, y lo que me encuentre por ahí....Saludos
#4

Hola de nuevo, Alfredo.

Me encanta conversar con "compañeros" de viaje del mundo de la electrónica y la radiocomunicación. Estudié electrónica de joven y he sido radioaficionado desde muy joven también, aunque ahora mismo no estoy activo en radio desde hace unos años. Me gusta mucho el cacharreo y ojalá tuviera más tiempo para dedicarme a ello.

En cuanto al manejo del puerto USB en linux, es muy sencillo. En Linux todo, repito, TODO (incluso el hardware) es un fichero. Es decir, que se puede acceder a casi cualquier cosa mediante la ruta al fichero o al fichero que representa un dispositivo de hardware. Así que para acceder a cualquier puerto, tendremos que la ruta podría ser más o menos así: /dev/ttyS0, donde /dev es el directorio que contiene los dispositivos de hardware y ttyS0 en este caso es el primer puerto rs232 existente. Algo así como el COM1 en windows. ttyS1, ttyS2, etc para los siguientes. Del mismo modo, /dev/ttyUSB0 sería la ruta para leer/escribir en un puerto usb y también de la misma manera se podrían usar los números correlativos dependiendo de qué puerto esté en uso.

Dos comandos importantes para saber qué puerto USB está en uso son los siguientes:

dmesg -  lista el buffer de mensajes del kernel y son visibles eventos de hardware como introducción o expulsión de un dispositivo USB
lsusb   -  lista los dispositivos conectados al bus correspondiente

A nivel informativo, estas herramientas son útiles para determinar si un dispositivo está físicamente conectado al sistema.

En cuanto a la lectura y escritura en los dispositivos, linux (y Gambas) los trata por igual, como un stream de datos (bits). Por lo tanto, se pueden leer y enviar datos usando funciones nativas de gambas de una forma muy sencilla y transparente para el programador, ya que es muy similar a abrir un fichero, leer o escribir y cerrarlo al finalizar.

He encontrado un ejemplo sencillo para ilustrar el concepto, sirve tanto para rs232 como para usb:

https://fossies.org/linux/gambas/app/exa...232.module


Y supongo que esto podría servir también para el puerto paralelo, aunque nunca lo he probado. Aquí hay algo más de información al respecto (en inglés):

http://gambaswiki.org/wiki/howto/parport?l=es

Espero que sirva de ayuda, si necesitas algo más concreto, puedes abrir un hilo específico en la sección correspondiente y trataremos de ayudarte.

Saludos

Por favor, usa el corrector ortográfico antes de pulsar el botón 'Enviar'
#5

JGuardon, muchas gracias por la información sobre el USB. Ya estoy preparando algún proyecto donde pueda aplicarlo. Tengo una placa que diseñé y armé con un sintetizador YM2203 y uso un PIC 18F2550, así que con ese prototipo que hoy funciona bajo VB en Windows, haré lo correspondiente en Linux (Ubuntu 18.04) y Gambas3....ya pondré los resultados....Saludos y feliz Noche Buena 2020.
#6

(24-12-2020, 05:07)AlfredoSC escribió:  JGuardon, muchas gracias por la información sobre el USB. Ya estoy preparando algún proyecto donde pueda aplicarlo. Tengo una placa que diseñé y armé con un sintetizador YM2203 y uso un PIC 18F2550, así que con ese prototipo que hoy funciona bajo VB en Windows, haré lo correspondiente en Linux (Ubuntu 18.04) y Gambas3....ya pondré los resultados....Saludos y feliz Noche Buena 2020.

Igualmente, felices fiestas Alfredo

Sólo un apunte más. Por norma general, el acceso a los dispositivos del sistema requiere permisos de root, como bien dijiste en tu primer post. En tal caso el programa que utilice los puertos serie o USB requeriría de dichos permisos, usando 'sudo' o cambiando al usuario root. Pero hay una forma de evitar que nuestros programas tengan que escalar privilegios, ya que supone un riesgo importante de seguridad y es la siguiente:

Necesitamos añadir nuestro usuario normal al grupo 'dialout' mediante este comando: 
 
Código:
sudo usermod -a -G dialout "$USER"

donde la variable $USER es sustituida automáticamente por nuestro nombre de usuario actual en la consola. El grupo dialout tiene privilegios para usar los puertos físicos de nuestra máquina, no siendo necesario recurrir al escalado de privilegios mediante sudo. En algunos casos es necesario desinstalar modemmanager y en todo caso, es necesario reiniciar la sesión o el PC para que el comando anterior haga efecto.
 
Código:
sudo apt remove modemmanager 


De esta forma ya no es necesario el uso de sudo para acceder a los puertos del sistema. 

Saludos

Por favor, usa el corrector ortográfico antes de pulsar el botón 'Enviar'
#7

Gracias a todas tus recomendaciones, seguí con mi proyecto usando el USB en Ubuntu 18.04, para lo cual ya había elaborado un prototipo usando un PIC18f13k50 para recoger los valores de 3 sensores (Temperatura, Voltaje y Cantidad de Luz ambiental) y enviar esta información por USB a un programa en VB6 en Win2. Pero ahora lo he logrado hacer en Linux.

Bien, habiendo realizado un 90% del proyecto, estoy anexando: Un listado del programa en Cpp del proyecto PIC18f13k50, Un listado del Programa en GAMBAS3, un pantallazo del IDE en Linux.

[img]/home/usuario/Documentos/Usb_TempVolt/Captura de pantalla de 2020-12-28 11-09-16.png[/img]

 
C
  1. /* Programa con el 18f13k50 que se utiliza como sensor de intensidad de luz, temperatura y voltaje,
  2. a traves de dos entradas analógicas, enviando la información por USB a una PC o Laptop,
  3. desde donde se podrá consultar dichos valores a petición de un usuario o de manera periodica
  4. en forma automática. Se usa un LED blanco, como sensor de luz, ya que este dispositivo,
  5. cuando es iluminado presenta en sus terminales un voltaje, proporcional a la intensidad de la luz incidente. 
  6. Se pone un botón en rc5 para enviar desde el PIC18 hacia la PC la información delos sensores.
  7. (El modo de envío automático se deshabilita). En la aplicación de VB6 se coloca un botón para solicitar
  8. datos al PIC18, enviando un valor numérico en el packet el cual debe ser reconocido por el PIC18. 
  9. VendorID = 6019, ProductID = 2003 Alfredo Segura, Queretaro, Mexico, noviembre de 2020.*/ 
  10.  
  11. #include <18F13k50.h>
  12. #fuses HS,NOWDT,NOPROTECT,NOCPB,NOLVP,NODEBUG,MCLR,CPUDIV1,PLLEN,USBDIV1,NOIESO,PUT
  13. #use delay(clock = 48000000) 
  14. //utiliza un XTAL de 12 MHz, para que con PLL arroje 48MHz 
  15. #define USB_HID_DEVICE  TRUE    // Deshabilitamos el uso de las directivas HID
  16. #define USB_EP1_TX_ENABLE  USB_ENABLE_BULK    // Activa EP1(EndPoint1) para las transferencias IN Bulk/Interrupt
  17. #define USB_EP1_RX_ENABLE  USB_ENABLE_BULK    // Activa EP1(EndPoint1) para las transferencias OUT Bulk/Interrupt
  18. #define USB_EP1_TX_SIZE 8                  // Tamaño reservado para el Buffer Tx EndPoint1
  19. #define USB_EP1_RX_SIZE 8                  // Tamaño reservado para el Buffer Rx EndPoint1 
  20. #include <pic18_usb.h>
  21. #include <hid_analog2.c>                 // Configuración del USB y los descriptores para este dispositivo
  22. #include <usb.c>                           // Handles usb ,tokens y descriptores 
  23. // Se declara el nombre a cada uno de los 8 elemento del vector recibe[8]   
  24. #define  dato0 recibe[0]                                  
  25. #define  dato1 recibe[1]                                   
  26. #define  dato2 recibe[2]                                  
  27. #define  dato3 recibe[3]
  28. #define  dato4 recibe[4]
  29. #define  dato5 recibe[5]
  30. #define  dato6 recibe[6]
  31. #define  dato7 recibe[7] 
  32. // Se declara el nombre a cada uno de los 8 elemento del vector envia[8], enviar_n   
  33. #define  enviar_0 envia[0]                                    
  34. #define  enviar_1 envia[1]                                   
  35. #define  enviar_2 envia[2]                         
  36. #define  enviar_3 envia[3]                                  
  37. #define  enviar_4 envia[4]
  38. #define  enviar_5 envia[5]
  39. #define  enviar_6 envia[6]
  40. #define  enviar_7 envia[7] 
  41. #use fast_io(A)          // LATA=0xF89  PORTA=0xF80, 5 I/O pins
  42. #use fast_io(B)            // LATB=0xF8A  PORTB=0xF81, 4 I/O pins
  43. #use fast_io(C)            // LATC=0xF8B  PORTC=0xF82, 8 I/O pins 
  44. #byte ptoa = 0xf80#byte ptob = 0xf81
  45. #byte ptoc = 0xf82 
  46. #byte lata = 0xf89
  47. #byte latb = 0xf8a
  48. #byte latc = 0xf8b 
  49. #bit ra0 = 0xf89.0         // D+ de USB
  50. #bit ra1 = 0xf89.1         // D- de USB                           
  51. // ra3 es MCLR                           
  52. // ra4 y ra5 XTAL 12MHz
  53. #bit rb6 = 0xf8a.6         // rb6 salida LED de conexión establecida
  54. #bit rb7 = 0xf8a.7         // rb7 salida LED de actividad 
  55. #bit rc3 = 0xf82.3         // Sensor Luz con LED Blanco
  56. #bit rc5 = 0xf82.5         // Botón para iniciar envío de datos a una PC
  57. #bit rc6 = 0xf82.6         // Sensor Voltaje#bit rc7 = 0xf82.7         
  58. // Sensor Temperatura  int8 recibe[8];           
  59. // Declaramos la variable recibe de 8 bytes
  60. //int info0 = 0, info1, info2, info3, info4, info5, info6, info7;
  61. int8 envia[8];             // Declaramos la variable envia de 8 bytes
  62. int info[8] = {0,0,0,0,0,0,0,0};
  63. int i, j, volts = 0, tempe = 0, luz = 0;
  64. int volts_ant, tempe_ant, luz_ant;
  65. int1 flag = 0, flag2 = 0;long k = 0; 
  66. #int_timer0void actividad(void) {
  67. i++;
  68. k++;
  69. if (i >= 190) {
  70. rb7++;                     // LED de actividadi = 0;
  71. } 
  72. if (k >= 1500) {
  73. flag2 = 1;
  74. k = 0;
  75. } 
  76. set_timer0(0);
  77.  
  78. } 
  79. void ini(void) {
  80. enable_interrupts(global);
  81. disable_interrupts(int_timer0);
  82. setup_timer_0(t0_internal | t0_div_1); 
  83. setup_adc(adc_clock_internal);
  84. setup_adc_ports(sAN7 |sAN8 | sAN9 | vss_vdd); 
  85. set_tris_a(0b11101111);       // XTAL, D+, D-, MCLRset_tris_b(0b00001111);       
  86. // rb6 Enumerado, rb7 LED de actividadset_tris_c(0b11101000);       
  87. // rc3, rc6 y rc7 entradas analogicas. 
  88. usb_init();                  // Inicializa USB
  89. delay_ms(100);
  90. ptoa = 0x00, ptob = 0x00, ptoc = 0xbf;
  91. set_timer0(0);
  92. } 
  93.  
  94. void main(void) {
  95. ini();
  96. delay_ms(100); 
  97. usb_task();                  ///habilita USB
  98. usb_wait_for_enumeration();  ///Espera hasta que la PC reconozca este dispositivo
  99. rb6 = 1;
  100. enable_interrupts(int_timer0); 
  101. while(true) { 
  102. if(usb_kbhit(1)) {            // Se reciben dati[0,2,4,6,8,10,12] de una sola vez
  103. usb_get_packet(1, recibe, 8);
  104. info[0] = dato0;
  105. info[1] = dato1;
  106. info[2] = dato2;
  107. info[3] = dato3;
  108. info[4] = dato4;
  109. info[5] = dato5;
  110. info[6] = dato6;
  111. info[7] = dato7;
  112. delay_us(10);
  113. flag = 1;
  114. } 
  115. if (flag == 1) {                // Se ha recibido un MSG USB válido
  116. if (info[2] == 49) {            // Verificar si infa[2] == 49, indica petición de informe
  117. flag = 0;
  118. goto DISPARO;
  119. }flag = 0;
  120. } 
  121. if (rc5 == 0) {
  122. DISPARO:set_adc_channel(7);             // Prepara AN8 para leer Votaje
  123. luz = read_adc();
  124. delay_us(50);
  125. set_adc_channel(8);             // Prepara AN8 para leer Votaje
  126. volts = read_adc();
  127. delay_us(50);
  128. set_adc_channel(9);             // Prepara AN9 para leer Temperatura
  129. tempe = read_adc();
  130. delay_us(50); 
  131. enviar_0 = 255;
  132. enviar_1 = volts;
  133. enviar_2 = 255;
  134. enviar_3 = Tempe;
  135. enviar_4 = 255;
  136. enviar_5 = luz;
  137. enviar_6 = 255;
  138. enviar_7 = 255;
  139. //usb_put_packet(int8 endpoint, int8 * ptr, unsigned int16 len, USB_DTS_BIT tgl)
  140. usb_put_packet(1, envia, 8, usb_dts_toggle); 
  141. do {
  142. delay_us(50);
  143. j++;
  144. } while (rc5 == 0);
  145. } 
  146. if (flag2 == 1) {             // Monitorea sensores en forma automática
  147. set_adc_channel(7);             // Prepara AN8 para leer Votaje
  148. luz = read_adc();
  149. delay_us(50);
  150. set_adc_channel(8);             // Prepara AN8 para leer Votaje
  151. volts = read_adc();
  152. delay_us(50);
  153. set_adc_channel(9);             // Prepara AN9 para leer Temperatura
  154. tempe = read_adc();
  155. delay_us(50); 
  156. if (luz != luz_ant) {
  157. luz_ant = luz;
  158. flag2 = 0;
  159. goto DISPARO;
  160. } 
  161. if (volts != volts_ant) {
  162. volts_ant = volts;
  163. flag2 = 0;
  164. goto DISPARO;
  165. } 
  166. if (tempe != tempe_ant) {
  167. tempe_ant = tempe;
  168. flag2 = 0;
  169. goto DISPARO;
  170. }flag2 = 0;
  171. } delay_us(100);
  172. }
  173. } 


 


GAMBAS
  1.  
  2. ' Gambas class file
  3.  
  4. Public Const VendorID As Integer = 6019           '0x1783
  5. Public Const ProductID As Integer = 2003          '0x07D3
  6. Public BufferOut As New Integer[32]
  7. Public BufferIn As New Integer[32]
  8. Public usb_Bit As New Integer[32]
  9. Public usb_B0 As Short
  10. Public usb_B1 As Short
  11. Public usb_B2 As Short
  12. Public usb_B3 As Short
  13. Public usb_B4 As Short
  14. Public usb_B5 As Short
  15. Public usb_B6 As Short
  16. Public usb_B7 As Short
  17. Public usb_B8 As Short
  18. Public usb_B9 As Short
  19. Public usb_B10 As Short
  20. Public usb_B11 As Short
  21. Public usb_B12 As Short
  22. Public usb_B13 As Short
  23. Public usb_B14 As Short
  24. Public usb_B15 As Short
  25. Public usb_B16 As Short
  26. Public usb_B17 As Short
  27. Public usb_B18 As Short
  28. Public usb_B19 As Short
  29. Public usb_B20 As Short
  30. Public usb_B21 As Short
  31. Public usb_B22 As Short
  32. Public usb_B23 As Short
  33. Public usb_B24 As Short
  34. Public usb_B25 As Short
  35. Public usb_B26 As Short
  36. Public usb_B27 As Short
  37. Public usb_B28 As Short
  38. Public usb_B29 As Short
  39. Public usb_B30 As Short
  40. Public usb_B31 As Short
  41.  
  42. Public puerto_usb As String
  43. Public usb_insertado As Process
  44.  
  45.  
  46.  
  47. Public Sub cmdMonitor_Click()
  48.  
  49. For N = 0 To 31
  50. BufferOut[N] = 255
  51.  
  52. BufferOut[0] = 0
  53. BufferOut[3] = 49               ' este es el Disparador para pedir datos al PIC18
  54.  
  55. WriteSomeData()
  56.  
  57.  
  58. Public Sub Form_Open()
  59. 'On Error Resume Next
  60. ' no quitar!
  61. 'ConnectToHID (Me.hwnd)
  62. txtConectar.Text = "No"
  63. cmdConectar.Enabled = True
  64. Timer1.Enabled = True
  65. Timer1.Delay = 1000
  66. Me.Left = 1200
  67. Me.Top = 100
  68.  
  69.  
  70. Public Sub cmdConectar_Click()
  71.  
  72. lblvid.Text = VendorID
  73. lblPid.Text = ProductID
  74. txtConectar.Text = "SI"
  75. cmdConectar.Enabled = False
  76. puerto_usb = txtPuertoS.Text
  77. Try usb_insertado = Exec ["cat", puerto_usb] For Read Write As "Display"
  78.  
  79.  
  80. Public Sub Form_Close()
  81.  
  82. lblVid.Text = "NO VID"
  83. lblPid.Text = "NO PID"
  84.  
  85.  
  86.  
  87. Public Sub Display_Read()
  88.  
  89. txtDatos.Text = ""
  90.  
  91. ' El primer byte es el ID del reporte, ej. BufferIn(0)
  92. ' los demás bytes son los datos del microcontrolador
  93. ' Los valores se reciben en DECIMAL
  94.  
  95. ' Leer los nuevos datos del Display
  96. Read #usb_insertado, usb_B0
  97. Read #usb_insertado, usb_B1
  98. Read #usb_insertado, usb_B2
  99. Read #usb_insertado, usb_B3
  100. Read #usb_insertado, usb_B4
  101. Read #usb_insertado, usb_B5
  102. Read #usb_insertado, usb_B6
  103. Read #usb_insertado, usb_B7
  104. Read #usb_insertado, usb_B8
  105. Read #usb_insertado, usb_B9
  106. Read #usb_insertado, usb_B10
  107. Read #usb_insertado, usb_B11
  108. Read #usb_insertado, usb_B12
  109. Read #usb_insertado, usb_B13
  110. Read #usb_insertado, usb_B14
  111. Read #usb_insertado, usb_B15
  112. Read #usb_insertado, usb_B16
  113. Read #usb_insertado, usb_B17
  114. Read #usb_insertado, usb_B18
  115. Read #usb_insertado, usb_B19
  116. Read #usb_insertado, usb_B20
  117. Read #usb_insertado, usb_B21
  118. Read #usb_insertado, usb_B22
  119. Read #usb_insertado, usb_B23
  120. Read #usb_insertado, usb_B24
  121. Read #usb_insertado, usb_B25
  122. Read #usb_insertado, usb_B26
  123. Read #usb_insertado, usb_B27
  124. Read #usb_insertado, usb_B28
  125. Read #usb_insertado, usb_B29
  126. Read #usb_insertado, usb_B30
  127. Read #usb_insertado, usb_B31
  128.  
  129. ' Distribuir los datos leidos en las acciones correspondientes
  130.  
  131. BufferIn[0] = usb_B0
  132. BufferIn[1] = usb_B1
  133. BufferIn[2] = usb_B2
  134. BufferIn[3] = usb_B3
  135. BufferIn[4] = usb_B4
  136. BufferIn[5] = usb_B5
  137. BufferIn[6] = usb_B6
  138. BufferIn[7] = usb_B7
  139. BufferIn[8] = usb_B8
  140. BufferIn[9] = usb_B9
  141. BufferIn[10] = usb_B10
  142. BufferIn[11] = usb_B11
  143. BufferIn[12] = usb_B12
  144. BufferIn[13] = usb_B13
  145. BufferIn[14] = usb_B14
  146. BufferIn[15] = usb_B15
  147. BufferIn[16] = usb_B16
  148. BufferIn[17] = usb_B17
  149. BufferIn[18] = usb_B18
  150. BufferIn[19] = usb_B19
  151. BufferIn[20] = usb_B20
  152. BufferIn[21] = usb_B21
  153. BufferIn[22] = usb_B22
  154. BufferIn[23] = usb_B23
  155. BufferIn[24] = usb_B24
  156. BufferIn[25] = usb_B25
  157. BufferIn[26] = usb_B26
  158. BufferIn[27] = usb_B27
  159. BufferIn[28] = usb_B28
  160. BufferIn[29] = usb_B29
  161. BufferIn[30] = usb_B30
  162. BufferIn[31] = usb_B31
  163.  
  164. For Mm = 0 To 15
  165. txtDatos.Text = txtDatos.Text & "    " & BufferIn[Mm]
  166.  
  167. txtDatos.Text &= Chr$(13)
  168.  
  169. For Mm = 16 To 31
  170. txtDatos.Text = txtDatos.Text & "    " & BufferIn[Mm]
  171.  
  172. sldLuz.Value = Abs(BufferIn[22])      ' Luz
  173. sldVolts.Value = Abs(BufferIn[6])      ' Voltaje
  174. sldTempe.Value = Abs(BufferIn[14])      ' Temperatura
  175.  
  176. txtDatos.Text = txtDatos.Text & Chr$(13)
  177.  
  178. For Mm = 0 To 31
  179. BufferIn[Mm] = 0
  180.  
  181.  
  182. Public Sub WriteSomeData()
  183. 'On Error Resume Next
  184. BufferOut[0] = 0   ' El primer byte es siempre el REPORTE ID
  185. 'For Mm = 0 To 7
  186. ' Escribe los datos, sin olvidar pasar el arreglo completo
  187. Try Exec ["outb", puerto_usb, BufferOut]
  188. 'Next
  189. txtDatos2.Text &= Str$(BufferOut) & Chr$(13) & Str$(BufferIn)
  190.  
  191.  
  192. Public Sub cmdBorrar_Click()
  193. txtDatos.Text = ""
  194.  
  195.  
  196. Public Sub Timer1_Timer()
  197. If cmdVivo.Background = Color.Green Then
  198. cmdVivo.Background = Color.Gray
  199. cmdVivo.Background = Color.Green
  200.  
  201.  
  202. Public Sub cmdSalir_Click()
  203.  
  204.  


#8

Hola de nuevo, Alfredo

Gracias por tus aportaciones, aunque tengo dudas sobre el código en C.

Bueno, antes de nada, te invito a leer aquí cómo insertar código en el foro para que se resalte en colores. En cualquier caso, el código que pegaste en tu mensaje estaba todo en una sola línea y he tenido que editar tu mensaje para que fuera mínimamente legible, formateando en código manualmente en un editor moderno. No sé qué editor de código usas para C, pero al hacer copia/pega se pierde el formato completamente.

Una vez ordenado el código no soy capaz de compilarlo. No soy experto en C, pero me choca que los comentarios que hay después de los #use y otras declaraciones (macros) no los detecte el editor.

También debes de corregir la imagen que intentas insertar, ya que has utilizado la ruta local en lugar del método correcto descrito aquí.

Y ya en cuanto al código gambas, que tampoco he probado por no disponer de los medios y requisitos necesarios para tu proyecto, me llama la atención al menos dos cosas:
  • Has usado 32 variables para cada bit de lectura/escritura del USB, pudiendo haber usado un simple array de bits
  • En lugar de usar las clase stream que dispone gambas para estos menesteres, has usado un ejecutable externo a gambas, que no siempre es lo ideal.
Entiendo que es solo un proyecto de pruebas que no va más allá, sólo es una pequeña crítica constructiva.

Saludos

Por favor, usa el corrector ortográfico antes de pulsar el botón 'Enviar'
#9

Hola JGUARDON:

Bueno el código "amontonado" del PIC se debe a que oprimí el botón de, Menu que dice "Fuente HTML" y me lo dejó todo en una sola línea, como bien dices. Ya no quise "moverle", porque se vaya a descomponer otro poco. je je....En VB6 si he usado un solo arreglo de 8 bits para leer correctamente un "mensaje USB", lo cual intenté en Gambas, pero sólo me daba el valor de "Volts". Yo me preguntaba ¿Que me hará falta?...Luego se me ocurrió -y recordé- que los mensajes USB son de 32, 64 bytes o más y es por eso que tuve que detectar al menos 32 lecturas del "mensaje USB", y sólo así pude recuperar los otros 2 datos, es decir Intensidad de Luz y Temperatura.

Así que los tres datos vienen en las variables[6], [14] y [22]....

Y efectivamente, el objetivo es que sea criticado el proyecto, sea mejorado y sea utilizado por otros hobbystas y que haya retroalimentación. Por último fui incapaz de enviar la imagen de mi aplicación, pues la original está en *.png y luego la convertí a *.jpg, pero ninguna se pudo cargar con el Menú que dice "Imagen"...Sorry...

Recuerdo que cuando era muy joven, a todo "le movía" por curiosidad y para aprender. Al paso de los años aprendí que no se debe andar de "tentón" ya que por eso pasan cosas desastrosas...acuérdate que ya paso de los 60's.....y ahora si no sé, no le toco....je je je...

Saludos.
#10

Hola: Habiendo leído los 2 artículos sobre Pegar Código e Insertar Imagen, procedo a insertar la imagen que quedó pendiente....saludos...
[Imagen: Dmq19H3.png]

La funcionalidad del botón "Monitor" no es correcta en este momento, pero estoy trabajando en ello. Si es posible que me echen una mano para lograrlo, lo agradeceré....

Nuevamente por aquí:

He colocado un Menú y un sub menú para elegir el bus HID que Linux ha destinado cuando se conecta el dispositivo externo USB, en este caso mi proyecto. En la ruta /dev/usb aparecen hiddev0 o hiddev1 y lp1.

Así que mi comando de Menú hace que se abra un nuevo Form y con el Control FileChooser abro por default la ruta /dev/usb para que me muestre el contenido. Se hace click en hiddev0 o hiddev1, con lo que esa cadena se pone en el cuadro de texto del FMain destinado para el Puerto USB seleccionado. Funciona muy bien.

En FMain el código adicional es:
 
 
GAMBAS
  1. Public Sub mnuUsb_Click()
  2.  
  3. Form1.Show
  4.   
  5.  
  6. Public Sub recibe(archivo As String)
  7.   
  8.   txtPuertoS.Text = archivo
  9.   




Y en el Form adicional, el código es:

GAMBAS
  1. ' Gambas class file
  2.  
  3.  
  4. Public Sub Form_Open()
  5.   Me.Left = 1200
  6.   Me.top = 500
  7.   FileC1.SelectedPath = "/dev/usb/"
  8.  
  9.  
  10. Public Sub cmdAceptar_Click()
  11. Dim archivo As String
  12.  
  13. archivo = FileC1.SelectedPath
  14. FMain.recibe(archivo)
  15.  




[Imagen: 535xSXb.png]


Saludos...


Salto de foro:


Usuarios navegando en este tema: 1 invitado(s)