Mensajes

[DexDrive.cs]

Hola:

Que casualidad. He encontrado esa página hace minutos y lo iba a publucar, ejjeje. Gracias de todas maneras.

He estado mirando el código por el aire, por lo poco que he visto, tiene muchas funciones que no me interesa, como cambiar el icono, añadir si es de Europa o Japón o de E.E.U.U. Solo me interesa que sea similar y lo justo al DeXplorer 2.0 si es posible.

Concretamente mirando el código de la clase DexDrive.cs.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Threading;

namespace DexDriveCommunication
{
    class DexDrive
    {
        enum DexCommands { INIT = 0x00, STATUS = 0x01, READ = 0x02, WRITE = 0x04, LIGHT = 0x07, MAGIC_HANDSHAKE = 0x27 };
        enum DexResponses { POUT = 0x20, ERROR = 0x21, NOCARD = 0x22, CARD = 0x23, WRITE_OK = 0x28, WRITE_SAME = 0x29, WAIT = 0x2A, ID = 0x40, DATA = 0x41 };

        //DexDrive communication port
        SerialPort OpenedPort = null;

        //Contains a firmware version of a detected device
        string FirmwareVersion = null;

        //Init DexDrive (string returned if an error happened)
        public string StartDexDrive(string ComPortName)
        {
            //Define a port to open
            OpenedPort = new SerialPort(ComPortName, 38400, Parity.None, 8, StopBits.One);
            OpenedPort.ReadBufferSize = 256;

            //Buffer for storing read data from the DexDrive
            byte[] ReadData = null;

            //Try to open a selected port (in case of an error return a descriptive string)
            try { OpenedPort.Open(); }
            catch (Exception e) { return e.Message; }

            //Dexdrive won't respond if RTS is not toggled on/off
            OpenedPort.RtsEnable = false;
            Thread.Sleep(300);
            OpenedPort.RtsEnable = true;
            Thread.Sleep(300);

            //DTR line is used for additional power
            OpenedPort.DtrEnable = true;

            //Check if DexDrive is attached to the port
            //Detection may fail 1st or 2nd time, so the command is sent 5 times
            for (int i = 0; i < 5; i++)
            {
                OpenedPort.DiscardInBuffer();
                OpenedPort.Write("XXXXX");
                Thread.Sleep(20);
            }

            //Check for "IAI" string
            ReadData = ReadDataFromPort();
            if (ReadData[0] != 0x49 || ReadData[1] != 0x41 || ReadData[2] != 0x49) return "DexDrive was not detected on '" + ComPortName + "' port.";

            //Wake DexDrive up (kick it from POUT mode)
            SendDataToPort((byte)DexCommands.INIT, new byte[] { 0x10, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0xAA, 0xBB, 0xCC, 0xDD }, 50);
            //SendDataToPort((byte)DexCommands.INIT, new byte[] { 0x10, 0x29, 0x23, 0xbe, 0x84, 0xe1, 0x6c, 0xd6, 0xae, 0x52, 0x90, 0x49, 0xf1, 0xf1, 0xbb, 0xe9, 0xeb }, 50);

            //Check for "PSX" string
            ReadData = ReadDataFromPort();
            if (ReadData[5] != 0x50 || ReadData[6] != 0x53 || ReadData[7] != 0x58) return "Detected device is not a PS1 DexDrive.";

            //Fetch the firmware version
            FirmwareVersion = (ReadData[8] >> 6).ToString() + "." + ((ReadData[8] >> 2) & 0xF).ToString() + (ReadData[8] & 0x3).ToString();

            //Send magic handshake signal 10 times
            for (int i = 0; i < 10; i++) SendDataToPort((byte)DexCommands.MAGIC_HANDSHAKE, null, 0);
            Thread.Sleep(50);

            //Turn on the status light
            SendDataToPort((byte)DexCommands.LIGHT, new byte[] { 1 }, 50);

            //Everything went well, DexDrive is ready to recieve commands
            return null;
        }

        //Cleanly stop working with DexDrive
        public void StopDexDrive()
        {
            if (OpenedPort.IsOpen == true) OpenedPort.Close();
        }

        //Get the firmware version of a DexDrive
        public string GetFirmwareVersion()
        {
            return FirmwareVersion;
        }

        //Send DexDrive command on the opened COM port with a delay
        private void SendDataToPort(byte Command, byte[] Data, int Delay)
        {
            //Clear everything in the input buffer
            OpenedPort.DiscardInBuffer();

            //Every command must begin with "IAI" string
            OpenedPort.Write("IAI" + (char)Command);
            if (Data != null) OpenedPort.Write(Data, 0, Data.Length);

            //Wait for a required timeframe (for the DexDrive response)
            if (Delay > 0) Thread.Sleep(Delay);
        }

        //Catch the response from a DexDrive
        private byte[] ReadDataFromPort()
        {
            //Buffer for reading data
            byte[] InputStream = new byte[256];

            //Read data from DexDrive
            if(OpenedPort.BytesToRead != 0)OpenedPort.Read(InputStream, 0, 256);

            return InputStream;
        }

        //Read a specified frame of a Memory Card
        public byte[] ReadMemoryCardFrame(ushort FrameNumber)
        {
            //Buffer for storing read data from the DexDrive
            byte[] ReadData = null;

            //128 byte frame data from a Memory Card
            byte[] ReturnDataBuffer = new byte[128];

            int DelayCounter = 0;

            byte FrameLsb = (byte)(FrameNumber & 0xFF);     //Least significant byte
            byte FrameMsb = (byte)(FrameNumber >> 8);       //Most significant byte
            byte XorData = (byte)(FrameLsb ^ FrameMsb);     //XOR variable for consistency checking

            //Read a frame from the Memory Card
            SendDataToPort((byte)DexCommands.READ, new byte[] { FrameLsb, FrameMsb }, 0);

            //Wait for the buffer to fill
            while (OpenedPort.BytesToRead < 133 && DelayCounter < 16)
            {
                Thread.Sleep(5);
                DelayCounter++;
            }

            //Read Memory Card data
            ReadData = ReadDataFromPort();

            //Copy received data (filter IAI prefix)
            Array.Copy(ReadData, 4, ReturnDataBuffer, 0, 128);

            //Calculate XOR checksum
            for (int i = 0; i < 128; i++)
            {
                XorData ^= ReturnDataBuffer[i];
            }

            //Return null if there is a checksum missmatch
            if (XorData != ReadData[132]) return null;

            //Return read data
            return ReturnDataBuffer;
        }

        //Write a specified frame to a Memory Card
        public bool WriteMemoryCardFrame(ushort FrameNumber, byte[] FrameData)
        {
            //Buffer for storing read data from the DexDrive
            byte[] ReadData = null;

            byte FrameLsb = (byte)(FrameNumber & 0xFF);                                 //Least significant byte
            byte FrameMsb = (byte)(FrameNumber >> 8);                                   //Most significant byte
            byte RevFrameLsb = ReverseByte(FrameLsb);                                   //Reversed least significant byte
            byte RevFrameMsb = ReverseByte(FrameMsb);                                   //Reversed most significant byte
            byte XorData = (byte)(FrameMsb ^ FrameLsb ^ RevFrameMsb ^ RevFrameLsb);     //XOR variable for consistency checking

            int DelayCounter = 0;

            //Calculate XOR checksum
            for (int i = 0; i < 128; i++)
            {
                XorData ^= FrameData[i];
            }

            //Write a frame to a Memory Card
            SendDataToPort((byte)DexCommands.WRITE, new byte[] { FrameMsb, FrameLsb, RevFrameMsb, RevFrameLsb }, 0);        //Frame number
            OpenedPort.Write(FrameData, 0, FrameData.Length);                                                               //Save data
            OpenedPort.Write(new byte[] { XorData }, 0, 1);                                                                 //XOR Checksum

            //Wait for the buffer to fill
            while (OpenedPort.BytesToRead < 4 && DelayCounter < 20)
            {
                Thread.Sleep(5);
                DelayCounter++;
            }

            //Fetch DexDrive's response to the last command
            ReadData = ReadDataFromPort();

            //Check the return status (return true if all went OK)
            if (ReadData[0x3] == (byte)DexResponses.WRITE_OK || ReadData[0x3] == (byte)DexResponses.WRITE_SAME) return true;

            //Data was not written sucessfully
            return false;
        }

        //Reverse order of bits in a byte
        byte ReverseByte(byte InputByte)
        {
            byte ReturnByte = new byte();

            int i = 0;
            int j = 7;

            while (i < 8)
            {
                if((InputByte & (1 << i)) > 0) ReturnByte |= (byte)(1 << j);

                i++;
                j--;
            }

            //Return reversed byte
            return ReturnByte;
        }
    }
}


La parte de enumerar los hedaceimales sean comandos o respuestas está muy cómodo.

Código (csharp) [Seleccionar] Expandir

        enum DexCommands { INIT = 0x00, STATUS = 0x01, READ = 0x02, WRITE = 0x04, LIGHT = 0x07, MAGIC_HANDSHAKE = 0x27 };
        enum DexResponses { POUT = 0x20, ERROR = 0x21, NOCARD = 0x22, CARD = 0x23, WRITE_OK = 0x28, WRITE_SAME = 0x29, WAIT = 0x2A, ID = 0x40, DATA = 0x41 };

Por supuesto, tengo el componente serialPort1 en el formulario, no se el motivo de que este usuario lo ha puesto a base de códigos. En fin, cuestión de gustos.

Código (csharp) [Seleccionar] Expandir

            //Define a port to open
            OpenedPort = new SerialPort(ComPortName, 38400, Parity.None, 8, StopBits.One);
            OpenedPort.ReadBufferSize = 256;

Voy hacer el código desde 0, así me ahorro muchas cosas que tiene este ejemplo, solo me centraré en el DexDrive. Poco a poco pondré avances y/o pedir ayuda.

Saludos.

Hola:

Lo he intentado así, pero no funciona.

Código (csharp) [Seleccionar] Expandir

           richTextBox.AppendText(Recibidos);

            richTextBox.VerticalScrollBarVisibility { get; set; }

            var doc = new FlowDocument();
            doc.Blocks.Add(new Paragraph(new Run(Recibidos)));
            richTextBox.Document = doc;

            richTextBox.ScrollToEnd();

Espero que no tenga que tocar nada en el XML.

Saludos.

[IAI (0x49 0x41 0x49) + INIT (0x00) + caractéres raros que son (0x10 0x29 0x23 0xbe 0x84 0xe1 0x6c 0xd6 0xae 0x52 0x90 0x49 0xf1 0xf1 0xbb 0xe9 0xeb) + MAGIC_HANDSHAKE (0x27)]

Hola campeón:

En mi caso el que tengo y uso es el de PSx. En el futuro por ebay, todavía, al menos eso dicen, se puede conseguir de paquete para la N64, cuando tenga algún éxito el de PSx, compraré sea como sea el de la N64.

Quiero sejar claro algunos aspectos del puerto serie como indica en la imagen de abajo. Este está hecho con Visual C#, l a mayoría viene por defecto.


Lo comento porque son detalles que no coinside con el que trae por defecto el serialPort1. Por ejemplo, viendo este código.

Código (c) [Seleccionar] Expandir

/* Timeout (in msecs) when waiting for the device to reply */
#define DEX_TIMEOUT 200

En este otro código, también te habla del timeout y más datos.

Código (cpp) [Seleccionar] Expandir

#define DEX_NAME "dexdrive" /* Driver name */
#define DEX_BUFSIZE 261 /* Size of input/output buffer */
#define DEX_TIMEOUT 100 /* Timeout in msecs when waiting */
#define DEX_MAX_RETRY 2 /* Maximum number of retries */
#define DEX_MAX_DEVICES 4 /* Maximum number of devices */

Si ves algo que no me he enterado o se me ha escapado, me avisas, aquí en estos códigos parece que le han puesto nombres diferentes y se me escapa muchas cosas, quiero ponerlo idéntico los valores por si acaso. Como dice arribas antes, se cambia aquí.

Aquí nombra el IAI y demás.

Código (c) [Seleccionar] Expandir

/* Prefix sent with all commands/replies */
#define DEX_CMD_PREFIX "IAI"

/* Default init string used by InterAct's software */
#define DEX_INIT_STR "\x10\x29\x23\xbe\x84\xe1\x6c\xd6\xae\x52" \
"\x90\x49\xf1\xf1\xbb\xe9\xeb"


Estoy ansioso de ver el Led verde encendido del DexDrive. Desde que ejecutes el DeXplorer, se enciende naranja que está comprobado todo, luego se pone verde, desde que cierre el DeXplorer, deja de funcionar el DexDrive y se apaga el Led. Con las pruebas que estoy haciendo, aún no pasa nada.

Con el Visual C#, en el evento Load, es decir, nada más cargar el formulario, hace comprobaciones, si está conectado DexDrive, si hay alguna Memory Card insertada, si la hay, lee los datos y lo muestra en pantalla, concretamente en ListBox parece ser.

Fijarse mucho en la tabla ASCII. Mejor ver imagen aquí que muestra los valores en hexadecimales.



Este es el código que todavía no sirve en Visual C#.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using System.IO.Ports; // No olvidar.

namespace DexPlorer
{
    public partial class Form1 : Form
    {
        // Utilizaremos un string como buffer de recepción.
        string Recibidos;

        public Form1()
        {
            InitializeComponent();

            // Puerto abierto desde que arranca la aplicación.
            if (!serialPort1.IsOpen)
            {
                try
                {
                    serialPort1.Open();
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }
            serialPort1.DataReceived += new SerialDataReceivedEventHandler(Recepcion);
        }

        // Al recibir datos.
        private void Recepcion(object sender, SerialDataReceivedEventArgs e)
        {
            // Acumula los caracteres recibidos a nuestro 'buffer' (string).
            Recibidos += serialPort1.ReadExisting();

            // Invocar o llamar al proceso de tramas.
            Invoke(new EventHandler(Actualizar));

            //Invoke(new EventHandler(IniciarTimer));
        }

        // Procesar los datos recibidos en el bufer y extraer tramas completas.
        private void Actualizar(object sender, EventArgs e)
        {
            // Para ver lo que envía desde el DexDrive hacia esta interfaz de C#.
            // Asignar el valor de la trama al richTextBox.
            richTextBox1.Text = Recibidos;

            // Selecciona la posición final para leer los mensajes entrantes.
            richTextBox1.SelectionStart = richTextBox1.Text.Length;

            // Mantiene el scroll en la entrada de cada mensaje.
            richTextBox1.ScrollToCaret();


            switch (Recibidos)
            {
                // Aquí hay que ejecutar los case cada vez que DexDrive envía
                // los datos.

            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            byte[] mBuffer = new byte[21];
            // El famoso IAI.
            mBuffer[0] = 0x49; // I en ASCII.
            mBuffer[1] = 0x41; // A.
            mBuffer[2] = 0x49; // I.

            // El comando INIT de inicio.
            mBuffer[3] = 0x00; // 0.

            // Caractéres extraños.
            mBuffer[4] = 0x10; // DLE.
            mBuffer[5] = 0x29; // ).
            mBuffer[6] = 0x23; // #.
            mBuffer[7] = 0xBE; // ¥.
            mBuffer[8] = 0x84; // ä.
            mBuffer[9] = 0xE1; // ß.
            mBuffer[10] = 0x6C; // l.
            mBuffer[11] = 0xD6; // Í.
            mBuffer[12] = 0xAE; // «.
            mBuffer[13] = 0x52; // R.
            mBuffer[14] = 0x90; // É.
            mBuffer[15] = 0x49; // I.
            mBuffer[16] = 0xF1; // ±.
            mBuffer[17] = 0xF1; // ±.
            mBuffer[18] = 0xBB; // ╗.
            mBuffer[19] = 0xE9; // Ú.
            mBuffer[20] = 0xEB; // Ù.
            serialPort1.Write(mBuffer, 0, mBuffer.Length);

            // Activa el timer para enviar el MAGIC_HANDSHAKE.
            timer1.Enabled = true;
            // timer1.Start(); // También válido para activar el timer1.
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            // Envía MAGIC_HANDSHAKE
            byte[] mBuffer = new byte[1];

            // Comando MAGIC_HANDSHAKE.
            mBuffer[0] = 0x27; // '.
            serialPort1.Write(mBuffer, 0, 1); // Envía el byte.
            timer1.Enabled = false; // Detiene el timer1 de 100 ms el intervalo.
            // timer1.Stop();
        }
    }
}


En la parte final, se le puede poner esto así para tener más precisión, es decir, la cantidad de byte completo porque se cuanto es. Por ahora lo dejo indicado arriba.

Código (csharp) [Seleccionar] Expandir

serialPort1.Write(mBuffer, 0, 21);

Estoy ahora en la parte, leyendo bien lo que has escrito arriba de recibir datos directo del DexDrive, dejo claro que la versión o Firmware de mi DexDrive es el mismo que el creador del código de Linux.



En resumen, puede que me equivoque. Envío esta trama de bytes todo junto.
IAI (0x49 0x41 0x49) + INIT (0x00) + caractéres raros que son  (0x10 0x29 0x23 0xbe 0x84 0xe1 0x6c 0xd6 0xae 0x52 0x90 0x49 0xf1 0xf1 0xbb 0xe9 0xeb) + MAGIC_HANDSHAKE (0x27)

Recibo en el chivato richTextBox esto: ?IAI!

Espero haberte ayudado.

Y tanto que me has y estás ayudando. Encantado y agradecido estoy, ya que tienes las cosas claras y aportas mucho para seguir adelante.

Un cordial saludo.

[1)]

Hola:

Eso me pasa porque estoy usando el traductor de google ya que no se Inglés, gracias por la aclaración. creí que el IAI es lo que te devuelve, me devolvía solo esto y a veces, "?", un interrogación y sin dobles comillas. Por lo que veo, entregar un total de 21 bytes. Siguiendo con las pruebas, el código par entragar esas tramas de bytes es esta.

Código (csharp) [Seleccionar] Expandir

        private void button6_Click(object sender, EventArgs e)
        {
            byte[] mBuffer = new byte[21];
            mBuffer[0] = 0x49;
            mBuffer[1] = 0x41;
            mBuffer[2] = 0x49;
            mBuffer[3] = 0x00;
            mBuffer[4] = 0x10;
            mBuffer[5] = 0x29;
            mBuffer[6] = 0x23;
            mBuffer[7] = 0xBE;
            mBuffer[8] = 0x84;
            mBuffer[9] = 0xE1;
            mBuffer[10] = 0x6C;
            mBuffer[11] = 0xD6;
            mBuffer[12] = 0xAE;
            mBuffer[13] = 0x52;
            mBuffer[14] = 0x90;
            mBuffer[15] = 0x49;
            mBuffer[16] = 0xF1;
            mBuffer[17] = 0xF1;
            mBuffer[18] = 0xBB;
            mBuffer[19] = 0xE9;
            mBuffer[20] = 0xEB;
            serialPort1.Write(mBuffer, 0, mBuffer.Length);
        }
    }

No devuelve nada y no hace nada. Antes me devolvía ? y a veces.

Configuración del HyperTerminal.


Desde que pulse cualquier letra del teclado, me devuelve IAI como puedes ver abajo. Por eso creí que no hay que enviarlo todo junto.


¿Relamente hay que usar IAI como indicas y luego el 0x00?

Me da que el DRT y DTS también se usa y lo he puesto en true por si acaso.


Dicen que se puede hacer trampa si los une físicamente.

http://www.moxa.com/resource_file/509820091121333.pdf

Lo quiero hacer sin usar trampas.

Por saber.
1) ¿Dónde sacas que me va a enviar su ID?
2) ¿Cómo puedo saber esa ID?

Parece ser que debo interpretar bien el protocolo de este enlace.

Cualquier apoyo en bienvenido, haber si sacamos una respuesta.

El comportamiento desde que ejecute el DeXplorer con el puerto COM1, parece que que comprueba si está el DexDrive conectado y la Memory Card si está insertada o no con el Led naranja, luego al tiempo se pone verde si no hace nada. Cualquier comando que envíes se pone naranja.

Por lo que haz contado arriba, hay que enviarle 100 ms a magic handshake. Me explicas mejor si es posible lo del magic handshake, aún no lo capto. ;(

Tendré que suar en el Visual C# (más adleante usaré Visual Basic .net para tenerlo también para los demás que le interese) un timer.

Saludos.

Hola:

Antes que nada, disculpen si esto no va aquí. Llevo un tiempo averguando como se controla el famoso y popular de la época de piedra el DexDrive con Visual Studio. Es un dispositivo que lee y guarda los datos de la Memory Card de la PlayStation 1 en el PC por puerto serie, lo que se usaba mucho en la época de antes.



Lo he desarmado.



Tiene un Led verde, cuando envia o recibe datos, se cambia a naranja, todo esto con el puerto COM1. Si no ejecutas su aplicación llamado DeXplorer 2.0.920, no funciona nada aunque lo tengas alimentado, me refiero el Led. Sospecho que usa RTS, CTS, DTR, etc. A parte de los Rx, Tx y GND.

Aquí encontré una aplicación o código fuente que no entiendo ni papa y quiero adaptarlo a Visual C#, más bien hacer una interfaz como el DexPlorer, al menos más moderno. Lo curioso que DeXplorer sabe cuando está conectado el dispositivo DexDrive, si tiene la Memory Card insertada o no.

Tal vez aquí me indique como hacerlo.
https://github.com/fbriere/linux-dexdrive/blob/master/protocol.txt

Esos códigos quiero de C, que por eso lo he puesto aquí, pasarlo a Visual C#. El diseño lo tengo hecho, solo el diseño, no la programación.

He intentado hacer caso esta parte en Visual C#.

COMMANDS
--------

 For all commands specifying a (16-bit) frame number, <lsb> and <msb> are,
 respectively, its least and most significant bytes.  Make sure to pay close
 attention to the order, as it varies between commands.

 Note that the Nintendo 64 DexDrive will get stuck if it is sent an
 incomplete command.  At that point, the only solution is to unplug it
 completely, and plug it back (power first, then serial).

0x00  INIT

 Args: <17 bytes>
 Reply: ID

 Initializes the DexDrive; see the POUTING section below.

 The contents of the 17 bytes does not appear to have any significance,
 except for determining the contents of the "weird" byte in the ID reply.
 See the WEIRD FORMULA section below for more details.

 InterAct's DexPlorer software uses the following hard-coded string:

    10 29 23 be 84 e1 6c d6 ae 52 90 49 f1 f1 bb e9 eb

Enviar esos 17 bytes pero no pasa nada.

Código [Seleccionar] Expandir

       private void button6_Click(object sender, EventArgs e)
       {
           byte[] mBuffer = new byte[17];
           mBuffer[0] = 0x10;
           mBuffer[1] = 0x29;
           mBuffer[2] = 0x23;
           mBuffer[3] = 0xBE;
           mBuffer[4] = 0x84;
           mBuffer[5] = 0xE1;
           mBuffer[6] = 0x6C;
           mBuffer[7] = 0xD6;
           mBuffer[8] = 0xAE;
           mBuffer[9] = 0x52;
           mBuffer[10] = 0x90;
           mBuffer[11] = 0x49;
           mBuffer[12] = 0xF1;
           mBuffer[13] = 0xF1;
           mBuffer[14] = 0xBB;
           mBuffer[15] = 0xE9;
           mBuffer[16] = 0xEB;
           serialPort1.Write(mBuffer, 0, mBuffer.Length);
       }

Ni una respuesta. Creo y no estoy seguro, que los baudios son 38400.

Boceto que hice con Visual C#,sin programarlo aún.


Saludos.

[Edito:]

Hola:

Me he pegado años sin usar RS232, se me ha olvidado muchísimo, ejjejeje. Ahora estoy de nuevo pero con Arduino. Dentro de poco subo las entradas de Arduino por puerto serie, el de encender y apagar un Led ya lo he publicado que puedes ver aquí.

Poco a poco a recordar.

Gracias por todo, cuando acabe el ejemplo completo, lo pongo aquí.

Edito:

He hecho este código. A pesar que se incluye texto y el lo último, no se muestra la barra del scroll.

Código (csharp) [Seleccionar] Expandir

            richTextBox.AppendText(Recibidos);

            var doc = new FlowDocument();
            doc.Blocks.Add(new Paragraph(new Run(Recibidos)));
            richTextBox.Document = doc;

            richTextBox.ScrollToEnd();

No puedo desplazar nada porque no se muestra la barra del lateral o scroll.

¿Se te escapa algo o se me escapa a mi?

Saludos.

Gracias.

Por lo que veo, hay que usar un timer si o si. En mi caso 16 timer, ejejjeje, y que sea indepentiende cada uno.

Sigo investigadno y me fijaré en el fondo tu código.

Hola:

Eso pensé, esos carácteres que no se ven se son los comportamientos, los más usados son \n y \r, pero no los uso.

Aquí hay un ejemplo rápido.
http://www.codeproject.com/Articles/46603/A-PicRS-control-with-a-PIC-microcontroller-seri

Desde que sustituí a richTextBox, se acabaron los problemas, lo curioso que me dicen que use el santo ListBox, ese no me gusta mucho porque eliges línea a línea.

Saludos.

Hola:

Parece más complicado de lo que creía. Tengo que usar 16 temporizadores que al activar uno de ellos empieza por 00:00:00 (HH:MM:SS), y le doy el otro botón parar, se detiene y se pone a 00:00:00 de nuevo.

Por ahora pruebo con dos botones y un contador, lo llamo contador o temporizador o cronómetro para llamarlo de alguna manera.

DEja ver si me sale, luego aviso.

Hola:

Muchas gracias por la ayuda, voy a probar todo palmo a palmo.

En cuanto al usar TextBox,lo hacía antiguamente por el 2008 y prsenté este vídeo. Como verás, no había forma de quitar caracteres raros del principio y fin que muestra este vídeo como prueba.

[youtube=640,360]https://www.youtube.com/watch?v=1sTaKKoGIqA[/youtube]

Dscubrí richTextBox en su época ya por el 2010, ahora con el 2015 me hancontado otros programadores que use listBox, me parece como más incómodo y no se maneja igual que los dos anteriores.

Deja hacer pruebas y te comento, gracias de nuevo por los consejos.

Un cordial saludo.