elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


  Mostrar Mensajes
Páginas: 1 ... 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 [26] 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 ... 261
251  Programación / .NET (C#, VB.NET, ASP) / Re: Separar binario por cada byte en: 6 Abril 2021, 03:38 am
Muy buen explicación.

En mi caso, siguiendo lo que me dicen, más la locura que tengo en la cabeza, el programa que hice es muy chapucero pero...

¡¡¡FUNCIONA!!!

 ;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-)


Ver imagen.

Código C#:
Código
  1.  
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace Delimitador_consola_03
  9. {
  10.     class Program
  11.     {
  12.         static void Main(string[] args)
  13.         {
  14.             #region Configuración ventana.
  15.             // Título de la ventana.
  16.             Console.Title = "Probando manipulación de cadena";
  17.  
  18.             // Tamaño de la ventana, x, y.
  19.             Console.SetWindowSize(100, 35);
  20.  
  21.             // Color de fondo.
  22.             Console.BackgroundColor = ConsoleColor.DarkBlue;
  23.  
  24.             // Color de las letras.
  25.             Console.ForegroundColor = ConsoleColor.Yellow;
  26.  
  27.             // Limpiar pantalla y dejarlo todo en color de fondo.
  28.             Console.Clear();
  29.  
  30.             // Visible el cursor.
  31.             Console.CursorVisible = true;
  32.             #endregion
  33.  
  34.             // Cree una codificación ISO-8859-1.
  35.             Encoding ISO_8859_1 = Encoding.GetEncoding("ISO-8859-1");
  36.  
  37.             #region Variables.
  38.             // Partir a trocitos estos caracteres.
  39.             char[] delimitadorComandoB = { '#', ',', 'O', 'I', 'L', 'B', 'V', 'F', 'H', 'R', 'S', };
  40.  
  41.             // Es la cadena de caracteres que me llegó desde el puerto serie.
  42.             // En este ejemplo lo dejo en la varible directamente.
  43.             // Una cadena completa empieza con # y termina en <cr>, o lo que es lo mismo, /r.
  44.             string respuestaB = "#I223.3O224.0L000B100V26.4F50.2H50.2R0080S„€€„À"; // Comando B.
  45.  
  46.             // Se guarga en este array tipo string los datos ya partidos a tozos.
  47.             string[] palabrasB = respuestaB.Split(delimitadorComandoB);
  48.  
  49.             // Tabla S1 descripción.
  50.             string[] DESCRIPCION_S1 =
  51.             {
  52.                 "Indica que este byte está disponible y es válido. [Siempre 1]",             // Posición [0].
  53.                 "Indica falla de energía de la red pública; ver detalles en S2.0 y S2.1.",
  54.                 "Indica que la capacidad de la batería es menor que el umbral de apagado.",
  55.                 "Indica que el zumbador está en estado de pitido.",
  56.                 "Indica que la prueba de batería se está procesando.",
  57.                 "Indica que el apagado programado está pendiente.",
  58.                 "Indica que la restauración programada está pendiente.",
  59.                 "Indica falla de hardware; ver detalles sobre el comando X71."               // Posición [7].
  60.             };
  61.  
  62.             string[] DESCRIPCION_S2 =
  63.             {
  64.                 "Para indicar que este byte está disponible y es válido. [Siempre 1].",
  65.                 "--",
  66.                 "XX",
  67.                 "Indica sobretemperatura del inversor.",
  68.                 "Indica que el inversor tiene una falla.",
  69.                 "Indica que el inversor está apagado.",
  70.                 "Indica que la frecuencia de la utilidad está fuera de rango.",
  71.                 "Indica que el voltaje de la red pública está fuera de rango."
  72.             };
  73.  
  74.             string[] DESCRIPCION_S3 =
  75.             {
  76.                 "Para indicar que este byte está disponible y es válido. [Siempre 1].",
  77.                 "Indica que la batería está completamente cargada.",
  78.                 "Indica que la capacidad de la batería aún es menor que el umbral restaurado del UPS cuando la energía de la red pública restaurado.",
  79.                 "Indica que la batería se está cargando.",
  80.                 "Indica que la batería se está descargando.",
  81.                 "Indica que la capacidad de la batería es inferior al 80 por ciento.",
  82.                 "Reservado, debe ser 0.",
  83.                 "Indica que la batería no está presente."
  84.             };
  85.  
  86.             string[] DESCRIPCION_S4 =
  87. {
  88.                 "Para indicar que este byte está disponible y es válido. [Siempre 1].",
  89.                 "Indica que el bypass es una sobrecarga.",
  90.                 "Indica que la derivación está activa.",
  91.                 "Indica que la salida sufre un cortocircuito.",
  92.                 "Indica que la salida tiene carga.",
  93.                 "Indica que la salida está sobrecargada.",
  94.                 "Indica que la frecuencia de salida está fuera de rango en bypass.",
  95.                 "Indica que el voltaje de salida está fuera de rango en derivación."
  96.             };
  97.  
  98.             string[] DESCRIPCION_S5 =
  99. {
  100.                 "Para indicar que este byte está disponible y es válido. [Siempre 1].",
  101.                 "Indica que no hay salida.",
  102.                 "Para indicar que el tiempo de ejecución restante es inferior al umbral.",
  103.                 "Para indicar que el zumbador está silenciado (no permanente) en este momento.",
  104.                 "Para indicar falla de cableado.",
  105.                 "Para indicar SAI en modo ECO.",
  106.                 "Para indicar UPS en Bypass manual.",
  107.                 "Arreglar 0."
  108.             };
  109.  
  110.             string[] DESCRIPCION_S6 =
  111. {
  112.                 "Para indicar que este byte está disponible y es válido. [Siempre 1].",
  113.                 "Indica UPS encendido.",
  114.                 "Reservado, debe ser 0.",
  115.                 "Reservado, debe ser 0.",
  116.                 "Reservado, debe ser 0.",
  117.                 "Reservado, debe ser 0.",
  118.                 "Reservado, debe ser 0.",
  119.                 "Reservado, debe ser 0."
  120.             };
  121.  
  122.             bool boolS1 = true;
  123.             bool boolS2 = false;
  124.             bool boolS3 = false;
  125.             bool boolS4 = false;
  126.             bool boolS5 = false;
  127.             bool boolS6 = false;
  128.             bool boolContador = true;
  129.             bool boolContador2 = false;
  130.             #endregion
  131.  
  132.             // Muestra los resultados en pantalla.
  133.             Console.WriteLine();
  134.             Console.WriteLine("El voltaje de la utilidad es de {0} voltios. ", palabrasB[2]); // I.
  135.             Console.WriteLine("El voltaje de salida del UPS es de {0} voltios. ", palabrasB[3]); // O.
  136.             Console.WriteLine("La carga actual de UPS es del {0} por ciento. ", palabrasB[4]); // L.
  137.             Console.WriteLine("La capacidad de la batería es del {0} por ciento. ", palabrasB[5]); // B.
  138.             Console.WriteLine("El voltaje de la batería es de {0} voltios. ", palabrasB[6]); // V.
  139.             //Console.WriteLine("La temperatura del gabinete del UPS es de {0} grados centígrados. ", palabrasB[7]); // T. No hay T. en mi versión.
  140.             Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[7]); // F.
  141.             Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[8]); // H.
  142.             Console.WriteLine("El tiempo de funcionamiento restante de la batería es de {0} minutos. ", palabrasB[9]);
  143.             //Console.WriteLine(@"Estos son los bits de estados que no se entiende.S:
  144.             //Aquí hay que leer cada bits como cuando se leyeron cada Byte arriba: ", (char)palabrasB[10]);
  145.  
  146.             char[] bits = palabrasB[10].ToCharArray();
  147.  
  148.             Tabla();
  149.             int contador = 0;
  150.             for (int b = 0; b < bits.Length; b++)
  151.             {
  152.                 for (int a = 7; a >= 0; a--)
  153.                 {
  154.  
  155.                     Console.Write((((byte)bits[b]) & (1 << a)) >> a);
  156.                     Console.Write(" | ");
  157.  
  158.                     if ((contador <= 7) && (boolS1 == true))
  159.                     {
  160.                         Console.WriteLine(DESCRIPCION_S1[contador]);
  161.  
  162.                         if (contador == 7)
  163.                         {
  164.                             boolS1 = false;
  165.                             boolS2 = true;
  166.                             boolContador2 = true;
  167.                             contador = 0;
  168.                         }
  169.                     }
  170.                     else if ((contador <= 7) && (boolS2 == true))
  171.                     {
  172.                         Console.WriteLine(DESCRIPCION_S2[contador]);
  173.                         boolContador2 = false;
  174.                         if (contador == 7)
  175.                         {
  176.                             boolS2 = false;
  177.                             boolS3 = true;
  178.                             boolContador2 = true;
  179.                             contador = 0;
  180.                         }
  181.                     }
  182.                     else if ((contador <= 7) && (boolS3 == true))
  183.                     {
  184.                         Console.WriteLine(DESCRIPCION_S3[contador]);
  185.                         boolContador2 = false;
  186.                         if (contador == 7)
  187.                         {
  188.                             boolS3 = false;
  189.                             boolS4 = true;
  190.                             boolContador2 = true;
  191.                             contador = 0;
  192.                         }
  193.                     }
  194.                     else if ((contador <= 7) && (boolS4 == true))
  195.                     {
  196.                         Console.WriteLine(DESCRIPCION_S4[contador]);
  197.                         boolContador2 = false;
  198.                         if (contador == 7)
  199.                         {
  200.                             boolS4 = false;
  201.                             boolS5 = true;
  202.                             boolContador2 = true;
  203.                             contador = 0;
  204.                         }
  205.                     }
  206.                     else if ((contador <= 7) && (boolS5 == true))
  207.                     {
  208.                         Console.WriteLine(DESCRIPCION_S5[contador]);
  209.                         boolContador2 = false;
  210.                         if (contador == 7)
  211.                         {
  212.                             boolS5 = false;
  213.                             boolS6 = true;
  214.                             boolContador2 = true;
  215.                             contador = 0;
  216.                         }
  217.                     }
  218.                     else if ((contador <= 7) && (boolS6 == true))
  219.                     {
  220.                         Console.WriteLine(DESCRIPCION_S6[contador]);
  221.                         boolContador2 = false;
  222.                         if (contador == 7)
  223.                         {
  224.                             boolS6 = true;
  225.                             boolContador = true;
  226.                             boolContador2 = true;
  227.                             contador = 0;
  228.                         }
  229.                     }
  230.  
  231.                     if (boolContador == true)
  232.                     {
  233.                         contador++;
  234.  
  235.                         if (boolContador2 == true)
  236.                         {
  237.                             contador = 0;
  238.                         }
  239.                     }
  240.                     //Console.WriteLine();
  241.                 }
  242.                 Console.WriteLine();
  243.             }
  244.  
  245.  
  246.             #region Tabla.
  247.             void Tabla()
  248.             {
  249.                 Console.WriteLine("Byte | Bit | Estado | Descripción");
  250.                 Console.WriteLine("-----+-----+-----------------------------------------------------------------------");
  251.             }
  252.             #endregion
  253.  
  254.             // Pulse cualquier tecla para salir.
  255.             Console.ReadKey();
  256.         }
  257.     }
  258. }
  259.  
  260.  

Código chapuza pero funciona.

Ahora la pregunta del millón.

Cada vez que envío un comando me da un resultado diferente.

¿Cómo procesaría cada resultado correspondiente a cada comando?

Está claro que el comando B<cr>, la cadena al recibir no tiene nada que ver con otros comandos.

¿Se entiende lo qué quiero decir?

Si no entiendes, lo pregunto de otra manera.

Gracias.

Gracias a todos.
252  Programación / ASM / Juego Space Invader en asm en: 4 Abril 2021, 10:25 am
Hola:

Quiero saber si este juego en asm se puede ejecutar en Visual studio bajo C++ nativo, ya que ejecutas asm también. Lo que no se hacerlo ya que no hago pruebas desde hace añazos.

¿Es posible ejecutarlo?



Código ASM.
Código
  1. cXLimIzq       EQU  32                  ; X-Limite izquierda juego
  2.   cXLimDer       EQU  320-cXLimIzq        ; X-Limite derecha juego
  3.   cYLimSup       EQU  60                  ; Y-Limite superior juego
  4.   cYLimInf       EQU  180                 ; Y-Limite inferior juego
  5.   cIncYEDisp     EQU  1                   ; Y-incremento de los e-disparos
  6.   cTamDefFig     EQU  7*2                 ; Los words que definen la figura
  7.   cSepIniEDisp   EQU  4                   ; Separación inicial del disparo enemigo
  8.   cColorEDisp    EQU  14                  ; Color del disparo enemigo
  9.   cColorPDisp    EQU  7                   ; Color del disparo del jugador
  10.   cFigAlto       EQU  7                   ; Altura de las figuras
  11.   cFigAncho      EQU  16                  ; Anchura de las figuras
  12.   cAncho         EQU  256                 ; Anchura de la pantalla de juego
  13.   cAlto          EQU  cYLimInf-cYLimSup+1 ; Altura de la pantalla de juego
  14.   cSepMargen     EQU  3                   ; Margen de separación con el borde
  15.   cLinColor      EQU  6                   ; Color de la línea contenedora
  16.   cFrecBomb      EQU  010h                ; Frecuencia con la que empiezan a caer bombas
  17.   cNumEColumn    EQU  11                  ; Número de columnas de enemigos
  18.   cNumEnemigos   EQU  5*cNumEColumn       ; Número de enemigos
  19.   cDispEne       EQU  5                   ; Máximo num disparos x cada enemigo
  20.   cNumDispEne    EQU  7;cDispEne*cNumEColumn; Máximo disparos activos enemigos
  21.   cXESep         EQU  1                   ; X-separación entre enemigos
  22.   cYESep         EQU  3                   ; Y-separación entre enemigos
  23.   cXESup         EQU  (cAncho-((16+cXESep)*10+16))/2  ; X-inicial-superior enemigos
  24.   cYESup         EQU  cYLimSup-cYLimSup   ; Y-superior enemigos
  25.   cYPSup         EQU  cYLimInf-7-cYLimSup ; Y-superior player
  26.   cXPIzq         EQU  0                   ; X-lim izquierda player
  27.   cXPDcha        EQU  256-11              ; X-lim derecha player
  28.   cTimePlayer    EQU  0                   ; Tiempo retardo movimiento player
  29.   cTimeEnemigos  EQU  20                  ; Tiempo retardo movimiento enemigos
  30.   cTimePDisp     EQU  0                   ; Tiempo retardo movimiento player-disparo
  31.   cTimeEDisp     EQU  0                   ; Tiempo retardo movimiento enemigos-disparos
  32.   cTimeESgteDisp EQU  10                  ; Tiempo retardo siguiente enemigos-disparos
  33.   cChgTEnemigos  EQU  2                   ; Cada cuántos enemigos destruidos incrementan velocidad
  34.   cFilasBaja     EQU  2                   ; Filas que bajan los enemigos cada vez
  35.   cYTope         EQU  cYPSup-10           ; Tope superior que no pueden sobrepasar enemigos
  36.   cSoyInmune     EQU  0                   ; 1-soy inmune, 0-no soy inmune
  37.   cTAMTOT        EQU  1024*6              ; Este programa y su pila caben en 6Kb
  38.   cnNotas        EQU  7+6+7+5
  39.  
  40.   TEnemigos   STRUC
  41.     PosX    DW ?
  42.     PosY    DW ?
  43.     OldPosX DW ?
  44.     Def     DW ?                          ; La dirección donde está definido
  45.     Despl   DW ?                          ; El desplazamiento de offsets (+7?)
  46.     Tipo    DB ?                          ; 1, 2, 3, 4, 5
  47.     Color   DB ?
  48.     Vida    DB ?
  49.     Abajo   DB ?                          ; Sólo disparan los que estén abajo
  50.   TEnemigos   ENDS
  51.  
  52.   TCabEDisp STRUC                         ; Estructura de la cabecera de los disparos enemigos
  53.     DirDisp DW ?                          ; Dirección donde se encuentra el disparo
  54.     Vida    DB ?                          ; ¿Está vivo?
  55.   TCabEDisp ENDS
  56.  
  57.   TEDisparos   STRUC                      ; Disparos de los enemigos
  58.     PosX    DW ?
  59.     PosY    DW ?
  60.     Def     DW ?                          ; Matriz de definición del disparo
  61.     Despl   DW ?                          ;   junto con el desplazamiento de offsets (+7?)
  62.     Color   DB ?
  63.   TEDisparos   ENDS
  64.  
  65.   TPlayer   STRUC
  66.     PosX    DW ?
  67.     PosY    DW ?
  68.     Def     DW ?                          ; La dirección donde está definido
  69.     Color   DB ?
  70.     Vida    DB ?
  71.   TPlayer   ENDS
  72.  
  73.   TPDisparos   STRUC                      ; Disparos del jugador
  74.     PosX    DW ?
  75.     PosY    DW ?
  76.     Def     DW ?
  77.     Despl   DW ?                          ; El desplazamiento de offsets (+7?)
  78.     Color   DB ?
  79.     Vida    DB ?
  80.   TPDisparos   ENDS
  81.  
  82.   TNota STRUC
  83.     Frecuencia DW ?
  84.     Duracion   DB ?
  85.   TNota ENDS
  86.  
  87.   LTEnemigos   EQU SIZEOF TEnemigos
  88.   LTEDisparos  EQU SIZEOF TEDisparos
  89.   LTCabEDisp   EQU SIZEOF TCabEDisp
  90.   LTPlayer     EQU SIZEOF TPlayer
  91.   LTPDisparos  EQU SIZEOF TPDisparos
  92.   LTNota       EQU SIZEOF TNota
  93.  
  94.   IF1
  95.     INCLUDE ..\LIB\CtesGphM.inc           ; Constantes gráficas
  96.     INCLUDE ..\LIB\GraphMM.inc            ; Incorporamos las macros gráficas
  97.   ENDIF
  98.  
  99. codigo SEGMENT PARA PUBLIC 'CODE'         ; Abre el segmento de código
  100.   ASSUME CS:codigo, DS:codigo, ES:codigo, SS:codigo
  101.   ORG 100h                                ; COM -> comienza en 100h
  102.   Entrada PROC                            ; Abre el procedimiento
  103.     ; *** Reasigna memoria
  104.     MOV         SP, cTAMTOT               ; La base de la pila
  105.     MOV         AH, 4Ah
  106.     MOV         BX, cTAMTOT/16            ; Lo pasamos a párrafos
  107.     INT         21h                       ; Redimensionamos el bloque de memoria
  108.     JNC         $_Bien1
  109.       MOV        AH, 9
  110.       MOV        DX, OFFSET msg1
  111.       INT        21h
  112.       JMP        $_Salimos
  113.     $_Bien1:
  114.     CALL        VGAColor                  ; Comprobamos si existe VGA en color
  115.     ; Reserva memoria para el búfer pant1
  116.     MOV         BX, (cXLimDer-cXLimIzq+1)*(cYLimInf-cYLimSup+1)/16+1 ; En párrafos
  117.     CALL        ResMem
  118.     MOV         WORD PTR [ScrSeg], AX
  119.     SetMode     13h                       ; Ponemos el modo gráfico
  120.     CALL        DibMarco
  121.     CALL        SaveValSPK
  122.     CALL        Randomize
  123.     CALL        SaveOldInt9h
  124.     CALL        SetNewInt9h
  125.     CALL        SaveOldInt1Ch
  126.     CALL        SetNewInt1Ch
  127.     CALL        IniCabEDisp
  128.     CALL        ResetNivel                ; Inicializamos el nivel del juego
  129.     $_Nueva_Partida:
  130.     CALL        IniElementos              ; Inicializa valores en función de variables y constantes
  131.     $_Main:
  132.       CALL        GetPShoot               ; ¿Hemos pulsado ctrl?
  133.       CALL        GetEShoot               ; ¿Debe disparar un enemigo?
  134.       CALL        SetMotion               ; Movemos las piezas si toca
  135.       JNC         $_Next0
  136.         ; Si STC = 1 significa que los enemigos han llegado al nivel inferior: ganaron
  137.         CALL        ResetNivel            ; Inicializamos el nivel del juego
  138.         CALL        WaitUntilCtrl         ; Esperamos hasta Ctrl pulsado
  139.         JMP         $_Nueva_Partida
  140.       $_Next0:
  141.       CMP         BYTE PTR [NumEnemigos], 0
  142.       JA          $_Next1
  143.         CALL        incNivel              ; Incrementamos el nivel del juego
  144.         JMP         $_Nueva_Partida
  145.       $_Next1:
  146.       CMP         BYTE PTR [Player.Vida], 0
  147.       JA          $_Next2
  148.         CALL        ResetNivel            ; Inicializamos el nivel del juego
  149.         CALL        WaitUntilCtrl         ; Esperamos hasta Ctrl pulsado
  150.         JMP         $_Nueva_Partida
  151.       $_Next2:
  152.       CALL        ClearBuffer             ; Limpiamos el búfer
  153.       CALL        DibujaEnemigos          ; Dibujamos los enemigos en el búfer
  154.       CALL        DibujaJugador           ; Dibujamos el jugador en el búfer
  155.       CALL        DibujaPDisparo          ; Dibujamos el disparo del jugador en búfer
  156.       CALL        DibujaEDisparo          ; Dibujamos los disparos de los enemigos en búfer
  157.       CALL        CheckPDEDColision       ; ¿El disparo del jugador alcanzo al de algun enemigo?
  158.       CALL        CheckMPDColision        ; ¿El disparo del jugador alcanzo algun enemigo?
  159.       CALL        CheckMEDColision        ; ¿El disparo de los enemigos alcanzaron al jugador?
  160.       WRetrace    8                       ; Esperamos al final del retrazo
  161.       MOV         AX, WORD PTR [ScrSeg]   ; Segmento Origen
  162.       MOV         BX, __VgaSeg            ; Segmento destino: mem vídeo
  163.       CALL        Copy64K                 ; Vuelca búfer en mem vídeo
  164.       CMP         BYTE PTR [Escape], 1
  165.     JNZ         $_Main
  166.     SetMode     3h                        ; Volvemos al modo texto
  167.     CALL        RestoreOldInt1Ch
  168.     CALL        RestoreOldInt9h
  169.     CALL        TurnOffSpk
  170.     MOV         AX, WORD PTR [ScrSeg]     ; Libera memoria pantalla
  171.     CALL        LibMem
  172.     $_Salimos:
  173.     ; Salimos al DOS
  174.     MOV      AX, 4C00h                    ; Servicio 4Ch, mensaje 0
  175.     INT      21h                          ; volvemos AL DOS
  176.   Entrada ENDP                            ; cierra el procedimiento
  177.  
  178.   IF1
  179.     INCLUDE  ..\LIB\VGA_M.inc             ; Incorporamos procedimientos
  180.     INCLUDE  ..\LIB\SpcM.inc              ; Incorporamos procedimientos
  181.   ENDIF
  182.  
  183.   ; ****************
  184.  
  185.   TurnOffSpk PROC
  186.     ;  Propósito: Apaga el altavoz
  187.     ;  Entrada  : Ninguna
  188.     ;  Salida   : Ninguna
  189.     ;  Destruye : AX
  190.     MOV      AL, BYTE PTR [vbSpeaker]
  191.     AND      AL, 11111100b                ; Apagamos y descconectamos el altavoz del canal 2 del PIT
  192.     OUT      61h, AL
  193.     RET
  194.   TurnOffSpk ENDP
  195.  
  196.   SaveValSPK PROC
  197.     ;  Propósito: Guarda el valor original del puerto 61h
  198.     ;  Entrada  : Ninguna
  199.     ;  Salida   : Ninguna
  200.     ;  Destruye : AX
  201.     IN       AL, 61h
  202.     AND      AL, 11111100b
  203.     MOV      BYTE PTR [vbSpeaker], AL
  204.     RET
  205.   SaveValSPK ENDP
  206.  
  207.   Frec_Periodo PROC
  208.     ;  Propósito: Convertimos la frecuencia en período
  209.     ;  Entrada  : CX: frecuencia
  210.     ;  Salida   : DX: período
  211.     ;  Destruye : AX, DX
  212.     MOV      DX, 12h
  213.     MOV      AX, 34DCh
  214.     DIV      CX
  215.     MOV      DX, AX                       ; Lo guardamos en DX
  216.     RET
  217.   Frec_Periodo ENDP
  218.  
  219.   PIT_REG_COMM PROC
  220.     ;  Propósito: Le indicamos al PIT lo que vamos a hacer
  221.     ;  Entrada  : DX:periodo
  222.     ;  Salida   : Ninguna
  223.     ;  Destruye : AX
  224.     MOV      AL, 0B6h
  225.     OUT      43h, AL
  226.     MOV      AL, DL                       ; Pasamos el byte bajo del contador
  227.     OUT      42h, AL
  228.     MOV      AL, DH                       ; Y ahora el alto
  229.     OUT      42h, AL
  230.     RET
  231.   PIT_REG_COMM ENDP
  232.  
  233.   SpkOn PROC
  234.     ;  Propósito: Encendemos el altavoz con duración determinada
  235.     ;  Entrada  : Ninguna
  236.     ;  Salida   : Ninguna
  237.     ;  Destruye : AX
  238.     MOV      AL, BYTE PTR CS:[vbSpeaker]
  239.     OR       AL, 3
  240.     OUT      61h, AL
  241.     RET
  242.   SpkOn ENDP
  243.  
  244.   SpkOff PROC
  245.     ;  Propósito: Encendemos el altavoz con duración determinada
  246.     ;  Entrada  : Ninguna
  247.     ;  Salida   : Ninguna
  248.     ;  Destruye : AX
  249.     MOV      AL, BYTE PTR CS:[vbSpeaker]
  250.     AND      AL, 11111100b
  251.     OUT      61h, AL
  252.     RET
  253.   SpkOff ENDP
  254.  
  255.   Sonido PROC
  256.     ;  Propósito: Toca una nota en el altavoz del PC a través del PIT
  257.     ;  Entrada  : CX:frecuencia
  258.     ;  Salida   : Ninguna
  259.     ;  Destruye : Ninguna
  260.     .IF      CX == 0
  261.       CALL     SpkOff
  262.     .ELSE
  263.       CALL     Frec_Periodo
  264.       CALL     PIT_REG_COMM
  265.       CALL     SpkOn
  266.     .ENDIF
  267.     RET
  268.   Sonido ENDP
  269.  
  270.   ResetNota PROC
  271.     ; Propósito: Recogemos los valores de la nueva nota en MNota
  272.     ; entrada  : KeyTable
  273.     ; salida   : KeyTable
  274.     ; Destruye : AX 
  275.     PUSH      AX
  276.     PUSH      BX
  277.     MOV       BX, WORD PTR CS:[vwActual]
  278.     MOV       AX, WORD PTR CS:[Notas1+BX]
  279.     MOV       WORD PTR CS:[MNota.Frecuencia], AX
  280.     MOV       AX, WORD PTR CS:[Notas1+BX+2]
  281.     MOV       BYTE PTR CS:[MNota.Duracion], AL
  282.     POP       BX 
  283.     POP       AX
  284.     RET
  285.   ResetNota ENDP
  286.  
  287.   ; ****************
  288.  
  289.   SaveOldInt1Ch PROC NEAR
  290.     ; Propósito: Guarda la dirección de la antigua ISR de Int 1Ch
  291.     ; entrada  : OldInt1Ch
  292.     ; salida   : Ninguna
  293.     ; Destruye : AX
  294.     MOV       AX, 351Ch                   ; Obtiene la dirección de la
  295.     INT       21h                         ;     interrupción 1Ch
  296.     MOV       WORD PTR OldInt1Ch[2],ES    ; Guarda segmento
  297.     MOV       WORD PTR OldInt1Ch[0],BX    ;     y dirección
  298.     RET
  299.   SaveOldInt1Ch ENDP
  300.  
  301.   RestoreOldInt1Ch PROC NEAR
  302.     ; Propósito: Restaura la dirección de la antigua ISR de Int 1Ch
  303.     ; entrada  : OldInt1Ch
  304.     ; salida   : Ninguna
  305.     ; Destruye : AX, DX
  306.     PUSH      DS                          ; Guardamos DS
  307.     LDS       DX, OldInt1Ch               ; Carga la dirección original
  308.     MOV       AX, 251Ch                   ; Lo restaura a la tabla de vectores
  309.     INT       21h
  310.     POP       DS
  311.     RET
  312.   RestoreOldInt1Ch ENDP
  313.  
  314.   SetNewInt1Ch PROC NEAR
  315.     ; Propósito: Establece la dirección de la nueva ISR para Int 1Ch
  316.     ; entrada  : NuevaInt1Ch
  317.     ; salida   : Ninguna
  318.     ; Destruye : AX, DX
  319.     MOV       DX, OFFSET NuevaInt1Ch      ; Carga la dirección de nueva rutina
  320.     MOV       AX, 251Ch                   ; Establece la nueva interrupción
  321.     INT       21h
  322.     RET
  323.   SetNewInt1Ch ENDP
  324.  
  325.   NuevaInt1Ch PROC FAR
  326.     ; Propósito: Nueva ISR para la INT 1Ch, crea un retardo
  327.     ; entrada  : Ninguna
  328.     ; salida   : Ninguna
  329.     ; Destruye : Ninguna
  330.     PUSHF
  331.     PUSH      AX
  332.     PUSH      BX
  333.     PUSH      CX
  334.     PUSH      DX
  335.     PUSH      DS
  336.     PUSH      ES
  337.     .IF       BYTE PTR CS:[vbEjecutando] == 1
  338.       ; Si está sonando la nota
  339.       DEC       BYTE PTR CS:[MNota.Duracion]            ; Decrementamos la duración
  340.       .IF       BYTE PTR CS:[MNota.Duracion] == 0
  341.         ; Si ya ha terminado la duración de la nota
  342.         ADD       WORD PTR CS:[vwActual], 4             ; Incrementamos puntero a notas
  343.         CALL      ResetNota                             ; Recogemos nueva nota
  344.         .IF       WORD PTR CS:[vwActual] >= cnNotas*4
  345.           ; Si ya hemos terminado todas las notas
  346.           MOV       BYTE PTR CS:[vbEjecutando], 0       ; Marcamos que no tocamos
  347.           MOV       WORD PTR CS:[vwActual], 0           ; Reseteamos el puntero a notas
  348.           CALL      TurnOffSpk
  349.         .ELSE
  350.           ; Si todavía no hemos terminado todas las notas
  351.           MOV       CX, WORD PTR CS:[MNota.Frecuencia]
  352.           CALL      Sonido
  353.         .ENDIF
  354.       .ENDIF
  355.     .ELSE
  356.       ; Si no está sonando ninguna nota
  357.       .IF       BYTE PTR CS:[vbEjecutar] == 1
  358.         ; Si debemos ejecutar las notas
  359.         .IF       WORD PTR CS:[vwActual] == 0
  360.           ; Si estamos al inicio, reseteamos
  361.           CALL      ResetNota
  362.         .ENDIF
  363.         .IF       BYTE PTR CS:[MNota.Duracion] != 0
  364.           ; Si todavía dura la nota, la tocamos
  365.           MOV       BYTE PTR CS:[vbEjecutando], 1       ; Marcamos para tocar
  366.           MOV       CX, WORD PTR CS:[MNota.Frecuencia]
  367.           CALL      Sonido
  368.         .ENDIF
  369.       .ENDIF
  370.     .ENDIF
  371.     CMP       BYTE PTR CS:[TimePlayer], 0
  372.     JZ        $_Next1
  373.       DEC       BYTE PTR CS:[TimePlayer]      ; Decrementamos el contador de pulsos
  374.     $_Next1:
  375.     CMP       BYTE PTR CS:[TimeEnemigos], 0
  376.     JZ        $_Next2
  377.       DEC       BYTE PTR CS:[TimeEnemigos]      ; Decrementamos el contador de pulsos
  378.     $_Next2:
  379.     CMP       BYTE PTR CS:[TimePDisp], 0
  380.     JZ        $_Next3
  381.       DEC       BYTE PTR CS:[TimePDisp]      ; Decrementamos el contador de pulsos
  382.     $_Next3:
  383.     CMP       BYTE PTR CS:[TimeEDisp], 0
  384.     JZ        $_Next4
  385.       DEC       BYTE PTR CS:[TimeEDisp]      ; Decrementamos el contador de pulsos
  386.     $_Next4:
  387.       CMP       BYTE PTR CS:[TimeESgteDisp], 0
  388.       JZ        $_GT_Next5
  389.         DEC       BYTE PTR CS:[TimeESgteDisp]   ; Retardo para el siguiente disparo de los enemigos
  390.       $_GT_Next5:
  391.     POP       ES
  392.     POP       DS
  393.     POP       DX
  394.     POP       CX
  395.     POP       BX
  396.     POP       AX
  397.     POPF
  398.     JMP       [CS:OldInt1Ch]              ; Saltamos a la vieja rutina
  399.   NuevaInt1Ch  ENDP
  400.  
  401. TopInvader1             DW      0c00h,1e00h,2d00h,3f00h,1200h,2100h,1200h
  402. ;   0c00   0000110000000000
  403. ;   1e00   0001111000000000
  404. ;   2d00   0010110100000000
  405. ;   3f00   0011111100000000
  406. ;   1200   0001001000000000
  407. ;   2100   0010000100000000
  408. ;   1200   0001001000000000
  409. TopInvader2             DW      0c00h,1e00h,2d00h,3f00h,1200h,2100h,4080h
  410. ;   0c00   0000110000000000
  411. ;   1e00   0001111000000000
  412. ;   2d00   0010110100000000
  413. ;   3f00   0011111100000000
  414. ;   1200   0001001000000000
  415. ;   2100   0010000100000000
  416. ;   4080   0100000010000000
  417. MiddleInvader1          DW      2100h,9e40h,0ad40h,7f80h,3f00h,2100h,4080h
  418. MiddleInvader2          DW      2100h,1e00h,2d00h,7f80h,0bf40h,0a140h,1200h
  419. BottomInvader1          DW      01e00h,7f80h,0ccc0h,0ffc0h,2100h,4c80h,2100h
  420. BottomInvader2          DW      01e00h,7f80h,0ccc0h,0ffc0h,2100h,4c80h,8040h
  421. PlayersShip             DW      0400h,0e00h,7fc0h,0ffe0h,0ffe0h,0ffe0h,0000h
  422. ;   0400   0000010000000000
  423. ;   0e00   0000111000000000
  424. ;   7fc0   0111111111000000
  425. ;   ffe0   1111111111100000
  426. ;   ffe0   1111111111100000
  427. ;   ffe0   1111111111100000
  428. ;   0000   0000000000000000
  429. TwistedMissile1         DW      0000h,0000h,0000h,0800h,0400h,0800h,0400h
  430. ;   0000   0000000000000000
  431. ;   0000   0000000000000000
  432. ;   0000   0000000000000000
  433. ;   0800   0000100000000000
  434. ;   0400   0000010000000000
  435. ;   0800   0000100000000000
  436. ;   0400   0000010000000000
  437. TwistedMissile2         DW      0000h,0000h,0000h,0400h,0800h,0400h,0800h
  438. StraightMissile         DW      0000h,0000h,0000h,0400h,0400h,0400h,0400h
  439.  
  440.   MEnemigos  TEnemigos  cNumEnemigos DUP (<>)    ; Enemigos sin inicializar
  441.   MCabEDisp  TCabEDisp  cNumDispEne  DUP (<>)    ; Disparos de los enemigos
  442. ;   align 16
  443. ;   db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1             ;16
  444.   MEDisparos TEDisparos cNumDispEne  DUP (<>)    ; Disparos de los enemigos
  445.   Player     TPlayer    <>                       ; Jugador sin inicializar
  446.   MPDisparos TPDisparos <>                       ; Disparos de los enemigos
  447.  
  448.   vbSpeaker    DB   ?
  449.   vbEjecutar   DB   1                     ; Lo definimos indicando que suenen las notas
  450.   vbEjecutando DB   0
  451.   vwActual     DW   0
  452.   Notas1       DW   262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 294, 3, 0, 8     ; 7
  453.                DW   262, 3, 330, 3, 349, 3, 392, 3, 349, 3,   0, 8           ; 6
  454.                DW   262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 294, 3, 0, 8     ; 7
  455.                DW   330, 3, 349, 3, 330, 3, 262, 3, 262, 3                   ; 5
  456.   MNota        TNota  <>
  457.  
  458. msg1           DB  "Error al REDIMENSIONAR memoria$"
  459. msg2           DB  "Error al RESERVAR memoria$"
  460. msg3           DB  "Error al LIBERAR memoria$"
  461. msgAOE         DB  "(c)Abre los ojos al ensamblador", 13, 10
  462.                DB  "Ejemplo de space invaders$"
  463. msgExito       DB  "Enhorabuena, has salvado al planeta Tierra$"
  464. msgFracaso     DB  "Por tu impericia la Tierra ha sido destruida$"
  465. msgBlanco      DB  "                                            $"
  466. NumEnemigos    DB  ?                      ; Número de enemigos que quedan
  467. OldInt9h       DD  ?                      ; Dirección antigua de Int 9h
  468. OldInt1Ch      DD  ?                      ; Dirección antigua de Int 1Ch
  469. ScrSeg         DW  ?                      ; Segmento del búfer de pantalla
  470. DirEnemigos    DW  ?                      ; Dirección del mvto de los enemigos
  471. DesplDefFig    DW  ?                      ; Para pintar el mvto de la figura
  472. TimePlayer     DB  ?                      ; Retardo para el mvto del jugador
  473. TimeEnemigos   DB  ?                      ; Retardo para el mvto de los enemigos
  474. TimePDisp      DB  ?                      ; Retardo para el mvto disparo jugador
  475. TimeEDisp      DB  ?                      ; Retardo para el mvto disparo enemigos
  476. TimeESgteDisp  DB  ?                      ; Retardo para el siguiente disparo enemigos
  477. vNextTEnemigos DB  ?                      ; Siguiente retardo de los enemigos
  478. TicksReloj     DD  ?                      ; Ticks de reloj
  479. ActFrecBomb    DB  ?                      ; Frecuencia actual disparos enemigos (cambia)
  480. NumEColumn     DW  ?                      ; Número de columnas de enemigos que quedan
  481. ChgTEnemigos   DB  ?                      ; Cada cuantos enemigos muertos incr su velocidad
  482. vSoyInmune     DB  cSoyInmune             ; Ser o no ser inmune
  483. ; Datos modificados en cada nivel
  484. vYESup         DW  ?                      ; X-inicial-superior de los enemigos
  485. ; Datos que modifica la nueva ISR del teclado
  486. PlayerLeft     DB  0
  487. PlayerRight    DB  0
  488. PlayerFire     DB  0
  489. Escape         DB  0
  490.  
  491. codigo ENDS
  492. END Entrada

Más códigos aquí.
http://abreojosensamblador.epizy.com/?Tarea=1&SubTarea=35&i=1

Gracias.
253  Programación / .NET (C#, VB.NET, ASP) / Re: Separar binario por cada byte en: 3 Abril 2021, 09:13 am
Cita de: @XSStringManolo en  2 Abril 2021, 23:05 pm
Uhh, no sabía que sucedía ese error.

Suma de 1 en 1 en lugar de 8 en 8 y cuando i % 8 == 0 añades un espacio.

Si te refieres a esto.
Código
  1. for (int i = 0; i < recibidos.Length; i += 8)
  2.             {
  3.                 richTextBox1.Text += recibidos.Substring(i, 1) + " ";
  4.             }

O a esto ottro.
Código
  1. for (int i = 0; i < recibidos.Length; i += 1)
  2.             {
  3.                 richTextBox1.Text += recibidos.Substring(i, 8) + " ";
  4.             }

No funciona.

Cita de: WHK en  3 Abril 2021, 03:14 am
Eso pasa porque el tipo String en .net tiene pre filtros como la eliminación de padding vacío, hay que procesarlo como un arreglo de bytes, sino pasarás haciendo parches y de una u otra manera tendrás problema con algún valor.

Los ejemplos de Microsoft, tiene la manía de recibir datos tipo sttring aquí y pòr aquí. Es verdad que en el puerto serie se transmite byte por byte. Aquí en SerialPort.ReadExisting es funciona con string.

Dicen muchos por Internet, que para estas cosas mejor aceptar las tramas de byte tal como vienen, en byte. Guardar los datos en Byte y luego procesarlo. Ya se usaría esto otro SerialPort.Read.

El problema si usas tipo arreglo con Byte[] tienes que saber el tamaño que te llega en ese arreglo. El programa completo cambiaría por todas partes, no es cambiar de tipo a string a Byte[] así sin más. Ahí está el problema.

Encuentro otro problema con el invoke al recibir datos por el puerto serie el como se comporta.
Código
  1. // Al recibir datos.
  2.         private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
  3.         {
  4.             // Acumula los caracteres recibidos a nuestro 'buffer' (string).
  5.             recibidos += serialPort1.ReadExisting();
  6.  
  7.             // Invocar o llamar al proceso de tramas.
  8.             Invoke(new EventHandler(Actualizar));
  9.         }

Si recibo este mensaje en ASCII, o lo que sea, por ejemplo. Debería mostrar el mensaje recibido tal como aparece en el Ejemplo 1. En el Ejemlo 2, a veces se corta, como si alguien le diera Enter en medio de la frase.

Ejemplo 1:
No hay mayor tesoro que un amigo.

Ejemplo 2:
No hay mayor tesoro q
ue un amigo.

No he conseguido ningún programa estable que funcione siempre como el Ejemplo 1.

Saludos.
254  Programación / .NET (C#, VB.NET, ASP) / Re: Leer bits de Byte en: 2 Abril 2021, 19:46 pm
Buen truco en C++.

Me funcionó en modo consola en Windows.

Ver imagen.

Código
  1. #include <iostream>
  2. #include <windows.h> // Para mostrar texto en el título de la ventana.
  3. #include <stdio.h>   // Cambio color de fondo y letras.
  4.  
  5. using namespace std;
  6. //using std::cout;
  7. //using std::cin;
  8.  
  9. typedef unsigned char Byte;
  10.  
  11. enum
  12. {
  13. 	EST_VENTILADOR,
  14. 	EST_PERSIANA,
  15. 	EST_ALARMA,
  16. 	EST_EXTRACTOR,
  17. 	EST_LUZ_B,
  18. 	EST_LUZ_A,
  19. 	EST_MOTOR_B,
  20. 	EST_MOTOR_A,
  21.  
  22. 	EST_TODOS_LOS_CONTROLADORES,
  23. };
  24.  
  25. bool LeerBit(Byte elByte, Byte elBit)
  26. {
  27. 	return (elByte & (1 << elBit)) != 0;
  28. }
  29.  
  30. int main(int argc, char* argv[])
  31. {
  32. 	// Mostrar caracteres correctamente en pantalla y título de la ventana.
  33. 	SetConsoleOutputCP(65001);
  34. 	wchar_t titulo[128];
  35. 	MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
  36. 	SetConsoleTitle(titulo);
  37.  
  38. 	// Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
  39. 	SMALL_RECT r = { 0, 0, 49, 9 }; // X = 49, Y = 9.
  40. 	SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
  41.  
  42. 	// Cambio color de A (verde claro), color letras 0 (negro).
  43. 	system("color A0");
  44.  
  45. 	// Ocultar cursor.
  46. 	CONSOLE_CURSOR_INFO cci;
  47. 	GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
  48. 	cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
  49. 	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
  50.  
  51. 	Byte unEstado = 0b11001000;
  52.  
  53. 	for (Byte i = 0; i < EST_TODOS_LOS_CONTROLADORES; i++)
  54. 	{
  55. 		printf("El bit: %i tiene valor %s\n", i, (LeerBit(unEstado, i) ? "Activo" : "Inactivo"));
  56. 	}
  57. 	cout << endl; // Nueva línea.
  58. 	system("pause");
  59. 	return 0;
  60. }

Voy a hacerlo ahora mismo en C# en modo consola y luego a Windows Form.

Gracias por el detalle.  ;-)
255  Programación / .NET (C#, VB.NET, ASP) / Leer bits de Byte en: 2 Abril 2021, 13:14 pm
Buenas camaradas:

Haciendo un programa hecho con Windows Form bajo .Net FrameWotk 4.7. Si envío un comando por el puerto serie que se llama X82, recibo un mensaje que en ASCII no se entiende porque usa caracteres raros.

Lo paso a hexadecimal y en binario.

Envío un comando, ocurre algún evento y en Windoes Form me aparece cógios en HEX y en BIN. Se puede cambiar varios bit en un único Byte.

Por ejemplo, si me llega este dato.

Hexadecimal: 23C797C0B00D

Binario: 00100011 11000111 10010111 11000000 10110000 00001101

Un ejemplo, es poner muchos labels en cada bits y una tabla de cada Byte recibido. Simpre son la misma cantidad de bytes ya que en realdiad hace de Flags.

Centrándonos en el binario, ya que hay 6 Bytes.

Código
  1. 00100011 11000111 10010111 11000000 10110000 00001101
  2. -------- -------- -------- -------- -------- --------
  3.  Byte I  Byte a    Byte b   Byte c   Byte d   Byte F
  4.  

En el Byte c que corresponde al 11000000 quiero leer el bit 3 que corresponde al "Extractor" indicado en la tabla de abajo. Cada Byte tiene su tabla, ahora nos centramos en un Byte y ver los estados de los bits.

bit:c Dato        Función.
7 =   1            Motor A.
6 =   1            Motor B.
5 =   0            Luz A.
4 =   0            Luz B.
3 =   0            Extractor.
2 =   0            Alarma.
1 =   0            Persiana.
0 =   0            Ventilador

El Byte c que ahora contiene estos bits que son 11000000, me llega una nueva trama de Bytes y precisamente este, cambia de 11000000 a 11001000. Solo ha cambiado un bit que es el 3 en el Byte c.

Cada bit tiene su label para mostrarlo en el formulario de Windows. La tabla de abajo se actualiza.

bit:c Dato        Función.
7 =   1            Motor A.
6 =   1            Motor B.
5 =   0            Luz A.
4 =   0            Luz B.
3 =   1            Extractor.
2 =   0            Alarma.
1 =   0            Persiana.
0 =   0            Ventilador

Antes el Byte c del bit 3 que es el Extractor estaba a 0, ahora es 1.

En resumen. Quiero saber como se leen los bits que me llegan del puerto serie.

¿Existe la posibilidad de hacer un programa así?

Saludos.

PD: En esta clase de programas que no suelo usar, es como las aves, fáciles de ver, difíciles de alcanzar.
256  Programación / .NET (C#, VB.NET, ASP) / Re: Separar binario por cada byte en: 2 Abril 2021, 10:33 am
Buenas:

Como veo la base ya tienes una variable con 0 y 1.
Hice el foreach y for que indicaste. Me da problemas. Lo hice así para que lo pase a binario y elfor tuyo para que lo separe.


Ver zoom.

Código
  1.             // Pasar a binario.
  2.             string resultado = "";
  3.             foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
  4.             {
  5.                 resultado += leer.ToString();
  6.             }    
  7.  
  8.             for (int i = 0; i < resultado.Length; i += 8)
  9.             {
  10.                 richTextBox1.Text += resultado.Substring(i, 8) + " ";
  11.             }

Si lo hago solo así que se muestre en richTextBox me da el  mismo error.
Código
  1.             for (int i = 0; i < recibidos.Length; i += 8)
  2.             {
  3.                 richTextBox1.Text += recibidos.Substring(i, 8) + " ";
  4.             }
257  Programación / .NET (C#, VB.NET, ASP) / Re: Separar binario por cada byte en: 2 Abril 2021, 05:33 am
Buenas mi muy distinguido amigo:

El problema que el código y variable recibidos me viene en string.

Lo he intentado poner en Byte y me da más problemas por todas partes. El código es enorme.

Dejo un ejemplo para que lo veas y te hagas una gran idea.


Código
  1. using System;
  2. using System.IO.Ports;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Windows.Forms;
  6.  
  7. namespace Ejemplo
  8. {
  9.     public partial class Form1 : Form
  10.     {
  11.         // Utilizaremos un string como buffer de recepción.
  12.         string recibidos;
  13.  
  14.         public Form1()
  15.         {
  16.             InitializeComponent();
  17.         }
  18.  
  19.  
  20.         private void Form1_Load(object sender, EventArgs e)
  21.         {
  22.             try
  23.             {
  24.                 // Codificación.
  25.                 //serialPort1.Encoding = Encoding.GetEncoding(437);
  26.                 //serialPort1.Encoding = Encoding.GetEncoding(28591); // 28591 es lo mismo que ISO-8859-1.
  27.                 serialPort1.Encoding = Encoding.GetEncoding("ISO-8859-1");
  28.  
  29.                 // Añado los puertos disponible en el PC con SerialPort.GetPortNames() al comboBox_Puerto.
  30.                 comboBox_Puerto.DataSource = SerialPort.GetPortNames();
  31.  
  32.                 // Añade puertos disponibles físicos  y virtuales.
  33.                 serialPort1.PortName = comboBox_Puerto.Text.ToString();
  34.  
  35.                 // Añadir datos recibidos en el evento.
  36.                 serialPort1.DataReceived += new SerialDataReceivedEventHandler(serialPort1_DataReceived);
  37.             }
  38.  
  39.             catch (Exception error)
  40.             {
  41.                 MessageBox.Show(error.Message, "Aviso:",
  42.                     MessageBoxButtons.OK, MessageBoxIcon.Warning);
  43.             }
  44.         }
  45.  
  46.         // Detecta USB o puerto serie virtual cuando lo conecta y desconecta del cable.
  47.         protected override void WndProc(ref Message USB)
  48.         {
  49.             if (USB.Msg == 0x219)
  50.             {
  51.                 comboBox_Puerto.DataSource = SerialPort.GetPortNames();
  52.             }
  53.  
  54.             // Detecta si hay cambios en el usb y si los hay los refleja.
  55.             base.WndProc(ref USB); 
  56.         }
  57.  
  58.         private void button_Conectar_Click(object sender, EventArgs e)
  59.         {
  60.             try
  61.             {
  62.                 serialPort1.PortName = comboBox_Puerto.Text.ToString(); // Puerto seleccionado previamente.
  63.                 serialPort1.BaudRate = Convert.ToInt32(comboBox_Baudios.Text); // Baudios.
  64.                 serialPort1.Open(); // Abrir puerto.
  65.                 comboBox_Puerto.Enabled = false;
  66.                 comboBox_Baudios.Enabled = false;
  67.                 button_Conectar.Enabled = false;
  68.                 button_Desconectar.Enabled = true;
  69.                 groupBox_Control_Zumbador.Enabled = true;
  70.             }
  71.             catch (Exception error)
  72.             {
  73.                 MessageBox.Show(error.Message, "Aviso:",
  74.                 MessageBoxButtons.OK, MessageBoxIcon.Warning);
  75.             }
  76.         }
  77.  
  78.         private void button_Desconectar_Click(object sender, EventArgs e)
  79.         {
  80.             try
  81.             {
  82.                 serialPort1.Close(); // Cerrar puerto.
  83.                 comboBox_Puerto.Enabled = true;
  84.                 comboBox_Baudios.Enabled = true;
  85.                 button_Conectar.Enabled = true;
  86.                 button_Desconectar.Enabled = false;
  87.                 groupBox_Control_Zumbador.Enabled = false;
  88.             }
  89.  
  90.             catch (Exception error)
  91.             {
  92.                 MessageBox.Show(error.Message, "Aviso:",
  93.                 MessageBoxButtons.OK, MessageBoxIcon.Warning);
  94.             }
  95.         }
  96.  
  97.         // Al cerrar el formulario, cierra el puerto si está abierto.
  98.         private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  99.         {
  100.             try
  101.             {
  102.                 serialPort1.Close(); // Cerrar puerto.
  103.             }
  104.  
  105.             catch (Exception error)
  106.             {
  107.                 MessageBox.Show(error.Message, "Aviso:",
  108.                 MessageBoxButtons.OK, MessageBoxIcon.Warning);
  109.             }
  110.         }
  111.  
  112.         // Al recibir datos.
  113.         private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
  114.         {
  115.             // Acumula los caracteres recibidos a nuestro 'buffer' (string).
  116.             recibidos += serialPort1.ReadExisting();
  117.  
  118.             // Invocar o llamar al proceso de tramas.
  119.             Invoke(new EventHandler(Actualizar));
  120.         }
  121.  
  122.         // Procesar los datos recibidos en el bufer y extraer tramas completas.
  123.         private void Actualizar(object sender, EventArgs e)
  124.         {
  125.  
  126.             // Asignar el valor de la trama al richTextBox.
  127.             richTextBox1.Text += recibidos;
  128.  
  129.             // Pasar a hexadecimal.
  130.             foreach (byte b in recibidos)
  131.             {
  132.                 // x = minúscula, X = mayúscula.
  133.                 richTextBox1.Text += b.ToString("X2");
  134.             }
  135.  
  136.             // Nueva línea.
  137.             richTextBox1.Text += Environment.NewLine;
  138.  
  139.             // Pasar a binario.
  140.             foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
  141.             {
  142.                 richTextBox1.Text += leer.ToString();
  143.             }
  144.  
  145.             // Nueva línea.
  146.             richTextBox1.Text += Environment.NewLine;
  147.             richTextBox1.Text += Environment.NewLine;
  148.  
  149.             // Selecciona la posición final para leer los mensajes entrantes.
  150.             richTextBox1.SelectionStart = richTextBox1.Text.Length;
  151.  
  152.             // Mantiene el scroll en la entrada de cada mensaje.
  153.             richTextBox1.ScrollToCaret();
  154.  
  155.             // Limpiar.
  156.             recibidos = "";
  157.         }
  158.  
  159.         private void button_Activar_Click(object sender, EventArgs e)
  160.         {
  161.             //byte[] mBuffer = Encoding.ASCII.GetBytes("K60:1\r"); // Comando K60:1 activar.
  162.             byte[] mBuffer = Encoding.ASCII.GetBytes("X87\r"); // Comando X87 Flags.
  163.             serialPort1.Write(mBuffer, 0, mBuffer.Length);
  164.         }
  165.  
  166.         private void button_Desactivar_Click(object sender, EventArgs e)
  167.         {
  168.             byte[] mBuffer = Encoding.ASCII.GetBytes("K60:0\r"); // Comando K60:0 desactivar.
  169.             serialPort1.Write(mBuffer, 0, mBuffer.Length);
  170.         }
  171.  
  172.         private void button_Mute_temporal_Click(object sender, EventArgs e)
  173.         {
  174.             byte[] mBuffer = Encoding.ASCII.GetBytes("B\r"); // Comando K60:2 Mute temporal.
  175.             serialPort1.Write(mBuffer, 0, mBuffer.Length);
  176.         }
  177.  
  178.         private void button_Limpiar_Click(object sender, EventArgs e)
  179.         {
  180.             // Limpiar.
  181.             richTextBox1.Clear();
  182.         }
  183.     }
  184. }
258  Programación / .NET (C#, VB.NET, ASP) / Separar binario por cada byte en: 1 Abril 2021, 19:15 pm
Hola:

Al mostrar una trama de bytes, lo presento en binario y me muestra esto.

001000111100011110010111110000001011000000001101

Hay 6 Bytes que en realidad en hexadecimal es 23 C7 97 C0 B0 0D

Quiero que se me separe así en cada byte o cada 8 bit.

00100011 11000111 10010111 11000000 10110000 00001101

He intentado hacerlo con este código:
Código
  1.             // Pasar a binario.
  2.             foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
  3.  
  4.             {
  5.                 richTextBox1.Text += leer.ToString();
  6.             }

Me pasa dos cosas.
Como en el ejemplo de arriba, si los bits empieza por cero y encuentro un uno, por ejemplo. 00000001, en la pantalla me aparece solo el 1 ignorando los sietes primeros 0. Me gusta más que se muestre así 00000001 en vez de tipo ahorrador con solo un 1.

La otra cosa, que por cada 8 bytes en binario se muestre separado como indicado arriba.

¿Es posible hacerlo?

Gracias.
259  Programación / .NET (C#, VB.NET, ASP) / Re: Leer información de una SAI / UPS en: 1 Abril 2021, 05:28 am
Buenas:

Me está dando resultados diferentes de un terminal que el propio mio en hexadecimal y no se el motivo. Cuando los datos recibidos son los mismos.


Ver Zoom.

Quiero saber el motivo. Muchas gracias.

Configuración puerto serie.

Ver zoom.

Código C#:
Código
  1. using System;
  2. using System.IO.Ports;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Windows.Forms;
  6.  
  7. namespace Terminal_UPS_SAI_02
  8. {
  9.     public partial class Form1 : Form
  10.     {
  11.         // Utilizaremos un string como buffer de recepción.
  12.         string recibidos;
  13.  
  14.         public Form1()
  15.         {
  16.             InitializeComponent();
  17.         }
  18.  
  19.         private void Form1_Load(object sender, EventArgs e)
  20.         {
  21.             try
  22.             {
  23.                 // Añado los puertos disponible en el PC con SerialPort.GetPortNames() al comboBox_Puerto.
  24.                 comboBox_Puerto.DataSource = SerialPort.GetPortNames();
  25.  
  26.                 // Añade puertos disponibles físicos  y virtuales.
  27.                 serialPort1.PortName = comboBox_Puerto.Text.ToString();
  28.  
  29.                 // Añadir en la variable recibidos datos codificados.
  30.                 recibidos += serialPort1.Encoding = Encoding.GetEncoding(437);
  31.  
  32.                 // Añadir datos recibidos en el evento.
  33.                 serialPort1.DataReceived += new SerialDataReceivedEventHandler(serialPort1_DataReceived);
  34.             }
  35.  
  36.             catch
  37.             {
  38.                 MessageBox.Show("No encuentra ningún puerto físico ni virtual.", "Aviso:",
  39.                     MessageBoxButtons.OK, MessageBoxIcon.Warning);
  40.             }
  41.         }
  42.  
  43.         // Detecta USB o puerto serie virtual cuando lo conecta y desconecta del cable.
  44.         protected override void WndProc(ref Message USB)
  45.         {
  46.             if (USB.Msg == 0x219)
  47.             {
  48.                 comboBox_Puerto.DataSource = SerialPort.GetPortNames();
  49.             }
  50.  
  51.             // Detecta si hay cambios en el usb y si los hay los refleja.
  52.             base.WndProc(ref USB); 
  53.         }
  54.  
  55.         private void button_Conectar_Click(object sender, EventArgs e)
  56.         {
  57.             try
  58.             {
  59.                 serialPort1.PortName = comboBox_Puerto.Text.ToString(); // Puerto seleccionado previamente.
  60.                 serialPort1.BaudRate = Convert.ToInt32(comboBox_Baudios.Text); // Baudios.
  61.                 serialPort1.Open(); // Abrir puerto.
  62.                 comboBox_Puerto.Enabled = false;
  63.                 comboBox_Baudios.Enabled = false;
  64.                 button_Conectar.Enabled = false;
  65.                 button_Desconectar.Enabled = true;
  66.                 groupBox_Control_Zumbador.Enabled = true;
  67.             }
  68.             catch (Exception error)
  69.             {
  70.                 MessageBox.Show(error.Message, "Aviso:",
  71.                 MessageBoxButtons.OK, MessageBoxIcon.Warning);
  72.             }
  73.         }
  74.  
  75.         private void button_Desconectar_Click(object sender, EventArgs e)
  76.         {
  77.             try
  78.             {
  79.                 serialPort1.Close(); // Cerrar puerto.
  80.                 comboBox_Puerto.Enabled = true;
  81.                 comboBox_Baudios.Enabled = true;
  82.                 button_Conectar.Enabled = true;
  83.                 button_Desconectar.Enabled = false;
  84.                 groupBox_Control_Zumbador.Enabled = false;
  85.             }
  86.  
  87.             catch (Exception error)
  88.             {
  89.                 MessageBox.Show(error.Message, "Aviso:",
  90.                 MessageBoxButtons.OK, MessageBoxIcon.Warning);
  91.             }
  92.         }
  93.  
  94.         // Al cerrar el formulario, cierra el puerto si está abierto.
  95.         private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  96.         {
  97.             try
  98.             {
  99.                 serialPort1.Close(); // Cerrar puerto.
  100.             }
  101.  
  102.             catch (Exception error)
  103.             {
  104.                 MessageBox.Show(error.Message, "Aviso:",
  105.                 MessageBoxButtons.OK, MessageBoxIcon.Warning);
  106.             }
  107.         }
  108.  
  109.         // Al recibir datos.
  110.         private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
  111.         {
  112.             // Acumula los caracteres recibidos a nuestro 'buffer' (string).
  113.             recibidos += serialPort1.ReadExisting();
  114.  
  115.             // Invocar o llamar al proceso de tramas.
  116.             Invoke(new EventHandler(Actualizar));
  117.         }
  118.  
  119.         // Procesar los datos recibidos en el bufer y extraer tramas completas.
  120.         private void Actualizar(object sender, EventArgs e)
  121.         {
  122.  
  123.             // Asignar el valor de la trama al richTextBox.
  124.             richTextBox1.Text += recibidos;
  125.  
  126.             // Pasar a hexadecimal.
  127.             foreach (byte b in recibidos)
  128.             {
  129.                 // x = minúscula, X = mayúscula.
  130.                 richTextBox1.Text += b.ToString("X2");
  131.             }
  132.  
  133.             // Nueva línea.
  134.             richTextBox1.Text += Environment.NewLine;
  135.  
  136.             // Pasar a binario.
  137.             foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
  138.  
  139.             {
  140.                 richTextBox1.Text += leer.ToString();
  141.             }
  142.  
  143.             // Nueva línea.
  144.             richTextBox1.Text += Environment.NewLine;
  145.             richTextBox1.Text += Environment.NewLine;
  146.  
  147.             // Selecciona la posición final para leer los mensajes entrantes.
  148.             richTextBox1.SelectionStart = richTextBox1.Text.Length;
  149.  
  150.             // Mantiene el scroll en la entrada de cada mensaje.
  151.             richTextBox1.ScrollToCaret();
  152.  
  153.             // Limpiar.
  154.             recibidos = "";
  155.         }
  156.  
  157.         private void button_Activar_Click(object sender, EventArgs e)
  158.         {
  159.             //byte[] mBuffer = Encoding.ASCII.GetBytes("K60:1\r"); // Comando K60:1 activar.
  160.             byte[] mBuffer = Encoding.ASCII.GetBytes("X87\r"); // Comando X87 Flags.
  161.             serialPort1.Write(mBuffer, 0, mBuffer.Length);
  162.         }
  163.  
  164.         private void button_Desactivar_Click(object sender, EventArgs e)
  165.         {
  166.             byte[] mBuffer = Encoding.ASCII.GetBytes("K60:0\r"); // Comando K60:0 desactivar.
  167.             serialPort1.Write(mBuffer, 0, mBuffer.Length);
  168.         }
  169.  
  170.         private void button_Mute_temporal_Click(object sender, EventArgs e)
  171.         {
  172.             byte[] mBuffer = Encoding.ASCII.GetBytes("K60:2\r"); // Comando K60:2 Mute temporal.
  173.             serialPort1.Write(mBuffer, 0, mBuffer.Length);
  174.         }
  175.  
  176.         private void button_Limpiar_Click(object sender, EventArgs e)
  177.         {
  178.             // Limpiar.
  179.             richTextBox1.Clear();
  180.         }
  181.     }
  182. }

¿Alguna idea?

Saludos camaradas. ;)
260  Programación / .NET (C#, VB.NET, ASP) / Re: Leer información de una SAI / UPS en: 31 Marzo 2021, 00:59 am
Hola:

Haciendo experimento, aunque no me sale del todo bien, probando la página 15 / 21 del documento. Si me funciona el Activar y Desactivar el Zumbador de la UPS y en el display me muestra que si funcina.

Aquí les dejo avances.
Páginas: 1 ... 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 [26] 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 ... 261
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines