Temas

Hola:

Estoy usando desde ISE con PowerShell este código. Lo que hace ahora es crear un formulario Windows Form en el cual abre y cierra la bandeja del lector del disco.

Código [Seleccionar] Expandir

$MemDef = @"
[DllImport("winmm.dll", CharSet = CharSet.Ansi)]
   public static extern int mciSendStringA(
   string lpstrCommand,
   string lpstrReturnString,
   int uReturnLength,
   IntPtr hwndCallback);
"@

$winnm = Add-Type -memberDefinition $MemDef -ErrorAction 'SilentlyContinue' -passthru -name mciSendString
function Set-CDAudioDoor {
Param(
  [ValidateSet("open", "closed")][String[]]$Mode = 'open'
)
$winnm::mciSendStringA("set cdaudio door $mode", $null, 0,0)}

[void][reflection.assembly]::loadwithpartialname("System.Windows.Forms")
[void][reflection.assembly]::loadwithpartialname("System.Drawing")


$Form = New-Object system.Windows.Forms.Form
$Form.Text = "PowerShell 2017"
$Form.TopMost = $true
$Form.Width = 300
$Form.Height = 300
$Form.StartPosition = "CenterScreen"



$button_Abrir = New-Object system.windows.Forms.Button
$button_Abrir.Text = "Abrir"
$button_Abrir.Width = 75
$button_Abrir.Height = 23
$button_Abrir.location = new-object system.drawing.point(40, 150)
$button_Abrir.Font = "Microsoft Sans Serif,10"
$Form.controls.Add($button_Abrir)


$button_Cerrar = New-Object system.windows.Forms.Button
$button_Cerrar.Text = "Cerrar"
$button_Cerrar.Width = 75
$button_Cerrar.Height = 23
$button_Cerrar.location = new-object system.drawing.point(174, 150)
$button_Cerrar.Font = "Microsoft Sans Serif,10"
$Form.controls.Add($button_Cerrar)




$label_Mensaje = New-Object system.windows.Forms.Label
$label_Mensaje.Text = "?"
$label_Mensaje.AutoSize = $true
$label_Mensaje.Width = 25
$label_Mensaje.Height = 10
$label_Mensaje.location = new-object system.drawing.point(54,26)
$label_Mensaje.Font = "Microsoft Sans Serif,36,style=Bold"
$Form.controls.Add($label_Mensaje)

# Abrir  bandeja.
$label_Mensaje.Text = "Abriendo..."
$button_Abrir.Add_Click({Set-CDAudioDoor open})
$label_Mensaje.Text = "Abierto."

# Cerrar bandeja.
$label_Mensaje.Text = "Cerrando..."
$button_Cerrar.Add_Click({Set-CDAudioDoor closed})
$label_Mensaje.Text = "Cerrado."

[void]$Form.ShowDialog()
$Form.Dispose() 

Al ejecutar este Script, muestra esta imagen.


Com podrás observar, siempre se ejecuta una detrás otra esta instrucción de mensajes.

Código [Seleccionar] Expandir

$label_Mensaje.Text = "Cerrado."

Mi idea es, que al pulsar el botón Abrir, aparezca el mensaje "Abrriendo...", se abre la bandeja del todo, sale otro mensaje, "Abierto.", lo mismo al pulsar el botón Cerrar.

¿En que fallo?

Saludos.

Hola:

Aquí hay un código hecho en Java usando WMPlayer.OCX.7. Quiero usar en Java mciSendString(L"Set CDAudio Door Open Wait", 0, 0, 0);
Es para abrir y cerrar la bandeja.

Código (java) [Seleccionar] Expandir

/**

*

*/

package com.sabado;



import java.io.File;

import java.io.FileWriter;







/**

* -.-

*

*/

public class Unidad {



/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

//mostramos mensajes antes de abrir las bandejas de CD DVD

javax.swing.JOptionPane.showConfirmDialog((java.awt.Component)

               null, "Pulsa OK para abrir las bandejas de los " +

       "lectores/grabadores de CD/DVD del equipo.", "Abrir CD/DVD",

               javax.swing.JOptionPane.DEFAULT_OPTION);

    Unidad.abrirBandejaCDDVD();



//mostramos mensaje antes de cerrar las bandejas de CD DVD

javax.swing.JOptionPane.showConfirmDialog((java.awt.Component)

         null, "Pulsa OK para cerrar las bandejas de los " +

       "lectores/grabadores de CD/DVD del equipo.", "Cerrar CD/DVD",

         javax.swing.JOptionPane.DEFAULT_OPTION);

    Unidad.cerrarBandejaCDDVD();



}



public static void abrirBandejaCDDVD ()

  {



  try

  {

        File file = File.createTempFile("abrirbandejacd",".vbs");

        file.deleteOnExit();

        FileWriter fw = new java.io.FileWriter(file);

        String vbs = "Set objPlayer = CreateObject(\"WMPlayer.OCX.7\") \n"

                   + "Set collCDROM = objPlayer.cdromCollection \n"

                   + "if collCDROM.Count >= 1 then \n"

                   + "For i = 0 to collCDROM.Count - 1 \n"

   + "collCDROM.Item(i).Eject \n"

   + "Next \n"

   + "End If \n";

        fw.write(vbs);

        fw.close();

        Runtime.getRuntime().exec("wscript " + file.getPath()).waitFor();

    }

    catch(Exception e)

{

        e.printStackTrace();

    }

  }



public static void cerrarBandejaCDDVD()

  {

    try

    {

        File file = File.createTempFile("cerrarbandejacd",".vbs");

        file.deleteOnExit();

        FileWriter fw = new FileWriter(file);

        //para cerrar las bandejas de CD hay que ejecutar "eject" dos veces

        String vbs = "Set objPlayer = CreateObject(\"WMPlayer.OCX.7\") \n"

                   + "Set collCDROM = objPlayer.cdromCollection \n"

                   + "if collCDROM.Count >= 1 then \n"

                   + "For i = 0 to collCDROM.Count - 1 \n"

   + "collCDROM.Item(i).Eject \n"

   + "collCDROM.Item(i).Eject \n"

   + "Next \n"

   + "End If \n";

        fw.write(vbs);

        fw.close();

        Runtime.getRuntime().exec("wscript " + file.getPath()).waitFor();

    }

    catch(Exception e)

{

        e.printStackTrace();

    }

  }

}

¿Algún ejemplo usando mciSendString en Java?

Lo pregunto porque el de arriba es mucho código para lo que hay que hacer, abrir y cerrar la bandeja.

Un ejemplo en C++ se hace en menos líneas de códigos, por ejemplo este indicado abajo.

Paso 1:


Paso 2:


Paso3:
Escribir Winmm.lib.


Paso 4:


Sólo se necesita tres includes.

Código (cpp) [Seleccionar] Expandir

#include "stdafx.h"
#include "Windows.h"
#include "iostream"

using namespace std;

int main()
{
// Título de la ventana.
SetConsoleTitle(L"Consola C++ Win32 2017");

// Variable.
char entrada[] = "\0"; // Guarda A, a, C, y c tipo string que introduces desde la consola.

while (true)
{
// Muestra en pantalla textos.
cout << "Control bandeja del lector: " << endl << endl;
cout << "A - Abrir bandeja." << endl;
cout << "C - Cerrar bandeja." << endl;
cout << "==========================" << endl;

cin >> entrada; // Aquí introduces letras A, a, C, y c.

cout << "\n" << endl;

// Abrir bandeja.
if ((entrada[0] == 'a') || (entrada[0] == 'A'))
{
cout << "Abriendo..." << endl << endl; // Muestra en pantalla textos.
mciSendString(L"set cdaudio door open", nullptr, 0, nullptr);
cout << "Abierto." << endl << endl; // Muestra en pantalla textos.
}
// Cerrar bandeja.
else if ((entrada[0] == 'c') || (entrada[0] == 'C'))
{
cout << "Cerrando..." << endl << endl; // Muestra en pantalla textos.
mciSendString(L"set cdaudio door closed", nullptr, 0, nullptr);
cout << "Cerrado." << endl << endl; // Muestra en pantalla textos.
}
// Si haz pulsado otro caracter distinto de A, C, a, y c aparece
else
{
cout << "Solo pulsar A o C." << endl << endl; // este mensaje.

}
}
return EXIT_SUCCESS;
}

Saludos.

[¿Se puede crear también formularios con el lenguaje Visual F#?]

Hola:

Antes pensaba que PowerShell solo era línea de comandos, el sustituto del CMD de Windows se puede decir. He descubierto hoy que se puede crear formulario tal como lo hace Windows Form de Visual C# o Visual Basic .net.

Aquí hay un editor de formularios para hacerlo más rápido por vía Web y te genera el código para probarlo en el Power Shell.
https://poshgui.com/#

Aquí encuentras más enalces.
# http://tianit.cloudapp.net/blog/index.php/2015/11/04/crear-formularios-con-powershell/

Por ejemplo, abajo un formalario creado en visual solo con códigos de PowerShell.


Mi pregunta es.

¿Se puede crear también formularios con el lenguaje Visual F#?

Por todas partes se llama Visual F#, pero solo he visto códigos en modo consola.

Saludos.

Hola:

Tengo esta ventana creada con PowerShell. Lo que no entiendo por mucho que observe el código, es que me aparezcan dos botones iguales en la parte de arriba.

Código [Seleccionar] Expandir

# Cargo los Assemblies (necesario para definir el form).
[void][reflection.assembly]::loadwithpartialname("System.Windows.Forms")
[void][reflection.assembly]::loadwithpartialname("System.Drawing")

            $label_Mensaje = New-Object System.Windows.Forms.Label
            $button_Abrir = New-Object System.Windows.Forms.Button
            $button_Cerrar = New-Object System.Windows.Forms.Button
            $groupBox_Bandeja = New-Object System.Windows.Forms.GroupBox

            #
            # label_Mensaje
            #
            $label_Mensaje.Location = New-Object System.Drawing.Point(12, 9)
            $label_Mensaje.Name = "label_Mensaje"
            $label_Mensaje.Size = New-Object System.Drawing.Size(58, 13)
            $label_Mensaje.Text = "Abriendo..."
            #
            # button_Abrir
            #
            $button_Abrir.Location = New-Object System.Drawing.Point(31, 30)
            $button_Abrir.Name = "button_Abrir"
            $button_Abrir.Size = New-Object System.Drawing.Size(75, 23)
            $button_Abrir.Text = "Abrir"         
            #
            # button_Cerrar
            #
            $button_Cerrar.Location = New-Object System.Drawing.Point(139, 30)
            $button_Cerrar.Name = "button_Cerrar"
            $button_Cerrar.Size = New-Object System.Drawing.Size(75, 23)
            $button_Cerrar.Text = "Cerrar"
            #
            # groupBox_Bandeja
            #
            $groupBox_Bandeja.Controls.Add($button_Cerrar)
            $groupBox_Bandeja.Controls.Add($button_Abrir)
            $groupBox_Bandeja.Location = New-Object System.Drawing.Point(15, 118)
            $groupBox_Bandeja.Name = "groupBox_Bandeja"
            $groupBox_Bandeja.Size = New-Object System.Drawing.Size(250, 97)
            $groupBox_Bandeja.Text = "Bandeja"

            #
            # Form1
            #
            #$AutoScaleDimensions = New-Object System.Drawing.SizeF(6F, 13F)
            #$AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
            $Form.ClientSize = New-Object System.Drawing.Size(284, 261)
            $Form.Controls.Add($groupBox_Bandeja)
            $Form.Controls.Add($label_Mensaje)
            $Form.Name = "Form1"
            $Form.Text = "Ventana PowerShell"

            # Ejecuto el formulario.
            [void]$Form.ShowDialog()

Saludos.

Hola a todos y a todas:

Quiero hacer un menú sencillo que las funciones se hará después.

Por ahora he hecho esto de esta manera haciendo pruebas.

╔====================================╗
║     Control bandeja del lector     ║
╠====================================╣
║                                    ║
1) Primera Opción
2) Segunda Opción
3) Tercera Opción
S) Presiona 'S' para salir
Elegir una Opción:

Como puedes ver, pulso el número 2), luego Enter para poder entrar en el menú. Mi idea es, desde que pulses la tecla número 2), entre directamente a la Segunda opción sin tener que pulsar Enter.

Código [Seleccionar] Expandir

{
     param (
           [string]$Titulo = ' Control bandeja del lector '
     )
     cls
     Write-Host "╔====================================╗"
     Write-Host "║    $Titulo    ║"
     Write-Host "╠====================================╣"
     Write-Host "║                                    ║"

     
     Write-Host "1) Primera Opción"
     Write-Host "2) Segunda Opción"
     Write-Host "3) Tercera Opción"
     Write-Host "S) Presiona 'S' para salir"
}

do
{
     mostrarMenu
     $input = Read-Host "Elegir una Opción"
     switch ($input)
     {
           '1' {
                cls
                'Primera Opción'
           } '2' {
                cls
                'Segunda Opción'
           } '3' {
                cls
                'Tercera Opción'
           } 's' {
                return
           } 
     }
     pause
}
until ($input -eq 's')


¿Cómo se hace lo que quiero?

Saludos.

Hola:

He hecho este programa para poder abrir y cerrar la bandeja con C++ Win32. Lo que tiene que hacer es si pulsa la tecla A, se abre el lector, si pulsas C, cierra la bandeja del lector de discos.

Código (cpp) [Seleccionar] Expandir

#include "stdafx.h"
#include "stdio.h"
#include "Windows.h"
#include "iostream"
#include "string"
#include "conio.h"

using namespace std;


int main()
{
// Título de la ventana.
SetConsoleTitle(L"Abrir y cerrar bandeja del disco C++ Win32");

// Variable
char entrada[] = "\0"; // Guarda A, a, C, y c tipo string que introduces desde la consola.

while (true)
{
printf("Control bandeja del lector : \n\n");
printf("A - Abrir bandeja. \n");
printf("C - Cerrar bandeja. \n");
printf("========================== \n\n");

cin >> entrada; // Aquí introduces letras A, a, C, y c.

switch (srt.tolower(entrada)) // Espera recibir A, a, C, y c. Transforma en minúscula.
{
// Abrir bandeja.
case 'a':
cout << "Abriendo..." << endl; // Muestra en pantalla textos.
//printf("Abriendo...");
// Aquí va un evento para que aparezca la palabra Abirendo... mientra se está abriendo el lector.
mciSendString(L"set cdaudio door open", nullptr, 0, nullptr);
cout << "Abierto." << endl; // Muestra en pantalla textos.
break;

// Cerrar bandeja.
case 'b':
cout << "Cerrando..." << endl; // Muestra en pantalla textos.
// Aquí va un evento.
mciSendString(L"set cdaudio door closed", nullptr, 0, nullptr);
cout << "Cerrado." << endl; // Muestra en pantalla textos.
break;

default: // Si haz pulsado otro caracter distinto de A, C, a, y c aparece
cout << "Solo pulsar A o C." << endl; // este mensaje.
}
}
return EXIT_SUCCESS;
}




¿Qué tengo mal?

Saludos.

[página 36, hasta la página 45]

Hola:

Trabajando con MFC al crear formularios, me salía esta ventana al final en el cual podía ejecutar al pulsar F5 para compilar.

Ver zoom.
Aquí abajo dejo una guía paso a paso de crear un formulario MFC como se hacía antes desde la página 36, hasta la página 45.
Ver visor.
Ver pdf.
Intenté seguir los pasos, la primera ventana me sale esto.


No se cual es la mejor forma de hacerlo. Lo dejo tal cual por si acaso y sigo a la página siguiente.
Sigo el siguiente paso.

Siguiente paso.

Siente paso.

Antes al ejecutar no me daba problemas. Ahora me salen todos estos errores indicado abajo y no se como solucionarlo.


¿Hay alguna solución?

Antes, podía ejecutar la ventana y no pasaba nada.

Saludos.

PD: Disculpen si no me sale el tamaño adecuado de las capturas.

[Código C++ CLR:]

Hola:

Quiero adaptar este código de C++ CLR a C++ Win32. Antes que nada, quiero saber si es posible o hay que complicarse mucho la vida para hacer lo mismo. El código lo que hace es abrir y cerrar la bandeja de cualquier lector de discos sea IDE o SATA.

Aquí encontré un vídeo pero solo ejecuta, y abre el lector en Win32. Por algo se empieza.

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

Código C++ CLR:

Código (cpp) [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;
}

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.

[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.

Hola:

Hice esta aplicación para enviar datos a EEPROM tipo 24LCxx por I2C con Arduino. Tabajando con C#, ya puedo enviar los datos al puerto serie. Puede contar los bytes enviados. El problema, que estoy machacando la cabeza que no hay manera de hacer fucnionar en la barra del progreso que me cuenta el "label_Por_ciento" del 0 % al 100 %.



Ya puedeo envair datos y cancelarlo.

Código (csharp) [Seleccionar] Expandir

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

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

            for (int i = 0; i <= archivo.GetUpperBound(0); i++)
            {
                serialPort1.Write(archivo, i, 1);

                progressBar_barrra_progreso.Value = i;

                label_Bytes_transmitidos.Text = i.ToString() + " Bytes.";

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

Botón.

Código (csharp) [Seleccionar] Expandir

        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";
                }
            }
        }

¿Alguna idea?

Saludos.

[Description Resource Path Location TypetextArea cannot be resolved Prueba01.java /Proyectazo/src/ejercicios line 53 Java Problem]

Hola:

Uso Eclipse oxigeny. En el JFrame puse en el formulario un JButton y un JTextArea. Mi idea es que si pulsas el botón "Mostrar", siga en el JTextArea el mensaje: Hola mundo.



Pulso dos veces el botón Mostrar y me lleva alcódigo.

Código [Seleccionar] Expandir

// Variable tipo String.
String variable = "Hola mundo.";

// Mostramos el contenido de la variable en el JTextArea.
textArea.append(variable);

La palabra textArea que es el nombre del JTextArea marca error. No lo detecta. El error indicado es este:
Description   Resource   Path   Location   Type
textArea cannot be resolved   Prueba01.java   /Proyectazo/src/ejercicios   line 53   Java Problem


Código completo:

Código [Seleccionar] Expandir

package ejercicios;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import javax.swing.JTextArea;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class Prueba01 extends JFrame {

private JPanel contentPane;

/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
Prueba01 frame = new Prueba01();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame.
*/
public Prueba01() {
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 btnMostrar = new JButton("Mostrar");
btnMostrar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

// Variable tipo String.
String variable = "Hola mundo.";

// Mostramos el contenido de la variable en el JTextArea.
textArea.append(variable);
}
});
btnMostrar.setBounds(165, 11, 89, 23);
contentPane.add(btnMostrar);

JTextArea textArea = new JTextArea();
textArea.setBounds(10, 55, 414, 195);
contentPane.add(textArea);
}

}

¿Alguna idea?

Saludos.

[Los más que veo son:]

Hola:

¿Qué compilador usas para programar en C/C++ bajo Windows?

Los más que veo son:
Visual Studio Community 2017.
Code::Blocks.
C++ Builder de Embarcadero.
KDevelop.

Saludos.

Hola:

Tengo este código en C# y quiero hacer lo mismo en Java modo consola. Lo que hace es introducir 16 números o dígitos binarios, es decir, solo puedes introducir 1 y 0 hasta 16, pulsa enter y muestra los resultados en hexadecimal.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Linq;

namespace Binario_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Binaro a ensamblador de PIC16F84A - C#";

            // Muestra texto en pantalla pidiendo que introduzca los datos en binario.
            Console.Write("Introduzca 16 números binarios: ");

            String binario = Console.ReadLine();

            Console.WriteLine();

            if (binario.Count(x => (x != '0') & (x != '1')) == 0 & (binario.Length == 16))
            {
                int NumDec = Convert.ToInt32(binario, 2);
                string NumHex = String.Format("0x{0:X4}", NumDec);
                Console.WriteLine("Binario = " + binario);
                Console.WriteLine("Decimal = " + NumDec.ToString());
                Console.WriteLine("Hexadecimal = " + NumHex);
            }
            else
            {
                Console.WriteLine("Número incorrecto");
            }
            Console.ReadKey();
        }
    }
}

Ni pajonera idea sobre Java, esoty con Eclipse y NetBeans.
¿Alguna idea?

Salu2.

Tutorial Arduino Consola y puerto serie. Interfaz creado con diversos lenguajes como C#, C++ CLR y VB .net bajo Visual Studio Community que puedes controlar el puerto serie a Arduino encendiendo y apagando un Led, manejar el LCD y recibes mensajes hacia el ordenador o PC.



En este apartado mostramos el código fuente en C#, en el PDF se encuentra C#, C++ CLR y VB .net.

Código C#:

Código [Seleccionar] Expandir

using System;
using System.IO.Ports;
using System.Text;

namespace Arduino_Consola_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Arduino Consola C#";

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

            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort("COM4");

            Puerto_serie.BaudRate = 115200;
            Puerto_serie.Parity = Parity.None;
            Puerto_serie.StopBits = StopBits.One;
            Puerto_serie.DataBits = 8;
            Puerto_serie.Handshake = Handshake.None;
            Puerto_serie.RtsEnable = true;

            // Establecer los tiempos de espera de lectura / escritura.
            Puerto_serie.ReadTimeout = 500; // Milisegundos.
            Puerto_serie.WriteTimeout = 500;

            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Puerto_serie.Open(); // Abrir puerto.

            ConsoleKey tecla;
            Console.WriteLine("Pulse tecla 1 para encender y 2 para apagar:");

            do
            {
                tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.

                switch (tecla)
                {
                    case ConsoleKey.D1: // Tecla 1 del teclado estandar.
                    case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
                        byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                        Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
                        Console.WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
                        break;

                    case ConsoleKey.D2:
                    case ConsoleKey.NumPad2:
                        byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
                        Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
                        Console.WriteLine("Comando \"Luz_OFF\" enviado.");
                        break;

                    default:
                        Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
                        break;
                }
            } while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.

            Console.WriteLine("Presione cualquier tecla para terminar...");
            Console.WriteLine();
            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
            Puerto_serie.Close(); // Cierra el puerto serie.
        }

        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
        }
    }
}

Código C# Avanzado:

Código [Seleccionar] Expandir

using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Speech.Recognition; // No olvidar. Micro.
using System.Speech.Synthesis; // No olvidar. Altavoz.

namespace Arduino_Consola_Color_Voz_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            string COM = "";

            // Título de la ventana.
            Console.Title = "Arduino Consola color y voz C#";

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

            SerialPort Puerto_serie;

            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            Puerto_serie = new SerialPort();

            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.

Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear();

            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.


            Puerto_serie.BaudRate = 115200; // Baudios.
            Puerto_serie.Parity = Parity.None; // Paridad.
            Puerto_serie.DataBits = 8; // Bits de datos.
            Puerto_serie.StopBits = StopBits.Two; // Bits de parada.
            Puerto_serie.Handshake = Handshake.None; // Control de flujo.

            // Establecer la lectura / escritura de los tiempos de espera.
            Puerto_serie.ReadTimeout = 500;
            Puerto_serie.WriteTimeout = 500;

            try
            {
                Puerto_serie.Open(); // Abrir el puerto serie.
            }

            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
                o no lo encuentra.");
                Console.ReadKey();   // Pulse cualquier tecla.
                Environment.Exit(1); // Salir de la aplicación.
            }



            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            ConsoleKey tecla;
            Console.WriteLine("Pulse tecla 1 para encender, 2 para apagar y \n" +
                "Escape para salir. \n" +
                "--------------------------------------------------------------\n");

            do
            {
                tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.
                                                   // Inicializar una nueva instancia de SpeechSynthesizer.
                using (SpeechSynthesizer altavoz = new SpeechSynthesizer())
                {
                    // Configure la salida de audio.
                    altavoz.SetOutputToDefaultAudioDevice();

                    // Velocidad de la voz.
                    altavoz.Rate = -2; // Valores entre -10 a 10.

                    // Volumen de la voz.
                    altavoz.Volume = 100; // Valores entre 0 y 100.

                    switch (tecla)
                    {
                        case ConsoleKey.D1: // Tecla 1 del teclado estandar.
                        case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
                            byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                            Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.Write("Comando"); // Muestra en pantalla comandos enviado.
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(" \"Luz_ON\" ");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.WriteLine("enviado.");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            altavoz.Speak("Luz encendida.");
                            break;

                        case ConsoleKey.D2:
                        case ConsoleKey.NumPad2:
                            byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
                            Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.Write("Comando"); // Muestra en pantalla comandos enviado.
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(" \"Luz_OFF\" ");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.WriteLine("enviado.");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            altavoz.Speak("Luz apagada.");
                            break;

                        case ConsoleKey.Escape:
                            Console.WriteLine("Saliendo...");
                            altavoz.Speak("Saliendo.");
                            break;

                        default:
                            Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");                         
                            break;
                    }
                }
            } while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.

            Console.ForegroundColor = ConsoleColor.Yellow;

            Console.WriteLine();
            Console.WriteLine("╔═════════════════════════════════════════════════════╗");
            Console.WriteLine("║ Electrónica PIC                 metaconta@gmail.com ║");
            Console.WriteLine("║                                                     ║");
            Console.WriteLine("║               Ángel Acaymo M. G.                    ║");
            Console.WriteLine("╚═════════════════════════════════════════════════════╝");
            Console.WriteLine();

            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("Pulse cualquier tecla para salir...");
            Console.WriteLine();
            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
            Puerto_serie.Close(); // Cierra el puerto serie.
        }

        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.ForegroundColor = ConsoleColor.Gray;
            Console.Write("Dato recibido desde Arduino: "); // Muestra en pantalla los datos recibidos.
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(entradaDatos + "\n");
            Console.ForegroundColor = ConsoleColor.Gray;
        }

        // Maneje el evento SpeechRecognized.
        static void recognizer_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
        {
            Console.WriteLine("Texto reconocido: " + e.Result.Text);

            string palabras = e.Result.Text;
        }
    }
}



Código de Aruino:

Código [Seleccionar] Expandir

// ----- Electrónica PIC -----
//
// Ejercicio 2.
//
// Encendido y apagado del Led 13 mediante puerto serie con pantalla.
// Es lo mismo que el Ejercicoi 1, pero usando el LCD Keypad Shield.

#include

// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;

const byte Led = 13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
  pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
  Serial.begin(115200);     // Puerto serie 115200 baudios.
  lcd.begin(16, 2);         // Formato de pantalla.
  lcd.clear();      // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
}

void loop()
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0)
  {
    caracter = Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */

  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Luz_ON") == true)
  {
    digitalWrite(Led, HIGH); // Enciende el Led 13.
    Serial.write("ON - Led encendido.");    // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz ON.         "); // Mostrar en el LCD.
  }


  if (comando.equals("Luz_OFF") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("OFF - Led apagado. ");  // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz OFF.        "); // Mostrar en el LCD.
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}



Ver vídeo.
[youtube=640,360]https://www.youtube.com/watch?v=erQygRNAPWc[/youtube]

Ver visor.

Ver PDF.

Un cordial saludo.

[Página 22. Organización de la memoria de datos:]

Hola:

Mi idea es introducir en una consola números binarios que lo detecta y los traduce a código ensamblador.

Hoja de datos PIC16F84A:

Ver enlace.

Página 22. Organización de la memoria de datos:


El archivo p16f84a.inc que encuentras en el directorio en mi caso cuando instalé MPLAB X v4.00.
C:\Program Files (x86)\Microchip\MPLABX\v4.00\mpasmx

p16f84aa.inc:

Código [Seleccionar] Expandir

        LIST

;==========================================================================
; Build date : May 17 2017
;  MPASM PIC16F84A processor include
;
;  (c) Copyright 1999-2017 Microchip Technology, All rights reserved
;==========================================================================

        NOLIST

;==========================================================================
;  This header file defines configurations, registers, and other useful
;  bits of information for the PIC16F84A microcontroller.  These names
;  are taken to match the data sheets as closely as possible.
;
;  Note that the processor must be selected before this file is included.
;  The processor may be selected the following ways:
;
;       1. Command line switch:
;               C:\MPASM MYFILE.ASM /PIC16F84A
;       2. LIST directive in the source file
;               LIST   P=PIC16F84A
;       3. Processor Type entry in the MPASM full-screen interface
;       4. Setting the processor in the MPLAB Project Dialog
;==========================================================================

;==========================================================================
;
;       Verify Processor
;
;==========================================================================
        IFNDEF __16F84A
           MESSG "Processor-header file mismatch.  Verify selected processor."
        ENDIF



;==========================================================================
;
;       Register Definitions
;
;==========================================================================

W                EQU  H'0000'
F                EQU  H'0001'

;----- Register Files -----------------------------------------------------

;-----Bank0------------------
INDF             EQU  H'0000'
TMR0             EQU  H'0001'
PCL              EQU  H'0002'
STATUS           EQU  H'0003'
FSR              EQU  H'0004'
PORTA            EQU  H'0005'
PORTB            EQU  H'0006'
EEDATA           EQU  H'0008'
EEADR            EQU  H'0009'
PCLATH           EQU  H'000A'
INTCON           EQU  H'000B'

;-----Bank1------------------
OPTION_REG       EQU  H'0081'
TRISA            EQU  H'0085'
TRISB            EQU  H'0086'
EECON1           EQU  H'0088'
EECON2           EQU  H'0089'

;----- STATUS Bits -----------------------------------------------------
C                EQU  H'0000'
DC               EQU  H'0001'
Z                EQU  H'0002'
NOT_PD           EQU  H'0003'
NOT_TO           EQU  H'0004'
IRP              EQU  H'0007'

RP0              EQU  H'0005'
RP1              EQU  H'0006'


;----- PORTA Bits -----------------------------------------------------
RA0              EQU  H'0000'
RA1              EQU  H'0001'
RA2              EQU  H'0002'
RA3              EQU  H'0003'
RA4              EQU  H'0004'


;----- PORTB Bits -----------------------------------------------------
RB0              EQU  H'0000'
RB1              EQU  H'0001'
RB2              EQU  H'0002'
RB3              EQU  H'0003'
RB4              EQU  H'0004'
RB5              EQU  H'0005'
RB6              EQU  H'0006'
RB7              EQU  H'0007'


;----- INTCON Bits -----------------------------------------------------
RBIF             EQU  H'0000'
INTF             EQU  H'0001'
T0IF             EQU  H'0002'
RBIE             EQU  H'0003'
INTE             EQU  H'0004'
T0IE             EQU  H'0005'
EEIE             EQU  H'0006'
GIE              EQU  H'0007'

TMR0IF           EQU  H'0002'
TMR0IE           EQU  H'0005'


;----- OPTION_REG Bits -----------------------------------------------------
PSA              EQU  H'0003'
T0SE             EQU  H'0004'
T0CS             EQU  H'0005'
INTEDG           EQU  H'0006'
NOT_RBPU         EQU  H'0007'

PS0              EQU  H'0000'
PS1              EQU  H'0001'
PS2              EQU  H'0002'


;----- TRISA Bits -----------------------------------------------------
TRISA0           EQU  H'0000'
TRISA1           EQU  H'0001'
TRISA2           EQU  H'0002'
TRISA3           EQU  H'0003'
TRISA4           EQU  H'0004'


;----- TRISB Bits -----------------------------------------------------
TRISB0           EQU  H'0000'
TRISB1           EQU  H'0001'
TRISB2           EQU  H'0002'
TRISB3           EQU  H'0003'
TRISB4           EQU  H'0004'
TRISB5           EQU  H'0005'
TRISB6           EQU  H'0006'
TRISB7           EQU  H'0007'


;----- EECON1 Bits -----------------------------------------------------
RD               EQU  H'0000'
WR               EQU  H'0001'
WREN             EQU  H'0002'
WRERR            EQU  H'0003'
EEIF             EQU  H'0004'




;==========================================================================
;
;       RAM Definitions
;
;==========================================================================
       __MAXRAM  H'00CF'
       __BADRAM  H'0007'
       __BADRAM  H'0050'-H'007F'
       __BADRAM  H'0087'

;==========================================================================
;
;       Configuration Bits
;
;   NAME            Address
;   CONFIG            2007h
;
;==========================================================================

; The following is an assignment of address values for all of the
; configuration registers for the purpose of table reads
_CONFIG         EQU  H'2007'

;----- CONFIG Options --------------------------------------------------
_FOSC_LP             EQU  H'3FFC'; LP oscillator
_LP_OSC              EQU  H'3FFC'; LP oscillator
_FOSC_XT             EQU  H'3FFD'; XT oscillator
_XT_OSC              EQU  H'3FFD'; XT oscillator
_FOSC_HS             EQU  H'3FFE'; HS oscillator
_HS_OSC              EQU  H'3FFE'; HS oscillator
_FOSC_EXTRC          EQU  H'3FFF'; RC oscillator
_RC_OSC              EQU  H'3FFF'; RC oscillator

_WDTE_OFF            EQU  H'3FFB'; WDT disabled
_WDT_OFF             EQU  H'3FFB'; WDT disabled
_WDTE_ON             EQU  H'3FFF'; WDT enabled
_WDT_ON              EQU  H'3FFF'; WDT enabled

_PWRTE_ON            EQU  H'3FF7'; Power-up Timer is enabled
_PWRTE_OFF           EQU  H'3FFF'; Power-up Timer is disabled

_CP_ON               EQU  H'000F'; All program memory is code protected
_CP_OFF              EQU  H'3FFF'; Code protection disabled

;----- DEVID Equates --------------------------------------------------
_DEVID1          EQU  H'2006'

;----- IDLOC Equates --------------------------------------------------
_IDLOC0          EQU  H'2000'
_IDLOC1          EQU  H'2001'
_IDLOC2          EQU  H'2002'
_IDLOC3          EQU  H'2003'

        LIST

Página 35. SISTEMA DE INSTRUCCIONES:


Para dejarlo mejor explicado, cogemos por ejemplo el registro MOVF que puedes ver en l apágin a36 de la hoja de datos del PIC16F84A.



Como podrás ver en la tabla, MOVF corresponde al 00 1000, o lo que es lo mismo, añadir dos ceros más al principio, 00001000.

El registro PORTB que muestra en el archivo p16f84a.inc:

Código [Seleccionar] Expandir


;----- Register Files -----------------------------------------------------

;-----Bank0------------------
PORTB            EQU  H'0006'

Del hexadecimal H'0006' al binario es: 000 0110

Mirando el archivo p16f84a.inc de arriba:

Código [Seleccionar] Expandir

;==========================================================================
;
;       Register Definitions
;
;==========================================================================

W                EQU  H'0000'
F                EQU  H'0001'

Elegimos la F que corresponde guardar en el propio registro, es un 1. La d es el lugar de destino, W que equivale a 0 se guarda en el registro de trabajo. La F que equivale a 1 se guarda en el registro.

En resumen:
MOVF PORTB, F

MOVF H'0006', H'0001'

00001000 1 000 0110



Pseudocódigo de nuestro compañero del foro explorer:

Código [Seleccionar] Expandir

bits1413 = (0b11_0000_0000_0000 & opcode) >> 12;      // extraemos los dos bits superiores

switch (bits1413) {
   case 0b00:
      // en este caso, el tercer nibble es la operación, el bit 7 es la suboperación o destino, y el resto, el operando
      nibble3  = (0b00_1111_0000_0000 & opcode) >> 8;
      bit7     = (0b00_0000_1000_0000 & opcode) >> 7;
      operando = (0b00_0000_0111_1111 & opcode);

      switch (bit7) {
         case 0:
            reg = 'W';
            break;
         case 1;
            reg = 'F';
            break;
      }

      switch (nibble3) {
         
         case 0x0:
            switch (bit7) {
               case 1:
                  printf("MOVWF %x\n", operando);
                  break;
               case 0;
                  // aquí pueden ocurrir varios casos, según el primer nibble
                  nibble1 = (0b00_0000_0000_1111 & opcode);
                  switch (nibble1) {
                     case 0x0:
                        printf("NOP\n");
                        break;
                     case 0x4:
                        printf("CLRWDT\n");
                        break;
                     case 0x9:
                        printf("RETFIE\n");
                        break;
                     case 0x8:
                        printf("RETURN\n");
                        break;
                     case 0x3:
                        printf("SLEEP\n");
                        break;
                  }
                  break;
            }
            break;
         case 0x1:
            switch (bit7) {
               case 0:
                  printf("CLRW\n");
                  break;
               case 1;
                  printf("CLRF %x\n", operando);
                  break;
            }
            break;
         case 0x2:
            printf("SUBWF %x,%c\n", operando, reg);
            break;
         case 0x3:
            printf("DECF %x,%c\n", operando, reg);
            break;
         case 0x4:
            printf("IORWF %x,%c\n", operando, reg);
            break;
         case 0x5:
            printf("ANDWF %x,%c\n", operando, reg);
            break;
         case 0x6:
            printf("XORWF %x,%c\n", operando, reg);
            break;
         case 0x7:
            printf("ADDWF %x,%c\n", operando, reg);
            break;
         case 0x8:
            printf("MOVF %x,%c\n", operando, reg);
            break;
         case 0x9:
            printf("COMF %x,%c\n", operando, reg);
            break;
         case 0xA:
            printf("INCF %x,%c\n", operando, reg);
            break;
         case 0xB:
            printf("DECFSZ %x,%c\n", operando, reg);
            break;
         case 0xC:
            printf("RRF %x,%c\n", operando, reg);
            break;
         case 0xD:
            printf("RLF %x,%c\n", operando, reg);
            break;
         case 0xE:
            printf("SWAPF %x,%c\n", operando, reg);
            break;
         case 0xF:
            printf("INCFSZ %x,%c\n", operando, reg);
            break;
      }
      break;
   case 0b01:
      // en este caso, los bits 12 y 11 es la suboperación, los bits 8, 9 y 10 es el número de bit, y el resto, el operando
      subop    = (0b00_1100_0000_0000 & opcode) >> 10;
      bit      = (0b00_0011_1000_0000 & opcode) >> 7;
      operando = (0b00_0000_0111_1111 & opcode);

      switch (subop) {
         case 0x0;
            printf("BCF %x,%d\n", operando, bit);
            break;
         case 0x1;
            printf("BSF %x,%d\n", operando, bit);
            break;
         case 0x2;
            printf("BTFSC %x,%d\n", operando, bit);
            break;
         case 0x3;
            printf("BTFSS %x,%d\n", operando, bit);
            break;
      }
      break;
   case 0b10:
      // ver el bit 12. El resto es el operando
      bit12    = (0b00_1000_0000_0000 & opcode) >> 11;
      operando = (0b00_0111_1111_1111 & opcode);

      switch (bit12) {
         case 0:
            printf("CALL %x\n", operando);
            break;
         case 1:
            printf("GOTO %x\n", operando);
            break;
      }
      break;
   case 0b11:
      // el tercer nibble es la suboperación, y el resto, el operando
      nibble3  = (0b00_1111_0000_0000 & opcode) >> 8;
      operando = (0b00_0000_1111_1111 & opcode);
     
      switch (nibble3) {
         case 0b0000:
         case 0b0001:
         case 0b0010:
         case 0b0011:
            printf("MOVLW %x\n", operando);
            break;
         case 0b0100:
         case 0b0101:
         case 0b0110:
         case 0b0111:
            printf("RETLW %x\n", operando);
            break;
         case 0b1000:
            printf("IORLW %x\n", operando);
            break;
         case 0b1001:
            printf("ANDLW %x\n", operando);
            break;
         case 0b1010:
            printf("XORLW %x\n", operando);
            break;
         case 0b1100:
         case 0b1101:
            printf("SUBLW %x\n", operando);
            break;
         case 0b1110:
         case 0b1111:
            printf("ADDLW %x\n", operando);
            break;
      }
      break;
}


Yo y  un amigo lo valos a traducir por el momento a Java que es el que entiende mejor, luego haré en otros lenguajes para quien le guste, como dije arriba, C#, C++ CLR y VB .net.

Si no tienen algo claro, avisen.

Un cordial saludo.

Hola:

Quiero enviar datos al puerto serie con el CMD de Windows, o el sustituto del cmd que es PowerShell, hacen lo mismo. Consiste en configurar dicho puerto que se hace así:

MODE COM1:9600,n,8,1

Y en la consola aparece esto:


Quiero crear un archivo .bat en el que solo tengo que pulsar la tecla 1 y envía esto: Luz_ON.

Si pulso la tecla 2, envía por el puerto serie Luz_OFF.

¿Existe la posibilidad de hacerlo?

Si es así. ¿Cómo se hace?

Saludos.

Hola:

Estoy probando y modificando este código en C++ con Visual Studio Community 2017. En el C++ CLR.
Sigo este enlace.
https://msdn.microsoft.com/es-es/library/system.io.ports.serialport.datareceived(v=vs.110).aspx?cs-save-lang=1&cs-lang=cpp#code-snippet-2

El codigo nuevo que he indicado es este.

Código (cpp) [Seleccionar] Expandir

// Envio_y_recepcion_puerto_serie_cpp.cpp: archivo de proyecto principal.

#include "stdafx.h"
#using <System.dll>

using namespace System;
using namespace System::Text;
using namespace System::IO::Ports;

// array<System::String ^> ^args

ref class PortDataReceived
{
public:
static void Main()
{
// Título de la ventana.
Console::Title = "Recibir datos desde Arduino con C++ CLR";

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

SerialPort^ Puerto_serie = gcnew SerialPort("COM4");

Puerto_serie->BaudRate = 115200;
Puerto_serie->Parity = Parity::None;
Puerto_serie->StopBits = StopBits::One;
Puerto_serie->DataBits = 8;
Puerto_serie->Handshake = Handshake::None;
Puerto_serie->RtsEnable = true;

Puerto_serie->DataReceived += gcnew SerialDataReceivedEventHandler(DataReceivedHandler);

Puerto_serie->Open();

ConsoleKey tecla;
Console::WriteLine("Pulse tecla 1 para encender y 2 para apagar:");

do
{
tecla = Console::ReadKey(true).Key; // Espera pulsación de teclas.

switch (tecla)
{
case ConsoleKey::D1: // Tecla 1 del teclado estandar.
case ConsoleKey::NumPad1: // Tecla 1 del número del pad.

array<Byte> ^miBuffer1 = Encoding::ASCII->GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
Puerto_serie->Write(miBuffer1, 0, miBuffer1->Length); // Envía los datos del buffer todo su contenido.
Console::WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
break;

case ConsoleKey::D2:
case ConsoleKey::NumPad2:
array<Byte> ^miBuffer2 = Encoding::ASCII->GetBytes("Luz_OFF");
Puerto_serie->Write(miBuffer2, 0, miBuffer2->Length);
Console::WriteLine("Comando \"Luz_OFF\" enviado.");
break;

default:
Console::WriteLine("Tecla el 1, el 2 y Escape para salir.");
break;
}
} while (tecla != ConsoleKey::Escape); // Pulsa Escape para salir del menú.

Console::WriteLine("Presione cualquier tecla para terminar...");
Console::WriteLine();
Console::ReadKey(); // Espera pulsar una tecla cualquiera.
Puerto_serie->Close(); // Cierra el puerto serie.

}
   // Detecta cualquier dato entrante.

private:
static void DataReceivedHandler(Object^ sender, SerialDataReceivedEventArgs^ e)
{
SerialPort^ sp = (SerialPort^)sender;
String^ entradaDatos = sp->ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
Console::WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.;
}
};

int main(array<System::String ^> ^args)
{
PortDataReceived::Main();
}

En apariencia no parece tener errores, al compilar me suelta estos 5 errrores.
Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error   C1854   no se puede sobrescribir la información realizada durante la creación del encabezado precompilado en el archivo objeto: 'c:\users\meta\documents\visual studio 2017\projects\envio_y_recepcion_puerto_serie_cpp\envio_y_recepcion_puerto_serie_cpp\debug\stdafx.obj'   Envio_y_recepcion_puerto_serie_cpp   C:\Users\Meta\documents\visual studio 2017\Projects\Envio_y_recepcion_puerto_serie_cpp\Envio_y_recepcion_puerto_serie_cpp\stdafx.cpp   5   


Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error   C2361   la inicialización de 'miBuffer2' se omite en la etiqueta 'default'   Envio_y_recepcion_puerto_serie_cpp   C:\Users\Meta\documents\visual studio 2017\Projects\Envio_y_recepcion_puerto_serie_cpp\Envio_y_recepcion_puerto_serie_cpp\Envio_y_recepcion_puerto_serie_cpp.cpp   64   


¿Cómo lo soluciono?

Saludos.

Hola:

He visto que han kackeado la NES Mini.
https://www.linuxadictos.com/hacker-consigue-hackear-la-nintendo-classic-mini-e-instalar-gnulinux.html

¿Cómo logran Meter Ubunto dentro de ella y hacer lo que les da la gana?

Esto ocurrió hasta con un marco de fotos digital, con Wii y vete a saber que más dispositivo acepta Linux.

Saludos.

[MOD: imagen adaptada a lo permitido.]

Hola:

He creado un evento. Se trata de usar el código correcto para que al recibir datos por el puerto serie, lo detecte y lo muestre en patalla.


Uso la ibrería https://github.com/Gmatarrubia/LibreriasTutoriales

El evento generado es este:

Código (cpp) [Seleccionar] Expandir

void CMFC_ArduinoDlg::OnEnUpdateEditMensajeDesdeArduino()
{

}

Introduje este código. Lo que debe hacer es, al detectar el puerto serie, se guarde en la variable lectura. Lo que tenga guardado en la variable lectura, lo uestra en el componente Rich del formulario.

Código (cpp) [Seleccionar] Expandir

void CMFC_ArduinoDlg::OnEnUpdateEditMensajeDesdeArduino()
{
// TODO:  Si éste es un control RICHEDIT, el control no
// enviará esta notificación a menos que se invalide CDialogEx::OnInitDialog()
// función para enviar el mensaje EM_SETEVENTMASK al control
// con la marca ENM_UPDATE ORed en la máscara lParam.

// TODO:  Agregue aquí el controlador de notificación de controles.

int n = Puerto->ReadData(lectura, 49);
if (n > 0)
{
lectura[n + 1] = '\0';
IDC_EDIT_MENSAJE_DESDE_ARDUINO->text = lectura;
}
}

Al compilar me da dos erroes.
Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error (activo)   E0044   la expresión debe tener un tipo de puntero   MFC_Arduino   c:\Users\usuario\Documents\Visual Studio 2017\Projects\MFC_Arduino\MFC_Arduino\MFC_ArduinoDlg.cpp   155   



Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error   C2227   el operando izquierdo de '->text' debe señalar al tipo class/struct/union/generic   MFC_Arduino   c:\users\meta\documents\visual studio 2017\projects\mfc_arduino\mfc_arduino\mfc_arduinodlg.cpp   155   


¿Alguna solución?

Saludos.

MOD: imagen adaptada a lo permitido.




Edito 3:

Hola de nuevo:

Si me deja escribir por aquí. Leyendo y leyendo por internet, hasta en ruso, encontré este enlace.

SetDlgItemText

En C# sería algo así cmo indiqué arriba, pero no lo es:

Código (cpp) [Seleccionar] Expandir

Rich.txt = Lectura.toString();

Se usa así:

Código (cpp) [Seleccionar] Expandir

SetDlgItemText(IDC_EDIT_MENSAJE_DESDE_ARDUINO, lectura); // Mostrar texto.

En parte me ha funcionado, solo en parte, es decir. Si pulso el botón ON o OFF, no pasa nada. Si escribo una letra en el Rich, aparece ya los textos desde el puerto serie. Vuelvo a pulsar el botón ON o el OFF, no pasa nada, si escribo otra letra en el Rich que se llama IDC_EDIT_MENSAJE_DESDE_ARDUINO, vuelve aparecer nuevos datos desde el puerto serie. Esto ocurre así porque he usado este evento que puedes ver aquí. No encuentro otro evento que valga la pena.

Código de este evento:

Código (cpp,7) [Seleccionar] Expandir

void CMFC_ArduinoDlg::OnEnUpdateEditMensajeDesdeArduino()
{
int n = Puerto->ReadData(lectura, 49);
if (n > 0)
{
lectura[n + 1] = '\0';
SetDlgItemText(IDC_EDIT_MENSAJE_DESDE_ARDUINO, lectura);
}
}

Si escribo una letra, en el Rich, me aparece por fin el mensaje, solo si escribe una letra, lo que sea con tal de detectar algo. Por lo que se ve, este método no es el adecuado.


Hice otro truco a ver si cuela, pero tampoco funciona como quiero. Puede el código en cada botón, el ON y OFF, usando el mismo código, y sin usar el void para reutilización de código, no quería perder el tiempo.

Código (cpp,8) [Seleccionar] Expandir

void CMFC_ArduinoDlg::OnBnClickedButton1()
{
Puerto->WriteData(Luz_OFF, sizeof(Luz_OFF) - 1);
int n = Puerto->ReadData(lectura, 49);
if (n > 0)
{
lectura[n + 1] = '\0';
SetDlgItemText(IDC_EDIT_MENSAJE_DESDE_ARDUINO, lectura);
}
}

Tiene comportamiento no deseado. Si uso ON, luego pulso OFF, me aparece el mensaje del ON, si vuelvo a pulsar OFF, me aparece el mensaje del OFF por fin, pero, debo pulsar dos veces el mismo botón para que me aparezca el mensaje adecuado. A parte de esto, si desde el puerto serie me aparece una entrada de texto sin yo solicitarlo desde el ordenador o PC, nunca me aparece el texto en pantalla.

La forma ideal es, desde que me llegue datos al puerto serie, desde que detecte algo, algún carácter, lo muestra en pantalla. Hay que buscar un evento o una función que cumpla esos requisitos.

Ahí no tengo idea, al menos he logrado que se muestre algo, porque desde hace meses no me comía una rosca, y desde los foros oficiales de Microsoft tanto en español como en Inglés, no tienen idea del tema de los puertos series y Arduino.

Sólo falta saber una buena función que detecte las entradas de datos en el Rich y asunto resuelto.

Saludos.

Hola:

Tengo un archivo llamado archivo.upg y no se si puedo hacerlo con algún programa, quiero saber nombre del programa para abrirlo. Mi objetivo es sacar un archivo.bin que es el firmware de un TV.

Archivos UPG disfrutan de incesante popularidad. El nombre de archivo, que contiene la extensión de archivo UPG ocasiona alguna dificultad a determinada parte de los usuarios. De hecho, tienen problemas con la correcta apertura de archivo con la extensión UPG. Se debe recordar, sin embargo, que la extensión de archivo UPG puede significar uno o más cantidad de tipos de archivo. El más popular es el Firmware Upgrade Format, pero si hay otros, con toda la seguridad, encontraras información sobre ellos, más abajo.

Merece la pena pues, que veamos de cerca el problema relativo a archivos UPG y buscar una solución.

http://es.filesupport.org/extension-de-archivo/upg

¿Alguna ayuda?

Saludos.

Buenas:

Quiero hacer un experimento de Encender un Led y apagarlo con el lenguaje Python y Arduino. Nunca lo he hecho con este lenguaje y hace tiempo que no lo toco.

He hecho hacer encender y apagar un Led con Delphi y Aruino. Puedes ver el tutorial para que te hagas una idea de que va.

¿Alguna sugerencia para hacer esto en Windows?

Saludos.

Tutorial Arduino Delphi 10.2 y Puerto serie. Interfaz creado con Delphi que puedes controlar el puerto serie a Arduino encendiendo y apagando un Led, manejar el LCD y recibes mensajes hacia el PC.

El entorno Delphi con el lenguaje pascal sigue vigente en la actualidad y su uso en Arduino está creciendo cada vez más.



Código fuente de Delphi:

Código [Seleccionar] Expandir

unit Principal;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, CPort;

type
  TForm1 = class(TForm)
    Label_Titulo: TLabel;
    Label_Mensajes: TLabel;
    Button_ON: TButton;
    Button_OFF: TButton;
    Button_COM: TButton;
    Button_Abrir: TButton;
    Memo_Mensajes: TMemo;
    Button_Limpiar: TButton;
    ComPort1: TComPort;
    procedure Button_ONClick(Sender: TObject);
    procedure Button_OFFClick(Sender: TObject);
    procedure Button_COMClick(Sender: TObject);
    procedure Button_AbrirClick(Sender: TObject);
    procedure Button_LimpiarClick(Sender: TObject);
    procedure ComPort1AfterClose(Sender: TObject);
    procedure ComPort1AfterOpen(Sender: TObject);
    procedure ComPort1RxChar(Sender: TObject; Count: Integer);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button_AbrirClick(Sender: TObject);
begin
  // Si el puerto está conectado.
  if ComPort1.Connected then
  begin
    ComPort1.Close; // Cierra el puerto.

    Button_COM.Enabled := True;
    Button_ON.Enabled := False;
    Button_OFF.Enabled := False;
  end

  else  // En caso contrario.

  begin
    ComPort1.Open;  // Abre el puerto.

    Button_COM.Enabled := False;
    Button_ON.Enabled := True;
    Button_OFF.Enabled := True;
  end;
end;

procedure TForm1.Button_COMClick(Sender: TObject);
begin
ComPort1.ShowSetupDialog; // Abre la configuración del puerto.
end;

procedure TForm1.Button_LimpiarClick(Sender: TObject);
begin
Memo_Mensajes.Clear();  // Limpia los mensajes del Memo.
end;

procedure TForm1.Button_OFFClick(Sender: TObject);
begin
ComPort1.WriteStr('Luz_OFF'); // Envía el comando "Luz_OFF" al puerto.
end;

procedure TForm1.Button_ONClick(Sender: TObject);
begin
ComPort1.WriteStr('Luz_ON');  // Envía el comando "Luz_ON" al puerto.
end;

procedure TForm1.ComPort1AfterClose(Sender: TObject);
begin
    if Button_Abrir <> nil then
    Button_Abrir.Caption := 'Abrir';
end;

procedure TForm1.ComPort1AfterOpen(Sender: TObject);
begin
   Button_Abrir.Caption := 'Cerrar';
end;

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);
var
  Str: String;
begin
  // Recibe mensajes desde Arduino.
  ComPort1.ReadStr(Str, Count);

  // Muestra los mensajes en pantalla.
  Memo_Mensajes.Lines.Add( Str );

  // Guarda los mensjes de Arduino en un archivo txt.
  Memo_Mensajes.Lines.SaveToFile('archivo.txt');
end;

end.



Código de Arduino:

Código [Seleccionar] Expandir

// ----- Electrónica PIC -----
//
// Ejercicio 2.
//
// Encendido y apagado del Led 13 mediante puerto serie con pantalla.
// Es lo mismo que el Ejercicoi 1, pero usando el LCD Keypad Shield.

#include

// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;

const byte Led = 13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
  pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
  Serial.begin(115200);     // Puerto serie 115200 baudios.
  lcd.begin(16, 2);         // Formato de pantalla.
  lcd.clear();      // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
}

void loop()
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0)
  {
    caracter = Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */

  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Luz_ON") == true)
  {
    digitalWrite(Led, HIGH); // Enciende el Led 13.
    Serial.write("ON - Led encendido.");    // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz ON.         "); // Mostrar en el LCD.
  }


  if (comando.equals("Luz_OFF") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("OFF - Led apagado. ");  // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz OFF.        "); // Mostrar en el LCD.
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}



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

Ver visor.

Ver PDF.

Un cordial saludo.

Hola:

Quiero instalar una librería que se llama comport que es el componeten para controlar el puerto serie.

ComPort Library

Estoy siguiendo el vídeo tutorial abajo que usa Delphi 10.1, sigo los paso y me da errores por todas partes.

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

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

Guardo la carpeta donde está los proyectos que hago como si fuera un proyecto más.
Selecciono la librería tal como indica en el vídeo.



Pulse el archivo que pulse para abrir, me sale este error.



¿Hay alguna solución?

Saludos.

Hola:

Hace un tiempo, hice un tutorial controlando Arduino y puerto serie en C++ con C++ Builder Starter entre otros compiladores.

Ahora ya de unos meses de descanso sobre programación, quiero retomar hacer algo similar pero con Windows Form y el lenguaje Delphi.

Primera parte:
La idea es, añadir dos botones desde el formulario, que al pulsar un botón envíe carácteres por el puerto serie. Esto hace encender un Led o apagarlo.

Segunda parte:
Cuando acabe la primera parte, seguimos en que por el puerto serie entras letras o carácteres para leer.

La interfaz Windows Form en Delphi Tokio 10.2 hay que enviar caracteres al puerto serie y que sea capaz de recibir datos también. Les dejo un ejemplo de una plantilla.



Los tutoriales que he encontrado son muy antiguos y con Delphi 7, no me interesa. Si encuentra algo para esta época, mejor, nos podemos ayudar.

Saludos.

[página 36]

ola:

He creado este formulario con MFC 2017.

Tengo creado el proyecto MFC siguiendo este tutorial a partir de la página 36.

Como puedes ver en la captura, he puestodos botones llamado ON y otro llamado OFF.



Como puedes ver abajo, añado un Richt edit.



Las librerías están aquí.

https://github.com/Gmatarrubia/LibreriasTutoriales

¿Cómo puedo recibir datos desde el puerto serie y lo muestre en el Richtedit?

Al menos con los botones del formulario MFC indicado arriba si puedo enviar datos al puerto serie.

Saludos.

Hola:

Intento que me ejecute esta aplicación MFC de C++, lo que quiero hacer es abrir el puerto serie y intentar enviar datos.

La ventana ya la tengo creado y esto si se ejecuta bien. El problema es cuando pincho en el botón ON para poner instrucciones y pasa cosas raras. A partir de la página 36 de este tutorial explica como se crea una ventana MFC.



Supuestamente en C++ de consola, para activar el puerto es esta instrucción.

Código (cpp) [Seleccionar] Expandir

Puerto->IsConnected()

Para enviar comandos es esta otra instrucciones.

Código (cpp) [Seleccionar] Expandir


Puerto->WriteData(Luz_ON, sizeof(Luz_ON) - 1); // Envía al puerto el texto "Luz_ON"

Para recibir datos, esta otra instracción.

Código (cpp) [Seleccionar] Expandir

int n = Puerto->ReadData(lectura, 49); // Recibe datos del puerto serie.

Aún así, haga lo que haga, no me sale. Lo que tiene que hacer el programa es, desde que ejecutes el formulario, abra el puerto serie.

Si pulso un botón, por ejemplo, el ON, envía el comando.

¿Alguna idea?

Saludos.

Tutorial Arduino C++ y Puerto serie. Puedes hacer controlar Arduino y el puerto serie desde el lenguaje C++ Win32. Hay tres IDE para elegir para crear tu propio programa en C++ como Visual Studio 2017, Code::Blocks y C++ Builder Starter.



Antes que nada saber que puerto usamos:
// Para crear conexión con los puertos COM1 - COM9.
// Serial* Arduino = new Serial("COM7");

// Para crear conexión con los puertos COM10 en adelante.
// Serial* Arduino = new Serial("\\\\.\\COM10");

Abrir conexión del puerto:
Puerto->IsConnected()

Enviar información a Arduino:
// Encener luz.
cout << "Enviando: " << Luz_ON << endl; // Muestra en pantalla textos.
Puerto->WriteData(Luz_ON, sizeof(Luz_ON) - 1); // Envía al puerto el texto "Luz_ON".

Código de Arduino:

Código [Seleccionar] Expandir

// Encendido y apagado del Led 13 mediante puerto serie.

const byte Led = 13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
 pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
 Serial.begin(115200);     // Puerto serie 115200 baudios.
}

void loop()
{
 /*
   Voy leyendo carácter a carácter lo que se recibe por el canal serie
   (mientras llegue algún dato allí), y los voy concatenando uno tras otro
   en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
   acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
   canal serie y que la concatenación se haga de forma ordenada.
 */
 while (Serial.available() > 0)
 {
   caracter = Serial.read();
   comando.concat(caracter);
   delay(10);
 }

 /*
   Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
   la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
   que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
   mueve un motor... y así.
 */

 // Si le llega el mensaje Luz_ON.
 if (comando.equals("Luz_ON") == true)
 {
   digitalWrite(Led, HIGH); // Enciende el Led 13.
   Serial.write("ON - Led encendido.");    // Envía este mensaje a C++.
 }

 // Si le llega el mensaje Luz_ON.
 if (comando.equals("Luz_OFF") == true)
 {
   digitalWrite(Led, LOW); // Apaga el Led 13.
   Serial.write("OFF - Led apagado. ");  // Envía este mensaje a C++.
 }

 // Limpiamos la cadena para volver a recibir el siguiente comando.
 comando = "";
}

Código C++:

Código [Seleccionar] Expandir

#include
#include
#include
#include "SerialClass.h"
using namespace std;

void main()
{
   // Título de la ventana
   SetConsoleTitle("Control Led Arduino - Visual Studio C++ 2017");

   // Puerto serie.
   Serial* Puerto = new Serial("COM4");

   // Comandos para Arduino.
   char Luz_ON[] = "Luz_ON"; // Envía "Luz_ON" al puerto serie.
   char Luz_OFF[] = "Luz_OFF";
   char lectura[50] = "\0"; // Guardan datos de entrada del puerto.

   int opc; // Guarda un 1 o 2 tipo entero queintroduces desde la consola.

   while (Puerto->IsConnected())
   {
       cout << endl; // Retorno.
       cout << "Introduzca la opcion deseada: " << endl;
       cout << "Pulse 1 para encender el Led, pulse 2 para apagar." << endl << endl; // Muestra texto en pantalla.

       cin >> opc; // Aquí introduces un número, el 1 o el 2.

       switch (opc) // Espera recibir un 1 o un 2.
       {
       case 1:
           // Encener luz.
           cout << "Enviando: " << Luz_ON << endl; // Muestra en pantalla textos.
           Puerto->WriteData(Luz_ON, sizeof(Luz_ON) - 1); // Envía al puerto el texto "Luz_ON".
           break;

       case 2:
           // Apagar luz.
           cout << "Enviando: " << Luz_OFF << endl;
           Puerto->WriteData(Luz_OFF, sizeof(Luz_OFF) - 1);
           break;

       default: // Si haz pulsado otro número distinto del 1 y 2, muestra
           cout << "Puse del 1 al 2."; // este mensaje.
       }


       Sleep(500);
       int n = Puerto->ReadData(lectura, 49); // Recibe datos del puerto serie.
       if (n > 0)
       {
           lectura[n + 1] = '\0'; // Limpia de basura la variable.
           cout << "Recibido: " << lectura << endl; // Muestra en pantalla dato recibido.
           cout << "-------------------" << endl;
       }

       cin.ignore(256, '\n'); // Limpiar buffer del teclado.
   }
}



Ver Visor.

[youtube=640,360]https://www.youtube.com/watch?v=KZkIZHSXL-g[/youtube]

Ver PDF.

Un cordial saludo.

Hola:

Haciendo pruebas ya que en VB .net no entiendo mucho. Tengo esta función tonta sin parámetros.

Código (vbnet) [Seleccionar] Expandir

Sub Mensaje1()
            Console.WriteLine()
            Console.WriteLine("Creando archivo al disco duro...")
        End Sub

Lo he intentado llamar directamete así y no funciona.

Código (vbnet) [Seleccionar] Expandir

mensaje1()

No sirve.

¿Cómo se le llama?

Saludos.

Buenas:

Tengo un programa aquí que no está bien hecho del todo.

Envía datos al puerto seria, concretamente llega a Arduino. Los datos llegan bien, al recibir, ya no tanto.

Si pulsas la tecla, por ejemplo 5, primero se ve reflejado y luego tengo que pulsar Enter. Lo que quiero lograr es que si pulse el número 5, automáticamente ejecuta la instruacción del case 5 del Switch.

Otra cosa, es que no me llegan los datos desde Arduino cuando le pulso un botón. C++ tiene que ser capaz, desde que le llegue algún dato, reflejarlo en pantalla.

La librería a usar es esta.

https://github.com/Gmatarrubia/LibreriasTutoriales

El código de C++ es:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream>
#include <Windows.h>
#include "SerialClass.h"
using namespace std;

void main()
{
SetConsoleTitle("Control Led 13 de Arduino UNO y saludos.");

Serial* Puerto = new Serial("COM4");

while (Puerto -> IsConnected())
{

// Comandos para Arduino.
char L_ON[] = "Led13_ON";
char L_OFF[] = "Led13_OFF";
char Saludar[] = "Hola Arduino. Saludos desde el PC con C++ bajo  Win32.";
char Luz_ON[] = "Luz_ON";
char Luz_OFF[] = "Luz_OFF";
char lectura[50];

int opc;

cout << "Introduzca la opcion deseada: ";

cin >> opc;

switch (opc)
{
case 1:
cout << "caso 1\n";
// Enviar encender Led.
cout << "Enviando: " << L_ON << endl;
Puerto -> WriteData(L_ON, sizeof(L_ON) - 1);
break;

case 2:
cout << "caso 2\n";
// Enviar apagar Led.
cout << "Enviando: " << L_OFF << endl;
Puerto -> WriteData(L_OFF, sizeof(L_OFF) - 1);
break;

case 3:
cout << "caso 3\n";
// Mensaje saludar.
cout << "Enviando: " << Saludar << endl;
Puerto -> WriteData(Saludar, sizeof(Saludar) - 1);
break;

case 4:
cout << "caso 4\n";
// Mensaje saludar.
cout << "Enviando: " << Luz_ON << endl;
Puerto->WriteData(Luz_ON, sizeof(Luz_ON) - 1);
break;

case 5:
cout << "caso 5\n";
// Mensaje saludar.
cout << "Enviando: " << Luz_OFF << endl;
Puerto->WriteData(Luz_OFF, sizeof(Luz_OFF) - 1);
break;

default:
cout << "Puse del 1 al 5.";
}

Puerto -> ReadData(lectura, 50);
cout << "Recibido: " << lectura << endl;

cout << "-------------------" << endl;

// system("PAUSE");
}
}

¿Alguna ayuda?

Un cordial saludo.

PD: Uso Visual Studio Community 2017, lenguaje C++ bajo Win32.

Hola:

Quiero usar e instalar esta librería para Visual C++, concretamente Visual Studio Community 2017.
https://github.com/Gmatarrubia/LibreriasTutoriales

Su código es este:

Código (cpp) [Seleccionar] Expandir

#include
#include
#include "SerialClass.h"
using namespace std;

void main () {
    Serial* Arduino = new Serial("COM7");


    while( Arduino->IsConnected() ){
        char palabra[] = "PalabraDelMundo";

        cout<<"Arduino conectado"<<endl;
       
        cout<<"Enviando :"<<palabra<<endl;
        Arduino->WriteData(palabra,sizeof(palabra)-1);

        Sleep(500);

        Arduino->ReadData(palabra,sizeof(palabra)-1);
        cout<<"Recibido: "<<palabra<<endl;
   
        cout<<"-------------------"<<endl;
        Sleep(1000);
    }

Creo un proyecto nuevo.




Me crea este código.


Añado las librerías com indica abajo.


Lo mismo para la hora y lo refleja, tanto en cpp como en h indicado abajo.


Como que no detecta la librería.


¿En que fallo?

Un cordial saludo.

[Java SE]

Hola:

Quiero pasar este código de C# a Java con NetBeans.



Instalar Java actualizado:
https://www.java.com/es/download/

Compilador NetBeans (En español), Java SE:
https://netbeans.org/downloads/index.html

Tutorial sobre instalación del NetBeans y las librerías RxTx para controlar el puerto serie de Arduino:
https://es.slideshare.net/Metaconta2/interfaz-java-y-arduino

Librería oficial RxTx solo para 32 bits:
http://rxtx.qbang.org/wiki/index.php/Download

Librería alternativa RxTx de 32 y de 64 bits. Usaremos 64 bits. (Recomendado):
http://jlog.org/rxtx-win.html

El código de C# es este aquí abajo.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Text;
using System.IO.Ports;
using System.IO;
using System.Diagnostics;
using System.Threading;

namespace Recibir_archivo_desde_Arduino_consola_06
{
    class Program
    {
        static int cantidadBytes;
        static StringBuilder sb = new StringBuilder();

        static void Main(string[] args)
        {
            string COM = "";
            // Título de la ventana.
            Console.Title = "Recoger foto desde Arduino y crearlo en el disco duro";

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

            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort();

            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.

Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear();

            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.


            Puerto_serie.BaudRate = 115200; // Baudios. 115200.
            Puerto_serie.Parity = Parity.None; // Paridad.
            Puerto_serie.DataBits = 8; // Bits de datos.
            Puerto_serie.StopBits = StopBits.One; // Bits de parada.
            Puerto_serie.Handshake = Handshake.None; // Control de flujo.

            // Establecer la lectura / escritura de los tiempos de espera.
            Puerto_serie.ReadTimeout = -1; // 500.
            Puerto_serie.WriteTimeout = -1; // 500.

            try
            {
                Puerto_serie.Open(); // Abrir el puerto serie.
            }

            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
                o no lo encuentra.");
                Console.ReadKey(); // Pulse cualquier tecla para salir.
            }

            catch (UnauthorizedAccessException e)
            {
                Console.WriteLine(e);
            }
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Console.WriteLine("Esperando datos desde Arduino... \n");
            Console.ReadKey();
            Puerto_serie.Close(); // Cerrar puerto.
        }

        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                SerialPort sp = (SerialPort)sender;
                string indata = sp.ReadExisting();
                string[] data = indata.Split('A');
                cantidadBytes = int.Parse(data[0]);


                switch (data[1].ToString())
                {
                    case "1":
                        Console.WriteLine("Tamaño: " + cantidadBytes + " Bytes.");
                        Console.WriteLine("Foto: " + data[1] + ". Tipo de archivo: JPG");
                        break;

                    case "2":
                        Console.WriteLine("Tamaño: " + cantidadBytes + " Bytes.");
                        Console.WriteLine("Foto: " + data[1] + ". Tipo de archivo: PNG.");
                        break;

                    default:
                        Console.WriteLine("Cosas raras en 'data': " + data.ToString()); // Por si hal algún error.
                        break;
                }

                int contador = 0;
                byte[] datosArray = new byte[cantidadBytes];

                switch (indata)
                {
                    case "17729A1":
                        Thread.Sleep(100); // Retardo.
                        byte[] miBuffer = Encoding.ASCII.GetBytes("OK1"); // Codificación ASCII.
                        sp.Write(miBuffer, 0, miBuffer.Length); // Envía OK1 al puerto serie.
                        break;

                    case "2065A2":
                        Thread.Sleep(100); // Retardo.
                        byte[] miBuffer2 = Encoding.ASCII.GetBytes("OK2"); // Codificación ASCII.
                        sp.Write(miBuffer2, 0, miBuffer2.Length); // Envía OK2 al puerto serie.
                        break;

                    default:
                        Console.WriteLine("Cosas raras en 'indata': " + indata.ToString()); // Por si hal algún error.
                        break;
                }

                while (true)
                {

                    contador += sp.Read(datosArray, contador, datosArray.Length - contador);

                    Console.SetCursorPosition(10, 6);
                    Console.Write("Datos recibidos:  {0}", contador + " Bytes.");
                    Console.WriteLine("                   ");

                    if ((contador == cantidadBytes) && (contador == 17729))
                    {
                        Mensaje1();
                        File.WriteAllBytes("fotón.jpg", datosArray); // Crear archivo en el disco duro.
                        Mensaje2();
                        Process.Start("fotón.jpg"); // Ejecutar visualizador de imágenes.
                        Mensaje3();
                        break; // Garantiza que el ciclo termine.
                    }

                    if ((contador == cantidadBytes) && (contador == 2065))
                    {
                        Mensaje1();
                        File.WriteAllBytes("fotón.png", datosArray); // Crear archivo en el disco duro.
                        Mensaje2();
                        Process.Start("fotón.png"); // Ejecutar visualizador de imágenes.
                        Mensaje3();
                        break; // Garantiza que el ciclo termine.
                    }
                }

                void Mensaje1()
                {
                    Console.WriteLine();
                    Console.WriteLine("Creando archivo al disco duro...");
                }

                void Mensaje2()
                {
                    Console.WriteLine();
                    Console.WriteLine("Archivo creado. Ejecutando imagen.");
                }

                void Mensaje3()
                {
                    Console.WriteLine();
                    Console.WriteLine("Imagen ejecutada.");
                    Console.WriteLine();
                    Console.WriteLine("Cabecera recibida: " + indata + "\n");
                    Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
                    Console.WriteLine("FIN DE PROGRAMA.");
                    Console.ForegroundColor = ConsoleColor.Gray; // Letras grises otra vez.
                }
            }

            catch (FormatException)
            {
                // System.FormatException: 'La cadena de entrada no tiene el formato correcto.'
            }
        }
    }
}


En estos momentos estoy instalando la librería RxTx de 64 bits para Windwos 10 de 64 bits que es el que uso actualmente. El código de C# arriba fucniona de maravilla.

Esto de Java para adaptarme tardaré una eternidad, al menos se que el Hola mundo es Console.WriteLine("Hola mundo"); de C# es el equivalente a System.out.println("Hola mundo"); de Java.

Cualquier ayuda es bienvenida.

Hola:

Quiero cerrar y abrir la bandeja del lector de DVD con el botón manualmente, y que lo sepa C#. Estoy usando Visual Studio Community 2017.

En otro momento hicimos desde C#, controlar la bandeja abrirla y cerrarla pulsando los botones como indica en la interfaz de abajo.



Código fuente sencillo de C#:

Código (csharp) [Seleccionar] Expandir

using System;
using System.Runtime.InteropServices; // No olvidar.
using System.Text;
using System.Windows.Forms;

namespace Lector_discos_cs
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        [DllImport("winmm.dll")]
        public static extern Int32 mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
            int uReturnLength, IntPtr hwndCallback);
       
        StringBuilder rt = new StringBuilder(127);

        private void button_Abrir_Click(object sender, EventArgs e)
        {
            label_Mensaje.Text = "Abriendo...";
            Application.DoEvents();
            mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
            label_Mensaje.Text = "Abierto";
        }

        private void button_Cerrar_Click(object sender, EventArgs e)
        {
            label_Mensaje.Text = "Cerrando...";
            Application.DoEvents();
            mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero);
            label_Mensaje.Text = "Cerrado";
        }
    }
}

Hasta aquí todo bien.

Ahora quiero hacer, saber antes que nada, si es posible que al meter la bandeja con la mano o pulsar el botón físicamente del lector, C# puede saber su estado, cunado está abierto y cuando está cerrado.

En este caso, no hay botones para Windows Form de C#, solo un label que indica el estado "ABIERTO" y "CERRADO".

¿Es posible hacerlo?

Si es así. ¿Cómo se hace?

Lo único que pensé que este enlace valdría la pena o te daba información, pero es otra cosa.

Que tengan buena semana.

Tutorial para iniciados de modo introducción de los tres métodos para crear un formulario. Ya puedes configurar en algunas tecnologías el primer formulario con cualquiera de ellso eligiendeo CLR, MFC o Win32 en C++ con Visual Studio Community 2017.

Ver tutorial.

Un cordial saludos.

PD: También tutorial la versión Visual studio Community 2015.

[Gravedad Código Descripción Proyecto Archivo Línea Estado suprimidoError C1010 final de archivo inesperado al buscar la directiva de encabezado precompilado. Compruebe si olvidó agregar '#include "stdafx.h"' al código fuente? Proyecto_Win32 c:\users\usuario\documents\visual studio 2017\projects\proyecto_win32\proyecto_win32\mensaje_texto.cpp 145]

Hola:

Estoy usando el nuevo Visual C++ 2017 con Win32. He probado este ejemplo que puedes ver en este enlace.

https://msdn.microsoft.com/es-es/library/bb384843.aspx

El código de ejemplo que viene completo al final del documento, si funciona muy bien para Visual Stduio Community 2015, no da ningún problema. Este mismo código me da problemas con Visual Studuio Community 2017.

Código (cpp) [Seleccionar] Expandir

// GT_HelloWorldWin32.cpp
// compile with: /D_UNICODE /DUNICODE /DWIN32 /D_WINDOWS /c

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>

// Global variables

// The main window class name.
static TCHAR szWindowClass[] = _T("win32app");

// The string that appears in the application's title bar.
static TCHAR szTitle[] = _T("Formulario");

HINSTANCE hInst;

// Forward declarations of functions included in this code module:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPLICATION));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_APPLICATION));

if (!RegisterClassEx(&wcex))
{
MessageBox(NULL,
_T("Call to RegisterClassEx failed!"),
_T("Win32 Guided Tour"),
NULL);

return 1;
}

hInst = hInstance; // Store instance handle in our global variable

   // The parameters to CreateWindow explained:
   // szWindowClass: the name of the application
   // szTitle: the text that appears in the title bar
   // WS_OVERLAPPEDWINDOW: the type of window to create
   // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
   // 500, 100: initial size (width, length)
   // NULL: the parent of this window
   // NULL: this application does not have a menu bar
   // hInstance: the first parameter from WinMain
   // NULL: not used in this application
HWND hWnd = CreateWindow(
szWindowClass,
szTitle,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
300, 300,
NULL,
NULL,
hInstance,
NULL
);

if (!hWnd)
{
MessageBox(NULL,
_T("Call to CreateWindow failed!"),
_T("Win32 Guided Tour"),
NULL);

return 1;
}

// The parameters to ShowWindow explained:
// hWnd: the value returned from CreateWindow
// nCmdShow: the fourth parameter from WinMain
ShowWindow(hWnd,
nCmdShow);
UpdateWindow(hWnd);

// Main message loop:
MSG msg;
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}

return (int)msg.wParam;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
TCHAR greeting[] = _T("Visual C++ 2017 Win32");

switch (message)
{
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);

// Here your application is laid out.
// For this introduction, we just print out "Hello, World!"
// in the top left corner.
TextOut(hdc,
55, 105,
greeting, _tcslen(greeting));
// End application-specific layout section.

EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
break;
}

return 0;
}

El error que me da es este:

Gravedad    Código    Descripción    Proyecto    Archivo    Línea    Estado suprimido
Error    C1010    final de archivo inesperado al buscar la directiva de encabezado precompilado. Compruebe si olvidó agregar '#include "stdafx.h"' al código fuente?    Proyecto_Win32    c:\users\usuario\documents\visual studio 2017\projects\proyecto_win32\proyecto_win32\mensaje_texto.cpp    145   

Si pongo arriba dicho #include "stdafx.h" me marca como error, como que no lo encuentra.

¿Alguna idea?

Saludos.

[Desarrollo de la plataforma universal de Windows.Desarrollo de escritorio .netDesarrollo para el escritorio con C++.]

Hola:

He intentado descargar la versión ISO del Visual Studio Community 2017 (gratuito) en el cual ya no se puede porque no cabe en un DVD. Pero hay un truco para tenerlo todo en el local, a mi me ocupa unos 20 GB descargado. Más información de cómo se hace aquí.

Me sale al ejecutar el ejecutable este menú.


Ver zoom.

Lo he instaldo desde la Web y apenas me aparecen plantillas, ni siquiera me aparece el de Windows Form de C#, ni Visual Basic .net.

Ahora lo tengo descargado en local y desistanlé por vía Web por si acaso. Por si acaso, voy a instalar los tres que pone arriba wn Windowa.
Desarrollo de la plataforma universal de  Windows.
Desarrollo de escritorio .net
Desarrollo para el escritorio con C++.

En la página 10 de este documento de abajo indica las herramientas comunes de VS 2015 y en el VS 2017 no se donde está.

https://www.slideshare.net/Metaconta2/formulario-windows-con-visual-c

¿Alguna idea?

Saludos.

PD: En este mismo momento, instalando las tres primeras opciones.

Hola:

Tengo una impresora por USB. Quiero aprender como se hackea desde red, al menos desde la Raspberry Pi o otro ordenador y que la impresora imprima. Hay gente que lo hacen y de modo cómico.


http://www.neoteo.com/impresora-parte-una-botnet-la-seguridad-las-impresoras-al-descubierto

Si hay que hacer un programa, pues se hace.

Cualquier idea o sugerencia, bienvenido sea.

Saludos.

Hola:

Mirando aquí este código en C#, está en C++ y VB .net, pero en F# no veo ni papa.

Cambiar de C# por F#:

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO.Ports;

class PortDataReceived
{
   public static void Main()
   {
       SerialPort mySerialPort = new SerialPort("COM1");

       mySerialPort.BaudRate = 9600;
       mySerialPort.Parity = Parity.None;
       mySerialPort.StopBits = StopBits.One;
       mySerialPort.DataBits = 8;
       mySerialPort.Handshake = Handshake.None;
       mySerialPort.RtsEnable = true;

       mySerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

       mySerialPort.Open();

       Console.WriteLine("Press any key to continue...");
       Console.WriteLine();
       Console.ReadKey();
       mySerialPort.Close();
   }

   private static void DataReceivedHandler(
                       object sender,
                       SerialDataReceivedEventArgs e)
   {
       SerialPort sp = (SerialPort)sender;
       string indata = sp.ReadExisting();
       Console.WriteLine("Data Received:");
       Console.Write(indata);
   }
}

He intentado encontrar tutoriales de F# en español, más bien estáenel MSDN de los foros oficiales.
https://msdn.microsoft.com/es-es/library/dd233160(v=vs.110).aspx
https://msdn.microsoft.com/es-es/library/ee241126(v=vs.110).aspx
https://msdn.microsoft.com/es-es/library/ee241127(v=vs.110).aspx

Para saber de que va está bien. Para hacer el minichat de arriba de C# a F# lo veo más complicado.

Vídeos del 2009, mejor algo que nada en español.
[youtube=640,360]https://www.youtube.com/watch?v=Tbe-b941xlw[/youtube]
Segunda parte.

Casi no hay nada de video tutoriales en español, de PowerShell está habiendo más aunque este último es másbien para tareas administrativas.

¿Alguna ayuda?

Un cordial saludo.

PD: Como se nota que no mola a lagente F# y si otros lenguajes, sobre todo, hoy en día se usa VB 6 en el cual no se recomienda para equipos actuales y no lo sueltan ni por asomo.

Hola:

Cada vez que veola gente comprar plafones de Led, le advierten que con el tiempo pierden intensidad e iluminación o se apagan de repente.

Me acaban de regalar este.

Es para techo falso.
Downlight LED regulable empotrable y redondo en acabado blanco, con una potencia de 20W y 1700 lúmenes. Tono de luz neutra (4000K) sustituye al downlight de bajo consumo. Incluye fuente de alimentación (driver dimmable). Versión: 06-12-2014.

El transformador que viene dice ser de 100-240 VAC de entrada y salida 54-63 VDC 300 mA.y cuando lo mides con el tester en vacío te suelta 81 VDC.

Estas lámparas se cascan rápido y según indican aquí.
http://www.luisllamas.es/2013/04/verdades-y-mentiras-sobre-la-vida-util-de-los-led/

La verdad que hay gente que inventan sus propis diseños increibles.
https://es.pinterest.com/explore/l%C3%A1mpara-led-957789226697/

La mejor opción para bajo mi punto de vista, es construirse su propia lápara de Led, hasta la fuente de alimentación o suar una de calidad.



http://www.neoteo.com/diy-lampara-de-bajo-consumo-led

¿Alguna experiencia por parte de ustedes o opinión?

Saludos.

Hola:

Tengo este código de abajo que funciona bien. Lo que hace es, al recibir algún dato por el puerto serie, me lo almacena en un array y guarda el archivo en el disco duro. Hecho en C#.

Código (csharp,77) [Seleccionar] Expandir


using System;
using System.Diagnostics;
using System.IO;
using System.IO.Ports;

namespace Recibir_archivo_desde_Arduino_consola_02
{
   class Program
   {
       static void Main(string[] args)
       {
           string COM = "";

           // Tamaño ventana consola.
           Console.WindowWidth = 55; // X. Ancho.
           Console.WindowHeight = 15; // Y. Alto.
           Console.Title = "Recoger foto desde Arduino y crearlo en el disco duro"; // Título de la ventana.

           // Crear un nuevo objeto SerialPort con la configuración predeterminada.
           SerialPort Puerto_serie = new SerialPort();

           // Configuración.
           Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.

Puerto: ");
           COM = Console.ReadLine(); // Escribir el número del puerto.
           Console.Clear();

           Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.


           Puerto_serie.BaudRate = 115200; // Baudios. 115200.
           Puerto_serie.Parity = Parity.None; // Paridad.
           Puerto_serie.DataBits = 8; // Bits de datos.
           Puerto_serie.StopBits = StopBits.Two; // Bits de parada.
           Puerto_serie.Handshake = Handshake.None; // Control de flujo.

           // Establecer la lectura / escritura de los tiempos de espera.
           Puerto_serie.ReadTimeout = -1; // 500.
           Puerto_serie.WriteTimeout = -1; // 500.

           try
           {
               Puerto_serie.Open(); // Abrir el puerto serie.
           }

           catch (IOException)
           {
               Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
               Console.CursorVisible = false;
               Console.SetCursorPosition(16, 6);
               Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
               o no lo encuentra.");
               Console.ReadKey(); // Pulse cualquier tecla para salir.
           }

           catch (UnauthorizedAccessException e)
           {
               Console.WriteLine(e);
           }
           Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

           Console.WriteLine("Esperando datos desde Arduino...");
           Console.Read();
           Puerto_serie.Close(); // Cerrar puerto.
       }

       private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)

       {
           try
           {
               SerialPort sp = (SerialPort)sender;
               int contador = 0;
               byte[] datosArray = new byte[17729]; // Aquí tengo que cambiar el valor cuando recibo datos desde el puerto serie.

               while (contador < datosArray.Length)
               {

                   contador += sp.Read(datosArray, contador, datosArray.Length - contador);

                   Console.SetCursorPosition(10, 2);
                   Console.Write("Datos recibidos:  {0}", contador);
                   Console.WriteLine("                   ");

                   if (contador == 17729)
                   {
                       Console.WriteLine();
                       Console.WriteLine("Creando archivo al disco duro...");
                       File.WriteAllBytes("fotón.jpg", datosArray); // Crear archivo en el disco duro.
                       Console.WriteLine();
                       Console.WriteLine("Archivo creado. Ejecutando imagen.");
                       Process.Start("fotón.jpg"); // Ejecutar visualizador de imágenes.
                       Console.WriteLine();
                       Console.WriteLine("Imagen ejecutada.");
                       Console.WriteLine();
                       Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
                       Console.WriteLine("FIN DE PROGRAMA.");
                       Console.ForegroundColor = ConsoleColor.Gray; // Letras grises otra vez.
                   }
               }
           }


           catch (TimeoutException)
           {
               //maybe increase ReadTimeout or something, use exponential backoff, your call
           }

           catch (IOException)
           {
               // Console.WriteLine("La operación de E/S se anuló por una salida de subproceso o por una solicitud de aplicación.");
           }
       }
   }
}


Quiero tener ideas para modificar este programa.

Los datos del puerto serie puede llegar desde Arduino o desde otro PC. Como llega desde Arduino en este caso, tiene dos botones, si pulsa el primer botón, C# recibe ciertos comandos que son estos:

Si en Arduino presiono el primer botón, C# le llega este número de 5 Bytes en este caso, 17729. Ese valor tiene que incluirse aquí, en esta parte del código indicado abajo.

Código (csharp) [Seleccionar] Expandir

byte[] datosArray = new byte[17729];

Como puedes ver, he puesto manualmente el valor de este array 17729.

¿Cómo hago que al detectar cualquier valor, en este caso 17729 sea para el array datosArray?

Digo 17729 como ejemplo, si le llega 478, pues que sea 478.

Lo que no entiendo que luego de llegar 17729, que son solo 5 dígitos, llegará de inforamación 17729 Bytes detrás.

Si no haz entendido algo, preguntar para explicarlo de otra manera.

Saludos.

Hola:

Quiero saber vuestras experiencias sobre lenguajes de programación que voy a nombrar si lo han probado.

Quiero probar con Visual Studio Community 2015 (Gratuito) este lenguaje llamado R. Se puede programar bajando un programa apra añadirlo en Visual Studio, aunque ya vendrá de forma oficial en Visual Studio 2017, por ahora solo está la versión RC.

Lenguaje F#. En su día lo probé en consola, creo que no tiene modo Visual. He intentado hacer este código de ejemplo en C# a F# sin éxito para saber si puedo controlar el puerto serie, hay que conocer muchas cosas.

estuve un tiempo con [url0https://es.wikipedia.org/wiki/Windows_PowerShell]PowerShell[/url], he leído noticias de este tipo, adiós a CMD y el sustituto es PowerShell. No se consiedra este lenguaje para desarroladores, si F#. Por esono se encuentra en los foros oficiales del MSDN y si en TechNET, es más bien para administración mediante Scrips sobre todo para Windows Server.

En Resumen:
Lenguaje R, F# y PowerShell.

¿Qué opinas?

Saludos.

Hola:

Tengo en el virtual Box instalado openSUSE v42.2. (No me digan po rprivado que use Kali Linux porque lo usa mucho en Mr Robot, xd).

Instalé el minicom, que es el equivalente del HyperTerminal de Windows, desde ahí envio y recibo datos por el puerto serie, quiero comunicarlo con Arduino y no me lo detecta.

Aquí hay un documento que si me funciona si tengo instalado en el disco duro openSuse, pero no si lo tengo instalado en una máuina virtual como Virtual Box.

Ver tutorial.

¿Alguna ayuda?

Saludos.