Hola:

Tengo el código en C# de esta manera. Este código solo recibe datos por el puerto serie.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
using System.IO.Ports; // No olvidar.
using System.Threading;
 
namespace Entrada_Arduino_AWF_1_CS
{
    public partial class Form1 : Form
    {
        // Utilizaremos un string como buffer de recepción.
        string Recibidos;
 
        public Form1()
        {
            InitializeComponent();
 
            if (!serialPort1.IsOpen)
            {
                try
                {
                    serialPort1.Open();
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
 
                serialPort1.DataReceived += new SerialDataReceivedEventHandler(Recepcion);
            }
        }
 
        // Al recibir datos.
        private void Recepcion(object sender, SerialDataReceivedEventArgs e)
        {
            // Acumula los caracteres recibidos a nuestro 'buffer' (string).
            Recibidos += serialPort1.ReadExisting();
 
            // Invocar o llamar al proceso de tramas.
            Invoke(new EventHandler(Actualizar));
        }
 
        // Procesar los datos recibidos en el bufer y extraer tramas completas.
        private void Actualizar(object sender, EventArgs e)
        {
 
            switch (Recibidos)
            {
                case "ON":
                    panel1.BackColor = Color.Green;
                    label_Lectura.Text = "Activado";
                    pictureBox_Dibujo.Image = Properties.Resources.Led_rojo_encendido;
                    Recibidos = "";
                    break;
 
                case "OFF":
                    panel1.BackColor = Color.Red;
                    label_Lectura.Text = "Desactivado";
                    pictureBox_Dibujo.Image = Properties.Resources.Led_rojo_apagado;
                    Recibidos = "";
                    break;
            }
        }
 
        // Cuando cierre la aplicación.
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (serialPort1.IsOpen) // ¿El puerto está abierto?
            {
                serialPort1.Close(); // Cerrar puerto.
            }
        }
    }
}

He intentado imigar el código de C# a C++/CLR. Pero que va.

#pragma once
 
namespace Entrada_Arduino_CPP_CLR_1 {
 
	using namespace System;
	using namespace System::ComponentModel;
	using namespace System::Collections;
	using namespace System::Windows::Forms;
	using namespace System::Data;
	using namespace System::Drawing;
 
	using namespace System::IO::Ports; // No olvidar.
 
	/// <summary>
	/// Resumen de Form_Principal
	/// </summary>
	public ref class Form_Principal : public System::Windows::Forms::Form
	{
		// Utilizaremos un string como buffer de recepción.
		String^ Recibidos;
 
	public:
		Form_Principal(void)
		{
			InitializeComponent();
			//
			//TODO: agregar código de constructor aquí
			//
 
			if (!serialPort1->IsOpen)
			{
				try
				{
					serialPort1->Open();
				}
				catch (Exception ^ex)
				{
					MessageBox::Show(ex->ToString());
				}
 
				serialPort1->DataReceived += new SerialDataReceivedEventHandler(Recepcion);
			}
		}
 
		// Al recibir datos.
		private void Recepcion(object sender, SerialDataReceivedEventArgs e)
		{
			// Acumula los caracteres recibidos a nuestro 'buffer' (string).
			Recibidos += serialPort1->ReadExisting();
 
			// Invocar o llamar al proceso de tramas.
			Invoke(new EventHandler(Actualizar));
		}
 
		// Procesar los datos recibidos en el bufer y extraer tramas completas.
		private void Actualizar(object sender, EventArgs e)
		{
 
			switch (Recibidos)
			{
			case "ON":
				panel1->BackColor = Color::Green;
				label_Lectura->Text = "Activado";
				pictureBox_Dibujo->Image = Properties::Resources::Led_rojo_encendido;
				Recibidos = "";
				break;
 
			case "OFF":
				panel1->BackColor = Color::Red;
				label_Lectura->Text = "Desactivado";
				pictureBox_Dibujo->Image = Properties::Resources::Led_rojo_apagado;
				Recibidos = "";
				break;
			}
		}
 
	protected:
		/// <summary>
		/// Limpiar los recursos que se estén usando.
		/// </summary>
		~Form_Principal()
		{
			if (components)
			{
				delete components;
			}
		}
	private: System::Windows::Forms::Label^  label_titulo;
	protected:
	private: System::Windows::Forms::Panel^  panel1;
	private: System::Windows::Forms::Label^  label_Lectura;
	private: System::Windows::Forms::PictureBox^  pictureBox_Dibujo;
	private: System::IO::Ports::SerialPort^  serialPort1;
	private: System::Windows::Forms::Label^  label1;
	private: System::ComponentModel::IContainer^  components;
 
	private:
		/// <summary>
		/// Variable del diseñador necesaria.
		/// </summary>
 
 
#pragma region Windows Form Designer generated code
		/// <summary>
		/// Método necesario para admitir el Diseñador. No se puede modificar
		/// el contenido de este método con el editor de código.
		/// </summary>
		void InitializeComponent(void)
		{
			this->components = (gcnew System::ComponentModel::Container());
			System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(Form_Principal::typeid));
			this->label_titulo = (gcnew System::Windows::Forms::Label());
			this->panel1 = (gcnew System::Windows::Forms::Panel());
			this->label_Lectura = (gcnew System::Windows::Forms::Label());
			this->pictureBox_Dibujo = (gcnew System::Windows::Forms::PictureBox());
			this->serialPort1 = (gcnew System::IO::Ports::SerialPort(this->components));
			this->label1 = (gcnew System::Windows::Forms::Label());
			(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->pictureBox_Dibujo))->BeginInit();
			this->SuspendLayout();
			// 
			// label_titulo
			// 
			this->label_titulo->AutoSize = true;
			this->label_titulo->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 36, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point,
				static_cast<System::Byte>(0)));
			this->label_titulo->Location = System::Drawing::Point(29, 26);
			this->label_titulo->Name = L"label_titulo";
			this->label_titulo->Size = System::Drawing::Size(382, 55);
			this->label_titulo->TabIndex = 0;
			this->label_titulo->Text = L"Visual C++ CLR";
			// 
			// panel1
			// 
			this->panel1->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle;
			this->panel1->Location = System::Drawing::Point(23, 97);
			this->panel1->Name = L"panel1";
			this->panel1->Size = System::Drawing::Size(100, 100);
			this->panel1->TabIndex = 1;
			// 
			// label_Lectura
			// 
			this->label_Lectura->AutoSize = true;
			this->label_Lectura->Location = System::Drawing::Point(183, 138);
			this->label_Lectura->Name = L"label_Lectura";
			this->label_Lectura->Size = System::Drawing::Size(48, 13);
			this->label_Lectura->TabIndex = 2;
			this->label_Lectura->Text = L"Leyendo";
			// 
			// pictureBox_Dibujo
			// 
			this->pictureBox_Dibujo->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"pictureBox_Dibujo.Image")));
			this->pictureBox_Dibujo->Location = System::Drawing::Point(311, 97);
			this->pictureBox_Dibujo->Name = L"pictureBox_Dibujo";
			this->pictureBox_Dibujo->Size = System::Drawing::Size(100, 100);
			this->pictureBox_Dibujo->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage;
			this->pictureBox_Dibujo->TabIndex = 3;
			this->pictureBox_Dibujo->TabStop = false;
			// 
			// serialPort1
			// 
			this->serialPort1->BaudRate = 115200;
			this->serialPort1->PortName = L"COM4";
			this->serialPort1->StopBits = System::IO::Ports::StopBits::Two;
			// 
			// label1
			// 
			this->label1->AutoSize = true;
			this->label1->Location = System::Drawing::Point(349, 200);
			this->label1->Name = L"label1";
			this->label1->Size = System::Drawing::Size(25, 13);
			this->label1->TabIndex = 4;
			this->label1->Text = L"Led";
			// 
			// Form_Principal
			// 
			this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
			this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
			this->ClientSize = System::Drawing::Size(436, 262);
			this->Controls->Add(this->label1);
			this->Controls->Add(this->pictureBox_Dibujo);
			this->Controls->Add(this->label_Lectura);
			this->Controls->Add(this->panel1);
			this->Controls->Add(this->label_titulo);
			this->Name = L"Form_Principal";
			this->StartPosition = System::Windows::Forms::FormStartPosition::CenterScreen;
			this->Text = L"Electrónica PIC - C++ 2015";
			(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->pictureBox_Dibujo))->EndInit();
			this->ResumeLayout(false);
			this->PerformLayout();
 
		}
#pragma endregion
	};
}

¿Alguna ayuda?

Muchas gracias.

Hola:

Usando el Dev C++ con un hola mundo. En el título de la ventana quiero que me diga el nombre del programa. El programa es hecho en modo consola.

He buscado por google y me dice cambiar el color, pero eso es dentro del programa, no quiero cambiar colores, solo el nombre o título.

Espero que se entienda lo que quiero decir. También hay que ver si en consola es posible hacerlo en Dev C++, en C# se hace así:

Console.title = "Título o nombre del programa";

Estamos en C++ Win32 en modo consola.

Saludos.

Hola:

Tengo un código que encontré sobre el puerto serie, recibir y enviar datos hechos en C++.

// Comunicación a través del puerto serie
// usando el API de Windows
// Modo consola.
// (C) Enero de 2013, Salvador Pozo Coronado
// Con Clase: http://www.conclase.net
// salvador@conclase.net
 
#include <iostream>
#include <cstring>
#include <windows.h>
 
using namespace std;
 
// Tipos de datos:
typedef struct
{
    char Puerto[5];
    int Baudios;
    int BitsDatos;
    int BitsStop;
    char Paridad[25];
} tipoOpciones;
 
bool ocupado;
// Prototipos:
HANDLE InicioComunicacion(tipoOpciones*);
bool FinComunicacion(HANDLE);
DWORD Hilo(LPDWORD lpdwParam);
void EscribirSerie(HANDLE, char *);
 
int main(int argc, char *argv[])
{
    bool salir=false;
    DWORD id;
    char cad[80];
    tipoOpciones Ops;         // Opciones
    HANDLE idComDev;
    HANDLE hHilo;             // Hilo del puerto serie
 
    ocupado = true;
    // Inicializar opciones del puerto serie:
    strcpy(Ops.Puerto, "COM4");
    Ops.Baudios = 115200;
    Ops.BitsDatos = 8;
    Ops.BitsStop = 2;
    strcpy(Ops.Paridad, "Sin paridad");
 
    // No se ha establecido comunicación:
    idComDev = InicioComunicacion(&Ops);
    if(idComDev == INVALID_HANDLE_VALUE) {
        cout << "Inicialización puerto serie" << endl;
        cout << "ERROR: No se puede acceder al puerto serie." << endl;
        return 1;
    }
    // Lanzar hilo de lectura del puerto serie:
    hHilo = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Hilo, (LPDWORD)&idComDev, 0, &id);
    if(!hHilo) cout << "Error" << endl;
    // Bucle principal:
    ocupado = false;
    while(!salir) {
        // Leer un comando:
        cin.getline(cad, 80);
        // Si es "salir", abandonar el bucle:
        if(!strcmp(cad, "salir")) salir = true;
        else {
            // Si no, enviar cadena por el puerto serie:
            strcat(cad, "\r");
            EscribirSerie(idComDev, cad);
        }
    }
    // Liberar hilo:
    CloseHandle(hHilo);
    // Liberar puerto serie:
    FinComunicacion(idComDev);
    return 0;
}
 
// Iniciar el puerto serie:
HANDLE InicioComunicacion(tipoOpciones *Ops)
{
    bool fSuccess;
    HANDLE idComDev;
    DCB dcb;                  // Puerto serie
 
    // Abrir el fichero asociado al puerto:
    idComDev = CreateFile(Ops->Puerto, GENERIC_READ | GENERIC_WRITE,
        0, NULL, OPEN_EXISTING, 0, NULL);
    if(idComDev == INVALID_HANDLE_VALUE) {
        cout << "ERROR: CreateFile. Inicialización puerto serie" << endl;
        return INVALID_HANDLE_VALUE;
    }
    PurgeComm(idComDev, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
 
    // Leer estructura de control del puerto serie, cdb:
    fSuccess = GetCommState(idComDev, &dcb);
    if(!fSuccess) {
        cout << "ERROR: GetCommState. Inicialización puerto serie" << endl;
        // Cerrar el puerto, regresar con 0.
        CloseHandle(idComDev);
        return INVALID_HANDLE_VALUE;
    }
 
    // Modificar el dcb según las opciones definidas:
    dcb.BaudRate = Ops->Baudios;
    dcb.ByteSize = Ops->BitsDatos;
 
    if(!strcmp(Ops->Paridad, "Sin paridad")) dcb.Parity = NOPARITY;
    if(!strcmp(Ops->Paridad, "Paridad par")) dcb.Parity = EVENPARITY;
    if(!strcmp(Ops->Paridad, "Paridad impar")) dcb.Parity = ODDPARITY;
 
    switch(Ops->BitsStop) {
        case 1:
            dcb.StopBits = ONESTOPBIT;
            break;
        case 2:
            dcb.StopBits = TWOSTOPBITS;
            break;
    }
 
    // Modificar la estructura de control del puerto serie:
    fSuccess = SetCommState(idComDev, &dcb);
    if(!fSuccess) {
        cout << "ERROR: SetCommStatus. Inicialización puerto serie" << endl;
        // Cerrar el puerto, regresar con 0.
        CloseHandle(idComDev);
        return INVALID_HANDLE_VALUE;
    }
 
    //// ASIGNAR TIMOUTS!!!
 
    return idComDev;
}
 
// Finalizar comunicación por puerto serie:
bool FinComunicacion(HANDLE idComDev)
{
    // Cerrar el puerto serie:
    CloseHandle(idComDev);
    return true;
}
 
// Hilo de escucha del puerto serie:
DWORD Hilo(LPDWORD lpdwParam)
{
    DWORD leidos;
    COMSTAT cs;
    char *cad;
    DWORD dwCommEvent;
    HANDLE idComDev = *((HANDLE*)lpdwParam);
 
    if(!SetCommMask(idComDev, EV_RXCHAR)) {
        cout << "Error al iniciar captura de evento" << endl;
        return 0;
    }
    do {
        if(WaitCommEvent(idComDev, &dwCommEvent, NULL)) {
            SetCommMask(idComDev, EV_RXCHAR);
            while(ocupado);
            ocupado = true;
            if(dwCommEvent & EV_RXCHAR) {
                ClearCommError(idComDev, &leidos, &cs);
                leidos=0;
                cout << "Detectados " << cs.cbInQue << " caracteres" << endl;
                /* Leer buffer desde puerto serie */
                if(cs.cbInQue) {
                    cad = new char[cs.cbInQue+3]; // Caracteres en buffer, más retorno de línea, más nulo
                    ReadFile(idComDev, cad, cs.cbInQue, &leidos, NULL);
                    cad[leidos] = '\n'; // Terminar cadena con salto de línea y nulo
                    cad[leidos+1] = '\r';
                    cad[leidos+2] = 0;
                    cout << cad;
                    delete[] cad;
                }
            } else {
                cout << "Evento: EV_BREAK o EV_ERR" << endl;
                 ClearCommBreak(idComDev);
            }
            ocupado = false;
        } else {
            cout << "Error en WaitCommEvent" << endl;
            ClearCommError(idComDev, NULL, NULL);
        }
        Sleep(10);
    } while(true);
    return 0;
}
 
void EscribirSerie(HANDLE idComDev, char *buf)
{
    char oBuffer[256];  /* Buffer de salida */
    DWORD iBytesWritten;
 
    iBytesWritten = 0;
    strcpy(oBuffer, buf);
    while(ocupado);
    ocupado = true;
    WriteFile(idComDev, oBuffer, strlen(oBuffer), &iBytesWritten, NULL);
    ocupado = false;
}

Fuente:
http://articulos.conclase.net/?tema=comunicacion&art=serie&pag=000

Por supuesto, debo modificarlo. Creo una interfaz MFC del C++ bajo Visual Studio Community 2015 indicado en este documento a partir de la página 30.

En el MFC de Visual Studio, hay que incluir dos botones y un richTextBox.


Imagen, Arduino debe recibir datos desde el puerto serie y enviar que ha sido recibido.


Solo quiero que con MFC sea capaz de apagar y encender un Led, tal como lo hago con otro lenguaje, C#, Visual Basic pero este MFC de C++ me cuesta muchísimo.


Si les pica la curiosidad, el código de Arduino es este.

/*
 * Electrónica PIC.
 * 
 * Ejemplo:
 * Encender y apagar un Led con Arduino y Visual Studio 2015.
 */
 
int pinLed =  13;   // Declaramos la variable pin del Led.
char caracter;
String comando;
 
void setup()
{
  Serial.begin(9600);
}
 
void loop()
{
  pinMode(pinLed, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  /* 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 pulsemos 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);
  }
 
  /* Unavez ya tengo la cadena "acabada", compruebo su valor y hago
   * que la placa Arduino reaccione según sea este. Aquí podríamos
   * hacer lo que quiesiéramos: si el comando es "tal", enciende
   * un Led, si es cual, mueve un motor... y así.
   */
  if (comando.equals("ON") == true)  // Led_ON.
  {
        digitalWrite(pinLed, HIGH); // Enciende el Led.
        Serial.println("Led 13 encendido.");
  }
 
  if (comando.equals("OFF") == true) // Led_OFF.
  {
        digitalWrite(pinLed, LOW); // Apaga el Led.
        Serial.println("Led 13 apagado.");
  } 
 
  // Limpiamos la cadena para volver a recibir el siguiente comando. 
  comando="";
}

En resumen,  a partir del código de C++ para consola, adaptarlo a modo Visual MFC C++, solo enviar ON y OFF y recibir datos de respuesta.

Espero resolver este problema de una vez. C++ me vuelve loco.

Un cordial saludos.

Hola:

Estoy con WPF de VB 2015. Este es la interfaz.



La parte de programación es esta:

Imports System.IO.Ports ' No olvidar.
Imports System.Text ' No olvidar.
 
Class MainWindow
    ' Utilizaremos un string como buffer de recepción.
    Dim Recibidos As String
    ' Creamos un objeto sdel puerto serie.
    Dim serialPort1 As New SerialPort()
 
    Private Sub Form_Principal_Loaded(sender As Object, e As RoutedEventArgs) Handles Form_Principal.Loaded
        ' Configuramos el puerto serie.
        serialPort1.BaudRate = 115200 ' Baudios, tiene que ser el mismo que Arduino UNO.
        serialPort1.PortName = "COM4" ' Elegimos el COM4 igual que Arduino en mi caso.
        serialPort1.Parity = Parity.None ' Nada de paridad.
        serialPort1.DataBits = 8 ' 8 bits.
        serialPort1.StopBits = StopBits.Two ' Funciona mejor con 2 bits de Stop.
 
        ' Abrir puerto mientras se ejecute la aplicación.
        If Not serialPort1.IsOpen Then
            Try
                serialPort1.Open()
            Catch ex As System.Exception
                MessageBox.Show(ex.ToString())
 
            End Try
        End If
        ' Ejecutar la función Recepción por disparo del evento ¡DataReived!
        serialPort1.DataReceived += Recepcion
    End Sub
 
    Private Sub Recepcion(sender As Object, e As SerialDataReceivedEventArgs)
        ' Acumular los caracteres recibidos a nuestro "buffer" (string).
        Recibidos += serialPort1.ReadExisting()
 
        ' Invocar o llamar al proceso de tramas.
        Me.Dispatcher.Invoke(AddressOf Actualizar)
    End Sub
 
    ' Procesar los datos recibidos en el buffer y extraer tramas completas.
    Private Sub Actualizar()
        Dim doc = New FlowDocument()
        doc.Blocks.Add(New Paragraph(New Run(Recibidos)))
 
        Select Case Recibidos
            Case "ON"
                image.Source = (New BitmapImage(New Uri("Led rojo encendido.png", UriKind.Relative)))
                label_Leyendo.Content = "Encendido."
                Rectangulo.Fill = New SolidColorBrush(Colors.Green)
                Recibidos = "" ' Limpiar.
                Exit Select
 
            Case "OFF"
                image.Source = (New BitmapImage(New Uri("Led rojo apagado.png", UriKind.Relative)))
                label_Leyendo.Content = "Apagado."
                Rectangulo.Fill = New SolidColorBrush(Colors.Red)
                Recibidos = "" ' Limpiar.
                Exit Select
        End Select
    End Sub
 
    ' Desde que cierres el programa, cierra el puerto.
    Private Sub Form_Principal_Closing(sender As Object, e As ComponentModel.CancelEventArgs) Handles Form_Principal.Closing
        If serialPort1.IsOpen Then ' ¿El puerto está abierto?
            serialPort1.Close() ' Cerrar puerto.
        End If
    End Sub
End Class
 

Gravedad    Código    Descripción    Proyecto    Archivo    Línea
Error    BC32022    'Public Event DataReceived As SerialDataReceivedEventHandler' es un evento y no se puede llamar directamente. Use una instrucción 'RaiseEvent' para generar un evento.    Entrada_Arduino_WPF_1_VB    C:\Users\Usuario\Documents\Visual Studio 2015\Projects\Entrada_Arduino_WPF_1_VB\Entrada_Arduino_WPF_1_VB\MainWindow.xaml.vb    28

Gravedad    Código    Descripción    Proyecto    Archivo    Línea
Error    BC30455    No se especificó un argumento para el parámetro 'e' de 'Private Sub Recepcion(sender As Object, e As SerialDataReceivedEventArgs)'.    Entrada_Arduino_WPF_1_VB    C:\Users\Usuario\Documents\Visual Studio 2015\Projects\Entrada_Arduino_WPF_1_VB\Entrada_Arduino_WPF_1_VB\MainWindow.xaml.vb    28

El programa completo se trada de recibir tramas de bytes por el puerto serie.

¿Alguna solución al problema?

Saludos.

PD: Uso Visual Studio Community 2015.

Hola:

Viendo esta noticia.


Tengo un sobre mesa, un Raspberry Pi 2 y un portatil con Windows y tiene webcam integrada, todo conectado desde el router.

Quiero hacer pruebas de hackear sea como sea mi propia webcam del portatil y sacar fotos y vídeos.

Si alguien sabe esto y lo ha hecho. Puede expresar sus experiencias de todo tipo.

Saludos.

Hola:

Me falla este programa, quiero coger la MAC de este formato que genera en la primera tarjeta de red física (04-B2-AF-EE-E2-34-6A-8C).

Al complicar, me dale este error.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using System.Net.NetworkInformation; // No olvidar.
 
namespace Leer_MAC
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "En busca del MAC";
 
            string Nombre_HostName = null;
            string Nombre_Dominio = null;
            string MAC = null;
 
            IPGlobalProperties Propiedades_PC = IPGlobalProperties.GetIPGlobalProperties();
            NetworkInterface[] Interfaz_red = NetworkInterface.GetAllNetworkInterfaces();
            Console.WriteLine("Información de interfaz para {0}.{1}     ",
                    Propiedades_PC.HostName, Propiedades_PC.DomainName);
            if ((Interfaz_red == null) || (Interfaz_red.Length < 1))
            {
                Console.WriteLine("  No hay interfaces de red encontrados.");
                return;
            }
 
            Console.WriteLine("  Número de interfaces .................... : {0}", Interfaz_red.Length);
            foreach (NetworkInterface Adaptador in Interfaz_red)
            {
                IPInterfaceProperties Propiedades = Adaptador.GetIPProperties(); //  .GetIPInterfaceProperties();
                Console.WriteLine();
                Console.WriteLine(Adaptador.Description);
                Console.WriteLine(String.Empty.PadLeft(Adaptador.Description.Length, '='));
                Console.WriteLine("  Tipo interfaz ........................... : {0}", Adaptador.NetworkInterfaceType);
                Console.Write("  Dirección física ........................ : ");
                PhysicalAddress Direccion = Adaptador.GetPhysicalAddress();
                byte[] bytes = Direccion.GetAddressBytes();
                for (int i = 0; i < bytes.Length; i++)
                {
                    // Muestra la dirección física en hexadecimal.
                    Console.Write("{0}", bytes[i].ToString("X2"));
                    // Inserte un guión después de cada bocado, a menos que estemos al final de la dirección. 
                    if (i != bytes.Length - 1)
                    {
                        Console.Write("-");
                    }
                }
                Console.WriteLine();
            }
 
            // Guarda el nombre del hostname en la variable Nombre_HostName.
            Nombre_HostName = Propiedades_PC.HostName;
 
            // Guarda el nombre del dominio si lo tiene.
            Nombre_Dominio = Propiedades_PC.DomainName;
 
 
            // Guarda la MAC recibida con sus - en la varible MAC.
            MAC = Encoding.UTF8.GetString(bytes);
 
            Console.WriteLine();
            Console.WriteLine(@"Nombre del HostName: {0}", Nombre_HostName);
            Console.WriteLine(@"Nombre del domninio: {0}", Nombre_Dominio);
            Console.WriteLine(@"MAC es: {0}", MAC);
            Console.ReadKey(); // Pulsa cualquier tecla y sale.
        }
    }
}
 

Buscando el cambio de tipo de Byte[] a string no me ha funcionado. En esta web ayuda como se hace.
http://www.convertdatatypes.com/Convert-Byte-Array-to-string-in-CSharp.html

¿Alguna idea?

Saludos.

Hola:

He hecho ejecutables a clientes en el cual al final no paga y se van, eso si, por Internet.

Mi idea, se que hay muchas y mejores de las que voy a contar, el mio es simple, no de hacer pero si de explicar.

Si hoy es día 15-01-2016 hora 15:30. Le entrego un ejecutable hecho con Visual C#, el que sea, simple como el propio Form1 con un botón que al pulsar dice Hola mundo. Si el día 29-01-2016 a la misma hora o la que sea, desde que ejecutes la aplicación haga lo siguiente.

Que borre el propio ejecutable.

Antes de eso, hace otra cosa, por ejemplo, el ejectubale se lo envio en .zip o .rar. ¿Qué hacer?
Que se ponga a buscar primero en el área local para que borre dichos archivos llamado nombre.zip o nombre.rar. Si no lo encuentra, acto seguido borra el nombre.exe.

Parece complicado a la hora de programar. Me conformo que se borre el propio ejecutable.

Se puede sugerir mejores métodos, eso si, tampoco quiero complicarme la vida. 

¿Alguna sugerencia, ejemplos?

Saludos.

Estoy indignado de una cosa con este proyecto de pruebas, se me bajaron las palancas de la casa y no me fucniona el relé K2, pesnaba que era el transistor, pero no, porque me enciende el Led rojo pero no activa el relé, rompí el diodo D2 para sustituirlo, no es el diodo, probé el relé directamente y funciona, solo el relé, claro. Así que tiene que ser el optoacoplador.

Por mucho que encienda el Led D2, opté por el relé K3 del INT 3, al rato de apagarse y encender la bombilla, se vuelve a bajar las palancas de mi casa, el magnetotérmico, no el digerencial, sin chispas o estampido de algo.



El optoacoplador le pasó lo mismo del INT 3 que al INT 2, se acabó máspruebas. Dentro de un rato pongo mis experiencias en mi blog sobre este proyecto. Deja ver si venden estos optoacopladores a parte en mi local habitual. En este mismo momento me quedan unos minutos para subir un vídeo qu esubiré aquí para que vean la idea del proyecto.

Dejo claro que aún no he puesto el motor, primero uan bombilla de 100 W a 230 VAC 50 Hz en España. A lo mejor de apagar y encender la bolbilla cada dos segundos, se bajaron las palancas, aunque no entiendo, porqué se fastidian los optoacopladores.

Estoy un poco desmotivado por tonterías como estas.

Se está trabajando con Arduino UNO r3.

Se hará poco a poco un buen código de lo que pretendo hacer, como ven, no se recomienda usar delay, como este es un ejemplo, es para hacer pruebas rápidas.

Esquema:


Código de Arduino:


Imágen:


Vídeo:


A la próxima probaré una bombilla de bajo consumo haber si esta vez no se me bajan las palancas. A parte de eso, detallar un poco más con una tabla, paso por paso lo que tiene que hacer Arduino con los relés.

Sigue las actualizaciones en el proyecto principal de crear una placa de lavadora.

Feliz año nuevo.

Hola:

Quiero saber cual es la forma de guardar datos fijos de un byte y otros de varios bytes. Estos datos son enviados al puerto serie. No se envían todos al mismo tiempo, sino cuando de la orden cuando quiera.

Por ejemplo, tengo datos guardados en enumeraciones como puedes ver abajo.

       

enum DexCommands { INIT = 0x00, STATUS = 0x01, READ = 0x02, WRITE = 0x04, LIGHT = 0x07, MAGIC_HANDSHAKE = 0x27 };

También se puede almacenar de esta forma en varibales const.

        const byte INIT = 0x00;
        const byte STATUS = 0x01;
        const byte READ = 0x02;
        const byte SEEK = 0x03;
        const byte WRITE = 0x04;
        const byte PAGE = 0x05;
        const byte LIGHT = 0x07;
        const byte MAGIC_HANDSHAKE = 0x27;

Otro ejemplo para tratar de byte para enviar por el puerto serie.

        byte[] INIT = { 0x00 };
        byte[] STATUS = { 0x01 };
        byte[] READ = { 0x02 };
        byte[] SEEK = { 0x03 };
        byte[] WRITE = { 0x04 };
        byte[] PAGE = { 0x05 };
        byte[] LIGHT = { 0x07 };
        byte[] MAGIC_HANDSHAKE = { 0x27 };

1. Quiero saber cuál forma es mejor y por qué.

Si quiero enviar el byte STATUS que es 0x01 puedo hacerlo así, si no estoy equivocado. Eso si, llamándole directamente 0x01.

byte[] mBuffer = new byte[1];
    mBuffer[0] = 0x01;
    serialPort1.Write(mBuffer, 0, mBuffer.Length);

Ya que lo tengo guardado en enum, lo llamaré así:

            serialPort1.Open(); // Abrir puerto.
            serialPort1.Write((byte)Dex_Comandos.STATUS);
            serialPort1.Close(); // Cerrar puerto.

2. Este código no funciona. ¿Cómo es la mejor manera para usar datos, variables o enumeraciones en este caso?

Teniendo esta trama de byte de forma fija, por ejemmplo, quiero mandar el comandos STATUS que es de un solo byte por el puerto serie. ¿Cómo lo hago?

3. Tengo esta trama de byte abajo. ¿Cómo puedo enviarla?

       

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

Felices fiestas 2015.

Hola:

En este código muestra los nombres de la configuración. Teniendo el código completo hecho, quiero que muestre un resumen en el componente statusStrip como muestra abajo.



Se tiene que mostrar como indica abajo.


Pongo el código funcional de la configuración del puerto serie, solo falta que muestra la información en el statusStrip que no se hacerlo, siempre con fallos y llevo tres días.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
using System.IO.Ports; // No olvidar.
 
namespace Config_Puerto_Serie
{
    public partial class Form1 : Form
    {
        // Variables.
        bool Conectado;
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            // Añado los puertos disponible en el PC con SerialPort.GetPortNames() al combo
            comboBox_Puerto.DataSource = SerialPort.GetPortNames();
 
            // Añade los bits de datos.
            comboBox_Bits_de_datos.Items.Add("5");
            comboBox_Bits_de_datos.Items.Add("6");
            comboBox_Bits_de_datos.Items.Add("7");
            comboBox_Bits_de_datos.Items.Add("8");
            comboBox_Bits_de_datos.SelectedIndex = 3;
 
            // Añade los bits de parada.
            foreach (string Bit_Parada in Enum.GetNames(typeof(StopBits)))
            {
                comboBox_Bits_de_parada.Text = "Two";
                comboBox_Bits_de_parada.Items.Add(Bit_Parada);
            }
 
            // Añade la Paridad al comboBox.
            foreach (string Paridad in Enum.GetNames(typeof(Parity)))
            {
                comboBox_Paridad.Text = "None";
                comboBox_Paridad.Items.Add(Paridad);
            }
 
            // Añade el control de flujo.
            foreach (string Flujo in Enum.GetNames(typeof(Handshake)))
            {
                comboBox_Control_de_flujo.Text = "None";
                comboBox_Control_de_flujo.Items.Add(Flujo);
            }
 
 
            textBox_Read_time_out.Text = "-1";
            textBox_Write_time_out.Text = "-1";
 
            comboBox_DiscardNull.Items.Add("False");
            comboBox_DiscardNull.Items.Add("True");
            comboBox_DiscardNull.SelectedIndex = 0;
 
            comboBox_DtrEnable.Items.Add("False");
            comboBox_DtrEnable.Items.Add("True");
            comboBox_DtrEnable.SelectedIndex = 0;
 
            comboBox_RtsEnable.Items.Add("False");
            comboBox_RtsEnable.Items.Add("True");
            comboBox_RtsEnable.SelectedIndex = 0;
 
            textBox_ParityReplace.Text = "63";
 
            textBox_ReceivedBytesTrheshold.Text = "1";
 
            textBox_ReadBufferSize.Text = "4096";
            textBox_WriteBufferSize.Text = "2048";
 
            // Añade puertos disponibles físicos  y virtuales.
            serialPort1.BaudRate = (int)Int16.Parse(comboBox_Bit_por_segundo.Text.ToString());
            serialPort1.PortName = comboBox_Puerto.Text.ToString();
            serialPort1.DataBits = (int)Int16.Parse(comboBox_Bits_de_datos.Text.ToString());
            serialPort1.Parity = (Parity)Enum.Parse(typeof(Parity), comboBox_Paridad.Text.ToString());
            serialPort1.StopBits = (StopBits)Enum.Parse(typeof(StopBits), comboBox_Bits_de_parada.Text.ToString());
            serialPort1.Handshake = (Handshake)Enum.Parse(typeof(Handshake), comboBox_Control_de_flujo.Text.ToString());
 
            // Más configuraciones.
            serialPort1.ReadTimeout = (int)Int16.Parse(textBox_Read_time_out.Text.ToString());
            serialPort1.WriteTimeout = (int)Int16.Parse(textBox_Write_time_out.Text.ToString());
            serialPort1.DiscardNull = Convert.ToBoolean(comboBox_DiscardNull.Text.ToString());
            serialPort1.DtrEnable = Convert.ToBoolean(comboBox_DtrEnable.Text.ToString());
            serialPort1.ParityReplace = Convert.ToByte(textBox_ParityReplace.Text.ToString());
            serialPort1.RtsEnable = Convert.ToBoolean(comboBox_RtsEnable.Text.ToString());
            serialPort1.ReadBufferSize = (int)Int16.Parse(textBox_ReadBufferSize.Text.ToString());
            serialPort1.WriteBufferSize = (int)Int16.Parse(textBox_WriteBufferSize.Text.ToString());
        }
 
        private void button_Conectar_Puerto_Click(object sender, EventArgs e)
        {
            if(!serialPort1.IsOpen)
              {
 
                 serialPort1.Open();
                 Conectado = true; // Cariable de clase boleana para controlar si el puero lo abro yo o no.
                 button_Conectar_Puerto.Text = "DESCONECTAR";
                 button_Conectar_Puerto.BackColor = Color.Green;
              }
 
            else
              {
                if (Conectado)
                  {
                    serialPort1.Close();
                    Conectado = false;
                    button_Conectar_Puerto.Text = "CONECTAR";
                    button_Conectar_Puerto.BackColor = Color.Red;
                  }
                else
                  {
                    // Esta ocupado por otro programa muestra mensaje y no hacer nada
                      label_Mensajes_de_error.Text = "Puerto ocupado o no lo encuentra.";
                  }
               }
        }
 
        // Detecta USB o puerto serie virtual cuando lo conecta y desconecta del cable.
        protected override void WndProc(ref Message USB)
        {
            if (USB.Msg == 0x219)
            {
                comboBox_Puerto.DataSource = SerialPort.GetPortNames();
            }
 
            base.WndProc(ref USB); // Detecta si hay cambios en el usb y si los hay los refleja.
        }
    }
}
 

Felices navidades.