Mensajes

Buenas:

También queiro saber lo que buscas, saber si el lector está cerrado o abierto el programa, sea del lenguaje que sea. Por ejemplo, si meto con la mano la bandeja, entra solo y el programa sabe cuando está abierto la bandeja o no. Si tngo l abandeja abierta por Windows, ejecuto después el programa, que detecte si está abierto. Los programas que puse arriba no lo sabe.

¿A lo mejor sysinfo vale para lo que buscas?

Veo que en status has comprobado que no vale.

La cuestión es saber si esa posibilidad que buscamos existe.

Saludos.

Hola:

Buscando mciSendString encontré algunas cosas.

Comandos.

status.

¿Qué información quieres sacar exactamente con status?

La verdad no se el motivo.

Mi objeto al tema principal que pregunto. Es conseguir el mismo resultado de abrir y cerrar la bandeja del lector de disco con el lenguaje F#. Puse otros lenguajes que si funciona de C#, VB y C++ para que lo entienda mucha gente. Mi problema que no se hacerlo con F#.

Saludos.

[Código C#:]

Buenas a todos y a todas:



Quiero pasar este código en consola de C#, VB .net o el C++ CLR a F#. Lo que hace el código es si pulsas A o la letra C abre o cierra la bandeja del lector de discos. A parte de C#, también está en C++ CLR y VB .net por si lo entienden mejor. Lo que hace el código es abrir y cerrar la bandeja de discos del lector, sea IDE o SATA.

Código C#:

Código [Seleccionar] Expandir

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace Lector_teclado_consola_cs
{
   class Program
   {
       [DllImport("winmm.dll")]
       public static extern Int32 mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
       int uReturnLength, IntPtr hwndCallback);

       public static StringBuilder rt = new StringBuilder(127);

       public static void DoEvents()
       {
           // Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
           Console.SetCursorPosition(0, 6);
           Console.Write("Abriendo...");
       }

       public static void DoEvents2()
       {
           // Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
           Console.SetCursorPosition(0, 6);
           Console.Write("Cerrando...");
       }

       static void Main(string[] args)
       {
           // Título de la ventana.
           Console.Title = "Control lector de bandeja. C#";

           // Tamaño ventana consola.
           Console.WindowWidth = 29; // X. Ancho.
           Console.WindowHeight = 8; // Y. Alto.

           // Cursor invisible.
           Console.CursorVisible = false;

           // Posición del mansaje en la ventana.
           Console.SetCursorPosition(0, 0);
           Console.Write(@"Control bandeja del lector:

A - Abrir bandeja.
C - Cerrar bandeja.
===========================");



           ConsoleKey key;
           //Console.CursorVisible = false;
           do
           {
               key = Console.ReadKey(true).Key;

               string mensaje = string.Empty;

               //Asignamos la tecla presionada por el usuario
               switch (key)
               {
                   case ConsoleKey.A:
                       // mensaje = "Abriendo...";
                       Console.SetCursorPosition(0, 6);
                       DoEvents();
                       mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
                       mensaje = "Abierto.";
                       break;

                   case ConsoleKey.C:
                       // mensaje = "Cerrando...";
                       Console.SetCursorPosition(0, 6);
                       DoEvents2();
                       mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero);
                       mensaje = "Cerrado.";
                       break;
               }

               Console.SetCursorPosition(0, 6);
               Console.Write("           ");
               Console.SetCursorPosition(0, 6);
               Console.Write(mensaje);

           }
           while (key != ConsoleKey.Escape);
       }
   }
}

Código VB .net:

Código [Seleccionar] Expandir

Imports System.Runtime.InteropServices
Imports System.Text

Module Module1
   <DllImport("winmm.dll")>
   Public Function mciSendString(lpstrCommand As String, lpstrReturnString As StringBuilder, uReturnLength As Integer, hwndCallback As IntPtr) As Int32
   End Function

   Public rt As New StringBuilder(127)

   Public Sub DoEvents()
       ' Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
       Console.SetCursorPosition(0, 6)
       Console.Write("Abriendo...")
   End Sub

   Public Sub DoEvents2()
       ' Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
       Console.SetCursorPosition(0, 6)
       Console.Write("Cerrando...")
   End Sub

   Sub Main()
       ' Título de la ventana.
       Console.Title = "Control lector de bandeja. Visual Basic"

       ' Tamaño ventana consola.
       Console.WindowWidth = 29 ' X. Ancho.
       Console.WindowHeight = 8 ' Y. Alto.
       ' Cursor invisible.
       Console.CursorVisible = False

       ' Posición del mansaje en la ventana.
       Console.SetCursorPosition(0, 0)
       Console.Write("Control bandeja del lector:" & vbCr & vbLf & vbCr & vbLf &
                     "A - Abrir bandeja." & vbCr & vbLf &
                     "C - Cerrar bandeja." & vbCr & vbLf &
                     "===========================")

       Dim key As ConsoleKey
       'Console.CursorVisible = false;
       Do
           key = Console.ReadKey(True).Key

           Dim mensaje As String = String.Empty

           'Asignamos la tecla presionada por el usuario
           Select Case key
               Case ConsoleKey.A
                   ' mensaje = "Abriendo...";
                   Console.SetCursorPosition(0, 6)
                   DoEvents()
                   mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero)
                   mensaje = "Abierto."
                   Exit Select

               Case ConsoleKey.C
                   ' mensaje = "Cerrando...";
                   Console.SetCursorPosition(0, 6)
                   DoEvents2()
                   mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero)
                   mensaje = "Cerrado."
                   Exit Select
           End Select

           Console.SetCursorPosition(0, 6)
           Console.Write("           ")
           Console.SetCursorPosition(0, 6)

           Console.Write(mensaje)
       Loop While key <> ConsoleKey.Escape
   End Sub

End Module


Código C++ CLR:

Código [Seleccionar] Expandir

#include "stdafx.h"

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace System::Text;

[DllImport("winmm.dll")]
extern Int32 mciSendString(String^ lpstrCommand, StringBuilder^ lpstrReturnString,
int uReturnLength, IntPtr hwndCallback);

static void DoEvents()
{
Console::SetCursorPosition(0, 6);
Console::Write("Abriendo...");
}

static void DoEvents2()
{
Console::SetCursorPosition(0, 6);
Console::Write("Cerrando...");
}

int main(array<System::String ^> ^args)
{
StringBuilder^ rt = gcnew StringBuilder(127);

// Título de la ventana.
Console::Title = "Control lector de bandeja. C++ CLR";

// Tamaño ventana consola.
Console::WindowWidth = 29; // X. Ancho.
Console::WindowHeight = 8; // Y. Alto.

 // Cursor invisible.
Console::CursorVisible = false;

// Posición del mansaje en la ventana.
Console::SetCursorPosition(0, 0);
Console::WriteLine("Control bandeja del lector : \n\n" +
"A - Abrir bandeja. \n" +
"C - Cerrar bandeja. \n" +
"========================== \n");
//Console::WriteLine("A - Abrir bandeja.");
//Console::WriteLine("C - Cerrar bandeja.");
//Console::Write("==========================");

ConsoleKey key;
//Console::CursorVisible = false;
do
{
key = Console::ReadKey(true).Key;

String^ mensaje = "";

//Asignamos la tecla presionada por el usuario
switch (key)
{
case ConsoleKey::A:
mensaje = "Abriendo...";
Console::SetCursorPosition(0, 6);
DoEvents();
mciSendString("set CDAudio door open", rt, 127, IntPtr::Zero);
mensaje = "Abierto.";
break;

case ConsoleKey::C:
mensaje = "Cerrando...";
Console::SetCursorPosition(0, 6);
DoEvents2();
mciSendString("set CDAudio door closed", rt, 127, IntPtr::Zero);
mensaje = "Cerrado.";
break;
}

Console::SetCursorPosition(0, 6);
Console::Write("           ");
Console::SetCursorPosition(0, 6);
Console::Write(mensaje);

} while (key != ConsoleKey::Escape);
   return 0;
}

Del .net me falta F# y acabo esta curiosidad y retillo que tengo pendiente desde hace vete a saber.

¿Algún atrevido para poder abrir y cerrar la bandeja del lector usando el lenguaje F#?

Tienes que tener iniciativa para empezar y convencido para terminarlo.

Un cordial saludos a todos y a todas.

Hola:

Aquí hay un código que pulsando A o C abre o cierras la bandeja del lector, a parte de esto, dice Abierto, Abriendo... Cerrado y Cerrando... Todo esto pulsado las teclas A o C.

Me he dado cuenta que si cierro la bandeja directamente con la mano, en la ventana o en el CMD de C#, no lo sabe, se queda en Abierto. La idea es que si cierro la bandeja con la mano, en la pantalla muestre el mensaje.

¿Esto es posible de hacer?

Código [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using static System.Net.Mime.MediaTypeNames;

namespace Lector_teclado_consola_cs
{
    class Program
    {
        [DllImport("winmm.dll")]
        public static extern Int32 mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
        int uReturnLength, IntPtr hwndCallback);

        public static StringBuilder rt = new StringBuilder(127);

        public static void DoEvents()
        {
            // Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
            Console.SetCursorPosition(0, 6);
            Console.Write("Abriendo...");
        }

        public static void DoEvents2()
        {
            // Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
            Console.SetCursorPosition(0, 6);
            Console.Write("Cerrando...");
        }

        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Control lector de bandeja.";

            // Tamaño ventana consola.
            Console.WindowWidth = 55; // X. Ancho.
            Console.WindowHeight = 18; // Y. Alto.

            // Cursor invisible.
            Console.CursorVisible = false;

            // Posición del mansaje en la ventana.
            Console.SetCursorPosition(0, 0);
            Console.Write(@"Control bandeja del lector:

A - Abrir bandeja.
C - Cerrar bandeja.
===========================");



            ConsoleKey key;
            //Console.CursorVisible = false;
            do
            {
                key = Console.ReadKey(true).Key;

                string mensaje = string.Empty;

                //Asignamos la tecla presionada por el usuario
                switch (key)
                {
                    case ConsoleKey.A:
                        // mensaje = "Abriendo...";
                        Console.SetCursorPosition(0, 6);
                        DoEvents();
                        mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
                        mensaje = "Abierto.";
                        break;

                    case ConsoleKey.C:
                        // mensaje = "Cerrando...";
                        Console.SetCursorPosition(0, 6);
                        DoEvents2();
                        mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero);
                        mensaje = "Cerrado.";
                        break;
                }

                Console.SetCursorPosition(0, 6);
                Console.Write("           ");
                Console.SetCursorPosition(0, 6);
                Console.Write(mensaje);

            } while (key != ConsoleKey.Escape);
        }
    }
}

Sólo debo modificar o ampliar esa función que falta para dejar el programa más completo.

Saludos.

Lo he intentado y no aparece la plantilla que indica en el enlace que pusiste.

[Código de Python:]

Buenas:

Tengo un código de Python y quiero ejecutarlo en Visual Studio. Nunca he tratado de hacer ejecutar un código de Python, a ver si sale.

He instalado los componentes necesario.

Código de Python:

Código (python) [Seleccionar] Expandir

import os, sys, tkFileDialog,Tkinter

root = Tkinter.Tk()
root.withdraw()

formats = [ ('Roms Super Nintendo SMC','.smc'),('Roms Super Nintendo SFC','.sfc'),('Fichier Bin','.bin'),('Roms Super Nintendo','.smc .sfc .bin') ]

input = tkFileDialog.askopenfile(parent=root,mode='rb',filetypes=formats,title='Elija el archivo para swapper')
if not input:
print "¡Imposible de abrir el archivo!"
sys.exit()

output = tkFileDialog.asksaveasfile(parent=root,mode='wb',filetypes=formats,title='Elija el archivo de salida')
if not output:
print "¡No se puede crear el archivo de salida!"
sys.exit()


# Lectura del archivo de entrada a un array de bytes
data = bytearray(input.read())

# Calculando el tamaño de la habitación en 2 exponentes
expsize = 0
bytesize = len(data)
while bytesize > 1:
expsize += 1
bytesize = bytesize // 2

# Unidad de un tamaño adecuado matriz de bytes vacíos
buffer = bytearray()
for i in range(2**expsize): buffer.append(0)

# let's do the swap
count = 0
for i in range(len(data)):
addr = (i & 0x7fff) + ((i & 0x008000) << (expsize - 16)) + ((i & 0x010000) >> 1) + ((i & 0x020000) >> 1) + ((i & 0x040000) >> 1) + ((i & 0x080000) >> 1) + ((i & 0x100000) >> 1) + ((i & 0x200000) >> 1)
if addr != i: count += 1
buffer[addr] = data[i]
print "Swapped %s (%s) addresses" % (count, hex(count))

# Escribir archivo de salida
output.write(buffer)

# Cerrar carpetas de archivos
input.close()
output.close()

Creo el proyecto de Python pero no tengo idea donde hay que darle exactamente con todo lo que tiene.


¿Alguna idea?

Saludos.

Hola:
Tengo este código hecho desde NetBeans y quiero adaptarlo a Eclipse. La verdad no sale igual.

NetBeans:

Código (java) [Seleccionar] Expandir


import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

/**
*
* @author Ángel Acaymo M. G. (Meta).
*/
//##############################JM################################################
/* La clase debe implementar la interfaz SerialPortEventListener porque esta
misma clase será la encargada de trabajar con el evento escucha cuando reciba
datos el puerto serie. */
public class EP_JAVA_Frame extends javax.swing.JFrame implements SerialPortEventListener {
//##############################JM################################################

    /**
     * Creates new form EP_JAVA_Frame
     */
    // Variables.
    private static final String Led_8_ON = "Led_8_ON";
    private static final String Led_8_OFF = "Led_8_OFF";
    private static final String Led_13_ON = "Led_13_ON";
    private static final String Led_13_OFF = "Led_13_OFF";

    // Variables de conexión.
    private OutputStream output = null;
//##############################JM################################################
/* Así como declaraste una variable ouuput para obtener el canal de salida
     también creamos una variable para obtener el canal de entrada. */
    private InputStream input = null;
//##############################JM################################################
    SerialPort serialPort;
    private final String PUERTO = "COM4";
    private static final int TIMEOUT = 2000; // 2 segundos.
    private static final int DATA_RATE = 115200; // Baudios.

    public EP_JAVA_Frame() {
        initComponents();
        inicializarConexion();
    }

    public void inicializarConexion() {
        CommPortIdentifier puertoID = null;
        Enumeration puertoEnum = CommPortIdentifier.getPortIdentifiers();

        while (puertoEnum.hasMoreElements()) {
            CommPortIdentifier actualPuertoID = (CommPortIdentifier) puertoEnum.nextElement();
            if (PUERTO.equals(actualPuertoID.getName())) {
                puertoID = actualPuertoID;
                break;
            }
        }

        if (puertoID == null) {
            mostrarError("No se puede conectar al puerto");
            System.exit(ERROR);
        }

        try {
            serialPort = (SerialPort) puertoID.open(this.getClass().getName(), TIMEOUT);
            // Parámatros puerto serie.

            serialPort.setSerialPortParams(DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);

            output = serialPort.getOutputStream();
        } catch (Exception e) {
            mostrarError(e.getMessage());
            System.exit(ERROR);
        }
//##############################JM################################################
/* Aquií asignamos el canal de entrada del puerto serie a nuestra variable input,
         con sus debido capturador de error. */
        try {
            input = serialPort.getInputStream();
        } catch (IOException ex) {
            Logger.getLogger(EP_JAVA_Frame.class.getName()).log(Level.SEVERE, null, ex);
        }

        /* Aquí agregamos el evento de escucha del puerto serial a esta misma clase
         (recordamos que nuestra clase implementa SerialPortEventListener), el método que
         sobreescibiremos será serialevent. */
        try {
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
        } catch (TooManyListenersException ex) {
            Logger.getLogger(EP_JAVA_Frame.class.getName()).log(Level.SEVERE, null, ex);
        }
//##############################JM################################################
    }
//##############################JM################################################
/* Este evento es el que sobreescribiremos de la interfaz SerialPortEventListener,
     este es lanzado cuando se produce un evento en el puerto como por ejemplo
     DATA_AVAILABLE (datos recibidos) */

    @Override
    public void serialEvent(SerialPortEvent spe) {
        if (spe.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
            byte[] readBuffer = new byte[20];
            try {
                int numBytes = 0;
                while (input.available() > 0) {
                    numBytes = input.read(readBuffer); //Hacemos uso de la variable input que
//creamos antes, input es nuestro canal de entrada.
                }
                jTextArea1.append(new String(readBuffer, 0, numBytes, "us-ascii")); // Convertimos de bytes a String y asignamos al JTEXTAREA.
               
                // Leelos últimos datos.
                jTextArea1.setCaretPosition(jTextArea1.getDocument().getLength());
            } catch (IOException e) {
                System.out.println(e);
            }
        }
    }
//##############################JM################################################   

    private void enviarDatos(String datos) {
        try {
            output.write(datos.getBytes());
        } catch (Exception e) {
            mostrarError("ERROR");
            System.exit(ERROR);
        }
    }

    public void mostrarError(String mensaje) {
        JOptionPane.showMessageDialog(this, mensaje, "ERROR", JOptionPane.ERROR_MESSAGE);
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                         
    private void initComponents() {

        jLabel1 = new javax.swing.JLabel();
        jLabel2 = new javax.swing.JLabel();
        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();
        jButton4 = new javax.swing.JButton();
        jScrollPane1 = new javax.swing.JScrollPane();
        jTextArea1 = new javax.swing.JTextArea();
        jLabel3 = new javax.swing.JLabel();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Mini Interfaz Java");

        jLabel1.setText("Led 8");

        jLabel2.setText("Led 13");

        jButton1.setText("ON");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        jButton2.setText("OFF");
        jButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });

        jButton3.setText("ON");
        jButton3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton3ActionPerformed(evt);
            }
        });

        jButton4.setText("OFF");
        jButton4.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton4ActionPerformed(evt);
            }
        });

        jTextArea1.setColumns(20);
        jTextArea1.setRows(5);
        jScrollPane1.setViewportView(jTextArea1);

        jLabel3.setText("Mensajes desde Arduino:");

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 217, Short.MAX_VALUE)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jLabel1)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                        .addComponent(jLabel2))
                    .addGroup(layout.createSequentialGroup()
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false)
                            .addComponent(jButton1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                            .addComponent(jButton2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                            .addComponent(jButton4, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                            .addComponent(jButton3, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jLabel3)
                        .addGap(0, 0, Short.MAX_VALUE)))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel1)
                    .addComponent(jLabel2))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jButton1)
                    .addComponent(jButton3))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jButton2)
                    .addComponent(jButton4))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(jLabel3)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap())
        );

        jLabel1.getAccessibleContext().setAccessibleName("jLabel_Led_8");
        jButton1.getAccessibleContext().setAccessibleName("jButton_Led_8_ON");
        jButton2.getAccessibleContext().setAccessibleName("jButton_Led_8_OFF");
        jButton3.getAccessibleContext().setAccessibleName("jButton_Led_13_ON");
        jButton4.getAccessibleContext().setAccessibleName("jButton_Led_13_OFF");

        pack();
        setLocationRelativeTo(null);
    }// </editor-fold>                       

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        enviarDatos(Led_8_ON); // Enciende Led 8.
    }                                       

    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        enviarDatos(Led_8_OFF); // Apaga Led 8.
    }                                       

    private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        enviarDatos(Led_13_ON); // Enciende Led 13.
    }                                       

    private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        enviarDatos(Led_13_OFF); // Apaga Led 13.
    }                                       

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(EP_JAVA_Frame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(EP_JAVA_Frame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(EP_JAVA_Frame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(EP_JAVA_Frame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new EP_JAVA_Frame().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;
    private javax.swing.JButton jButton4;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTextArea jTextArea1;
    // End of variables declaration                   
}


Lo he intentado paso por paso, pero no se me da.

Eclipse:

Código (java) [Seleccionar] Expandir

package electronica;

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import javax.swing.JTextArea;
import java.awt.EventQueue;

public class EP_Java extends JFrame {

private JPanel contentPane;

/**
* Launch the application.
*/
// Variables.
    private static final String Led_ON = "Led_ON";
    private static final String Led_OFF = "Led_OFF";
   
    // Variables de conexión.
    private OutputStream output = null;
    private InputStream input = null;
    SerialPort serialPort;
    private final String PUERTO = "COM4";
    private static final int TIMEOUT = 2000; // 2 segundos.
    private static final int DATA_RATE = 115200; // Baudios.
   
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
EP_Java frame = new EP_Java();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public EP_Java() {
setTitle("Encender y apagar un Led - Java y Arduino");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);

JButton btnOn = new JButton("ON");
btnOn.setBounds(161, 39, 89, 23);
contentPane.add(btnOn);

JButton btnOff = new JButton("OFF");
btnOff.setBounds(161, 73, 89, 23);
contentPane.add(btnOff);

JTextArea textArea_Recibir_mensajes = new JTextArea();
textArea_Recibir_mensajes.setBounds(10, 103, 414, 147);
contentPane.add(textArea_Recibir_mensajes);

inicializarConexion();
}

/**
* Create the frame.
*/
    public void inicializarConexion() {
        CommPortIdentifier puertoID = null;
        Enumeration puertoEnum = CommPortIdentifier.getPortIdentifiers();

        while (puertoEnum.hasMoreElements()) {
            CommPortIdentifier actualPuertoID = (CommPortIdentifier) puertoEnum.nextElement();
            if (PUERTO.equals(actualPuertoID.getName())) {
                puertoID = actualPuertoID;
                break;
            }
        }

        if (puertoID == null) {
            mostrarError("No se puede conectar al puerto");
            System.exit(ERROR);
        }

        try {
            serialPort = (SerialPort) puertoID.open(this.getClass().getName(), TIMEOUT);
            // Parámatros puerto serie.

            serialPort.setSerialPortParams(DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);

            output = serialPort.getOutputStream();
        } catch (Exception e) {
            mostrarError(e.getMessage());
            System.exit(ERROR);
        }
//##############################JM################################################
/* Aquií asignamos el canal de entrada del puerto serie a nuestra variable input,
         con sus debido capturador de error. */
        try {
            input = serialPort.getInputStream();
        } catch (IOException ex) {
            Logger.getLogger(EP_Java.class.getName()).log(Level.SEVERE, null, ex);
        }

        /* Aquí agregamos el evento de escucha del puerto serial a esta misma clase
         (recordamos que nuestra clase implementa SerialPortEventListener), el método que
         sobreescibiremos será serialevent. */
        try {
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
        } catch (TooManyListenersException ex) {
            Logger.getLogger(EP_Java.class.getName()).log(Level.SEVERE, null, ex);
        }
//##############################JM################################################
    }
   
  //##############################JM################################################
    /* Este evento es el que sobreescribiremos de la interfaz SerialPortEventListener,
         este es lanzado cuando se produce un evento en el puerto como por ejemplo
         DATA_AVAILABLE (datos recibidos) */

        public void serialEvent(SerialPortEvent spe) {
            if (spe.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
                byte[] readBuffer = new byte[20];
                try {
                    int numBytes = 0;
                    while (input.available() > 0) {
                        numBytes = input.read(readBuffer); //Hacemos uso de la variable input que
    //creamos antes, input es nuestro canal de entrada.
                    }
                    textArea_Recibir_mensajes.append(new String(readBuffer, 0, numBytes, "us-ascii")); // Convertimos de bytes a String y asignamos al JTEXTAREA.
                   
                    // Leelos últimos datos.
                    textArea_Recibir_mensajes.setCaretPosition(textArea_Recibir_mensajes.getDocument().getLength());
                } catch (IOException e) {
                    System.out.println(e);
                }
            }
        }
    //##############################JM################################################ 
       
        private void enviarDatos(String datos) {
            try {
                output.write(datos.getBytes());
            } catch (Exception e) {
                mostrarError("ERROR");
                System.exit(ERROR);
            }
        }

        public void mostrarError(String mensaje) {
            JOptionPane.showMessageDialog(this, mensaje, "ERROR", JOptionPane.ERROR_MESSAGE);
        }
}


¿Alguna idea?

Saludos.

Hola:

En un textbox tengo un contenido, por ejemplo un 0, al hacer clic para escribir, quiero que se borre automáticamente. Nada de seleccoinarlo yo con el ratón y luego borrarlo con Delete. ajjaja.

Lo he intentado de dos maneras y nada.

Código (csharp) [Seleccionar] Expandir

private void textBox_Tamaño_EEPROM_KeyDown(object sender, KeyEventArgs e)
       {
           textBox_Tamaño_EEPROM.Clear(); // Limpiar.
       }

Y así:

Código (csharp) [Seleccionar] Expandir

      private void textBox_Tamaño_EEPROM_KeyDown(object sender, KeyEventArgs e)
       {
           textBox_Tamaño_EEPROM.Text = ""; // Limpiar.
       }

A parte de eso, solo me deja escribir hasta un carácter.

Averiguado, gracias por la ayuda.

Código (csharp) [Seleccionar] Expandir

      // Variables.
        bool alto = false;
        int N = 0;
        int P = 0;
        int resul = 0;

        private void TestDoEvents()
        {
            // Carga el archivo en el array.
            byte[] archivo = File.ReadAllBytes(textBox_ubicacion_archivo.Text);

            // Hasta donde llegue el tamaño del archivo.
            progressBar_barrra_progreso.Maximum = archivo.Length;

            // Guarda la cantidad de Bytes del archivo en la variable.
            N = archivo.Length - 1;

            // Transmite byte en byte los datos del archivo al puerto serie.
            for (int i = 0; i <= archivo.GetUpperBound(0); i++)
            {
                // Enviando archivo al puerto serie.
                serialPort1.Write(archivo, i, 1);
               
                // Números de Bytes.
                P = i;
               
                // Resultado de la regla de tres. Cálculo del porcentaje de la barra de progreso.
                resul = 100 * i / N;
               
                // Muestra barra del progreso.
                progressBar_barrra_progreso.Value = i;

                // Muestra la cantidad de Bytes enviados.
                label_Bytes_transmitidos.Text = i.ToString() + " Bytes.";

                // Muestra la cantidad en porciento archivo enviado.
                label_Por_ciento.Text = resul + " %";

                // Evento de cancelación.
                Application.DoEvents();
                if (alto == true)
                {
                    alto = false;
                    break; // TODO: might not be correct. Was : Exit For
                }
            }
            button_Cancelar.Text = "Arranque";
        }

        private void button_Cancelar_Click(object sender, EventArgs e)
        {
            if (button_Cancelar.Text == "Arranque")
            {
                button_Cancelar.Text = "Cancelar";
                TestDoEvents();
                progressBar_barrra_progreso.Value = 0; // Resetear progressBar a 0.
                label_Bytes_transmitidos.Text = "0";
            }
            else
            {
                if (alto == true)
                {
                    alto = false;
                }
                else
                {
                    alto = true;
                    button_Cancelar.Text = "Arranque";
                }
            }
        }

Buenas:

Pensaba que era algo así.

Código (csharp) [Seleccionar] Expandir

label_Por_ciento.Text = ((progressBar_barrra_progreso.Value / archivo.Count()) * 100).ToString() + "%";

Voy a probar lo que dices.

Saludos.