Usar todos los pines del puerto serie.

Normalmente se suelen usar los pines para Arduino o el PC el Rx, Tx y GND.

Hay otros pines que por lo que veo, casi nadie usa, solo los de siempre.

¿Qué se puede hacer con los demás pines exactamente?

Llegué a pensar que es capaz de detectar cuando hay un dispositivo conectado, el hardware físico, cosas así.

¿Alguna idea sobre esto?

Saludos.

Si te refieres a las señales RTS, CTS, DTR, etc que vienen en el conector del ordenador, sirven para crear otros protocolos sobre el bus rs232 y conexiones sobre modems. Echale un vistazo en google y verás. A nivel arduino, no veo de momento ningun motivo para usarlos, de momento.

Los pines RX-TX (y GND) son los básicos para una comunicación serie. Por norma general no vas a utilizar más que esos en arduino. Sin embargo, no tener en cuenta los otros puede ser fuente de problemas cuando quieres conectar arduino a un dispositivo RS232 que los utilice, no tanto porque no funcione la comunicación como porque no consigues que el dispositivo te "preste atención". Recuerdo hace ya bastante algún hilo en este foro lidiando con un problema de ese tipo (no recuerdo si una báscula). Finalmente vimos que si conectaba el cacharro al ordenador, a la vez que al arduino, la transmisión se iniciaba y podía continuar sin problemas desconectando el lado del ordenador; pero si no se conectaba al ordenador la báscula permanecía "dormida". Básicamente, hay dos parejas de pines que pueden influir: -DTR (Data Terminal Ready) / DSR (Data Signal Ready). Uno de los dispositivos le dice al otro que está presente mediante DTR y el otro mediante DSR. -RTS (Request To Send) / CTS (Clear To Send). Uno de los dispositivos le solicita "permiso para hablar" por RTS y el otro (si está dispuesto a escucharle) le concede dicho permiso por CTS.

Y la solución para no tener que lidiar con estos pines es un truco llamado handshaking (o algo así) que consiste en puentear ambas parejas en el propio conector para que RTS active directamente CTS y DTR haga lo propio con DSR.

A modo de resumen creo que esta tabla (Extraída de aquí) es bastante explicativa:

  ___________                    ________________________________________
  \1 2 3 4 5/  Looking at pins   \1  2  3  4  5  6  7  8  9  10 11 12 13/
   \6 7 8 9/  on male connector   \14 15 16 17 18 19 20 21 22 23 24 25/
    ------                         -----------------------------------
Pin #   Pin #   Acronym  Full-Name   Direction  What-it-May-Do/Mean
9-pin   25-pin
 3       2      TxD     Transmit Data     -->   Transmits bytes out of PC
 2       3      RxD     Receive Data      <--        Receives bytes into PC
 7       4      RTS     Request To Send   -->   RTS/CTS flow control
 8       5      CTS     Clear To Send     <--        RTS/CTS flow control
 6       6      DSR     Data Set Ready    <--        I'm ready to communicate
 4      20      DTR     Data Terminal Ready-->  I'm ready to communicate
 1       8      DCD     Data Carrier Detect<--       Modem connected to another
 9      22      RI      Ring Indicator    <--        Telephone line ringing
 5       7      SG      Signal Ground

Pregunta: Que quieres hacer con el conector RS232? Cual es tu objetivo?

Hola:

Mi objetivo en un principio controlar un dispositivo que usa todos pines que se ha nombrado, un lector y grabador y se puede hacer copias de seguridad antiguo de Memory Card de la PlayStation 1. En resumen, guarda datos de la memoria al PC como copia de seguridad. Este aparato se llama DexDrive.

Antes que nada, por lo que he leído en Internet, funciona a 38400 baudios.

Su programa original que hay dos versiones, la más usada el 2, desde que ejecutes o abras la aplicación, se enciende el Led verde, antes se pone naranja comprobando la Memory Card. El programa se llama DeXplorer.

Lo abrí y comprobñe los cables.

Antes que nada, llevo años pensando en hacerme una interfaz propia con Visual Studio .net para controlar este dispositivo, como no tengo analizador lógico, lo he dejado. Lo compraré en el futuro cuando tenga €€€€€€.

Tiene un transformador a parte, por mucho que lo alimentes, nunca encenderá el Led verde, ni naranja que significa enviar y recibir datos.

Deduzco que los RTS, CTS, DTR, etc tiene que ver bastante, nunca los he usado en Visual Studio, nadie en la época encontré que sepan cosas de estas, solo lo típico de siempre, con el Rx, Tx y GND.

Está esos modos en modo desactivado en Visual Studio el componente serialPort1 para los que los conozcan. |301x500

No sabía que se podía hacer puente para engañar. Antes de hacer puente entre ello, debo estar más informado y mejor. Así que me voy a bucar más por www.google.es estos temas que antes no me daba inforamción para entenderlo, a lo mejor hay más y sin saberlo hoy en día, ya no estamos en el 2003.

Como el dispositivo solo funciona desde que inices su interfaz original, por ahora no puedo hacer nada, ya que no conozco sus comandos internos. Eso si, la interfaz DeXplorer 2.x sabe cuando está conectado al puerto COM1, cuando tiene la Memory Card insertada, si la quitas o la pones dicha Memory Card lo indica en tiempo real en su interfaz. Por lo que se ve, detecta todo. Lo que me sorprende, que en su interior del DexDrive, no incluye algún tipo de microcontrolador.

Cuando acabe mi propia interfaz para conocerlo a fondo, me meto con Arduino que controle, con LCD incluido y tarjeta micro-SD, esto más adelante claro, primero lo primero.

Les dejo una captura que vi de la primera versión original. |500x377

Por lo que cuentan, hacer puente físicamente como esto. http://www.moxa.com/resource_file/509820091121333.pdf

Aquí parece ser que puedes controlar el DexDrive, lo dejo por si acaso. https://github.com/fbriere/linux-dexdrive/blob/master/dexattach.c https://github.com/fbriere/linux-dexdrive/blob/master/protocol.txt

Un cordial saludo.

PD: Pedazo de palique que ni ganas tendrán de leer, jejeje. ;)

Y por que no conectas la memoria directamente a arduino?

ver aqui

Hola:

Lo he visto, pero solo de modo lectura, por ahora eso lo haré más adelante. ¿El motivo? Porque siempre he querido desde hace años controlar el DexDrive original haciendo mi propio interfaz, más adelante con el propio Arduino.

He intentado hacer caso esta parte en Visual C#.

COMMANDS

For all commands specifying a (16-bit) frame number, and 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.

       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.

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

Saludos.

Hola:

Aquí está lo que necesito. Para los curiosos o los que le hagan falta, aquí les dejo el enlace. https://github.com/ShendoXT/memcarduino/blob/master/MemCARDuino.ino

Aquí una interfaz de Visual C#. https://github.com/ShendoXT/memcardrex/blob/master/MemcardRex/DexDrive.cs

Saludos.

Metaconta prueba esto y usa las conexiones simples de los primeros post

Gracias campeón, no te había leído.

He visto que usa este código.

            // Dexdrive no responderá si RTS no se conmuta on / off.
            OpenedPort.RtsEnable = false;
            Thread.Sleep(300);
            OpenedPort.RtsEnable = true;
            Thread.Sleep(300);

Saludos.

El esquema RS232 que te puse está mas alla de las líneas de handshake que requierían las viejas comnicaciones RS232. Observa que los pines extra se cierran entre si y solo miras RX TX y GND

Buenas noticias.

Al menos para mi, y los que les interesen. Hay que lograr que el DexDrive despierte, aunque envíes los comandos correctos lo ingnorará. Se han complicado la vida haciendo comportamientos para que no le copien el producto, en fin, al final se puede hacer. Lo que he logrado solo hace encender el Led verde, lo que indica que por fin está despierto.

Primera prueba y me costó coger el truco, he logrado encender el Led verde del DexDrive. Por algo se empieza. :wink: Lo que he hecho, solo despierta el DeDrive mostrándolo conel Led verde encendido, está preparado para recibir comandos en el cual aún no lo he programado.

En el cuadro negro, muestra letras en verde los caracteres.

Por ahora, este es el código.

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.
using System.Threading;

namespace DexPlorer
{
    public partial class Form1 : Form
    {
        public enum Dex_Comandos
        {
            INIT = 0x00, STATUS = 0x01, READ = 0x02, SEEK = 0x03, WRITE = 0x04, PAGE = 0x05, LIGHT = 0x07, MAGIC_HANDSHAKE = 0x27
        }

        public enum Dex_Respuestas
        {
            POUT = 0x20, ERROR = 0x21, NOCARD = 0x22, CARD = 0x23, CARD_NEW = 0x25, SEEK_OK = 0x27, WRITE_OK = 0x28, WRITE_SAME = 0x29, WAIT = 0x2A, ID = 0x40, DATA = 0x41
        }

        byte[] TRAMAS = { 0x10, 0x29, 0x23, 0xbe, 0x84, 0xe1, 0x6c, 0xd6, 0xae, 0x52, 0x90, 0x49, 0xf1, 0xf1, 0xbb, 0xe9, 0xeb };

        // Utilizaremos un string como buffer de recepción.
        string Recibidos;

        // Buffer para almacenar leer datos de la DexDrive.
        byte[] Leer_Datos = null;

        // Contiene una versión de firmware de un dispositivo detectado.
        string Firmware_Version = null;

        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());
                }
            }

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

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

            // Comprobar si DexDrive está conectado al puerto.
            // La detección puede fallar primera o segunda vez, por lo que el comando es enviado 5 veces.
            for (int i = 0; i < 5; i++)
            {
                serialPort1.DiscardInBuffer();
                serialPort1.Write("XXXXX");
                Thread.Sleep(20);
            }

            // Compruebe cadena "IAI".
            Leer_Datos = Leer_datos_del_puerto();
            if ((Leer_Datos[0] != 0x49) || (Leer_Datos[1] != 0x41) || (Leer_Datos[2] != 0x49)) return;

            // Despierta DexDrive arriba (patear desde el modo POUT).
            //Envia_dato_al_puerto((byte)Dex_Comandos.INIT, new byte[] { 0x10, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0xAA, 0xBB, 0xCC, 0xDD }, 50);
            Envia_dato_al_puerto((byte)Dex_Comandos.INIT, new byte[] { 0x10, 0x29, 0x23, 0xbe, 0x84, 0xe1, 0x6c, 0xd6, 0xae, 0x52, 0x90, 0x49, 0xf1, 0xf1, 0xbb, 0xe9, 0xeb }, 50);

            // Compruebe cadena "PSX".
            Leer_Datos = Leer_datos_del_puerto();
            if ((Leer_Datos[5] != 0x50) || (Leer_Datos[6] != 0x53) || (Leer_Datos[7] != 0x58)) return; // "Dispositivo detectado no es un PS1 DexDrive."

            // Obtener la versión del firmware.
            Firmware_Version = (Leer_Datos[8] >> 6).ToString() + "." + ((Leer_Datos[8] >> 2) & 0xF).ToString() + (Leer_Datos[8] & 0x3).ToString();

            // Enviar señal de handshake magia 10 veces.
            for (int i = 0; i < 10; i++) Envia_dato_al_puerto((byte)Dex_Comandos.MAGIC_HANDSHAKE, null, 0);
            Thread.Sleep(50);

            // Enciende la luz de estado.
            Envia_dato_al_puerto((byte)Dex_Comandos.LIGHT, new byte[] { 1 }, 50);

            // Todo ha ido bien, DexDrive está listo para recibir comandos.
            //return null;

            Recibidos = Encoding.ASCII.GetString(Leer_Datos);

            // Recibidos = Encoding.Default.GetString(Leer_Datos);

            // 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;

            //    // 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;

            //serialPort1.DataReceived += new SerialDataReceivedEventHandler(Recepcion);
        }

        // Enviar comando DexDrive en el puerto COM se abrió con un retraso.
        private void Envia_dato_al_puerto(byte Comando, byte[] Dato, int Delay)
        {
            // Borrar todo en el búfer de entrada.
            serialPort1.DiscardInBuffer();

            // Cada comando debe comenzar con la cadena "IAI".
            serialPort1.Write("IAI" + (char)Comando);
            if (Dato != null) serialPort1.Write(Dato, 0, Dato.Length);

            // Espere un tiempo establecido (para la respuesta DexDrive).
            if (Delay > 0) Thread.Sleep(Delay);
        }

        // Captura la respuesta de un DexDrive.
        private byte[] Leer_datos_del_puerto()
        {
            // Buffer para la lectura de datos.
            byte[] Flujo_de_entrada = new byte[256];

            // Leer datos de DexDrive.
            if (serialPort1.BytesToRead != 0) serialPort1.Read(Flujo_de_entrada, 0, 256);

            return Flujo_de_entrada;
        }
    }
}

Sigo con ello intentar enviar comandos a ver si se deja, como formatear, leer, borrar, algo.

Felices fiesta.