Temas

[Imagen corregida respecto a las reglas del foro]

Imagen corregida respecto a las reglas del foro
Hola:

Como curiosidad, quiero saber si con C# se puede programar un pequeño programón que recoja información de un PC, quiero hacer una prueba con otro PC que tengo.

Por ejemplo, saber la MAC de la tarjeta de red de una placa de un PC, como es único, me parece una información importante. Luego se guarda la información en un archivo txt bien legible, ya se hará técnicas de cifrado.

Si quieres información de alguien, ese alguien ejecuta tu aplicación y recopila información.

Para que tengan una idea, a parte de recoger la MAC, quiero saber que unidades de disco duro tiene instalado en su PC, como se llama su etiqueta, capacidad de disco duro, y el árbol de todos los archivos que tiene, en el txt se guarda nombre de las carpetas, subcarpetas y archivos con extensión completas. También que marca y cantidad de RAM que tiene instalada.

Tengo la idea de hacer una apliación que se guarda en inicio o servivio, que analiza todo del PC. Ya en la casa  cuando le visite, recuperaré ese archivo en un Pendrive cifrado por si acaso.

Si veo que se baja películas X y fotos peor que X.   , el programa dentro de tres meses borra dichas fotos y vídeos. Muchas veces inserta por USB un disco duro extraible, quiero hacer un programa que tamién te analice algo y que al conectar una unidad, borre todo, nada más al detectarlo al tercer mes de usar el programa.

Si quieren información de un PC con sus contenidos. ¿Qué buscaría ustedes?

Saludos.

PD: Lo del lenguaje puede ser el más que te guste.

Hola:

Quiero saber que al entrar datos por el puerto serie me cuente los byte recibidos y los alacene en un array tipo byte[]

¿Alguna idea?

El programa sin acabar que tengo hecho por ahora es este.

Código (csharp) [Seleccionar] Expandir

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

namespace Recibir_archivo_desde_Arduino_consola
{
    class Program
    {
        public static string Recibidos = "";
        //public static byte[] datosArray = Encoding.ASCII.GetBytes(Recibidos);
        public static byte[] datosArray = Encoding.ASCII.GetBytes(Recibidos);

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

            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
           
            Console.Read();
            Puerto_serie.Close(); // Cerrar puerto.
        }

        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)

        {
            SerialPort sp = (SerialPort)sender;
            int ByteLeidos = sp.Read(datosArray, 0, 28256);

            Console.Write(ByteLeidos);
        }
    }
}

El código no está bien.

Hola

Casi en el siglo pasado me lelgó una demo oficial con el programa YaBasic, en el cual se puede programar e incluye ejemplos como la serpiente para jugar y tus programas lo guardas en la Memory Card.

También está en version PC, lo que me sorprende, aún se actualiza, impresionante. En mi caso prefiero primero hacer pruenas en el PC porque trabajo más rápido y luego lo paso a PS2 copiándo de nuevo con el teclado que se puede, solo por mera curiosidad.

Quiero saber si se puede controlar algo de la PS2, un hardware, como un puerto USB o algo, crear un archivo de texto y pasarlo a un pendrive.

Web oficial de YaBasic.
http://www.yabasic.de/download.html

¿Alguna sugerencia?

Feliz fin de año 2016.

Hola:

Tengo un array tipo byte[] en C# que es este:

Código (csharp) [Seleccionar] Expandir

byte[] rawData = {
    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
};

¿Cómo es en Arduino?

Quiero la misma información que el de C#.

¿Cómo se envía por el puerto serie al pulsar un botón esos datos?

Saludos.

Hola:

Tengo hecho un mini programa en consola C#.

Código (csharp) [Seleccionar] Expandir

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

namespace Byte_Hex_ocultos_2
{
   class Program
   {

       byte[] rawData = {
   0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
   0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
};

static void Main(string[] args)
       {
           Console.Title = "Imagen oculto.";
           new Program();
       }

       public Program()
       {
           Console.WriteLine("Escribiendo archivo desde el arreglo de bytes");
           File.WriteAllBytes("fotón.jpg", rawData);
           Console.WriteLine("¡Hecho! ¿Deseas ver la foto? Sí / No");
           string input = Console.ReadLine();

           if ((input == "Yes".ToLower()) || (input == "Y".ToLower()) ||
               (input == "Sí".ToLower()) || (input == "S".ToLower()))
           {
               Console.WriteLine("Mostrando imagen...");
               Process.Start("fotón.jpg");
               Console.WriteLine("Imagen cargada.");
           }

           else
           {
               Console.WriteLine("Saliendo...");
           }
       }
   }
}

Justo abajo hay un array tipo byte[] indicaco justo abajo.

Código (csharp) [Seleccionar] Expandir

byte[] rawData = {
   0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
   0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
};

Estos son pocos byte para probar, en realidad pueden ser millones.
Quiero hacer de alguna manera, modificar a mi antojo cada byte[] del array, por ejemplo, hacerlo de forma básica para probar como curiosidad, lograr desplazar cada bit una vez a la derecha. Esto lo hará otro programa en C#. En el indicado arriba tiene que usar la misma fórmula pero al revés, los byte del array ahora tienen que moverlo a la izquierda una vez para que tengan su posición normal.

Así de paso no es tan fácil detectar lo que hay en el archivo de C#.

¿Alguna idea?

Les dejo el enlace de descarga del proyecto completo, solo tienes que ejecutarlo con Visual Community 2015 y pueden ver que foro tengo escondido, pueden mostrarlo por aquí si les pica la atención.

Descargar

Felices fiestas 2016.

[Excepción no controlada del tipo 'System.Exception' en Ejecutable_dentro_de_recursos_consola_01.exeInformación adicional: No se puede encontrar el recurso 'Recursos.Validar.exe']

Hola:

Tengo un ejecutable llamado Validar.exe en un recurso.

Más información poner o quitar reursos.

He creado una palicación en consola con C#.

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

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;

namespace Ejecutable_dentro_de_recursos_consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Ejecuta Validar.exe dentro de C#.";
            Console.WriteLine("Funcionando C#...");
            CopiarRecurso(Assembly.GetExecutingAssembly(), "Recursos.Validar.exe", "Validar.exe");
            ProcessStartInfo info = new ProcessStartInfo("Validar.exe");
            Process.Start(info);

        }

        public static void CopiarRecurso(Assembly pAssembly, string pNombreRecurso, string pRuta)
        {
            using (Stream s = pAssembly.GetManifestResourceStream(pAssembly.GetName().Name + "." + pNombreRecurso))
            {
                if (s == null)
                {
                    throw new Exception("No se puede encontrar el recurso '" + pNombreRecurso + "'");
                }

                byte[] buffer = new byte[s.Length];
                s.Read(buffer, 0, buffer.Length);
                using (BinaryWriter sw = new BinaryWriter(File.Open(pRuta, FileMode.Create)))
                {
                    sw.Write(buffer);
                }
            }
        }
    }
}

Error:
Excepción no controlada del tipo 'System.Exception' en Ejecutable_dentro_de_recursos_consola_01.exe

Información adicional: No se puede encontrar el recurso 'Recursos.Validar.exe'

¿Algo se me escapa?

Ni poniendo la ruta completa, me hace caso. Da el mismo error.

Felices fiestas 2016.

[Program.cs]

Hola:

Quiero leer un texto que puse como string desde la Class2 y no me sale.

Dejo el código.

Program.cs

Código (csharp) [Seleccionar] Expandir

using System;

namespace Textos_Clases_02
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Métodos y funciones C#";

            Console.WriteLine("Que muestre los textos desde la clase externa llamada Class1.cs");

            Class1 txt = new Class1();  // Crear un objeto.
            txt.MostrarTextoClass1();   // Mostrar textos de la Class1.

            Class2 txt2 = new Class2(); // Crear un objeto.
            Console.WriteLine(txt2.metodo()); // Mostrar textos de la Class2.

            Console.ReadKey(); // Pulsa cualquier tecla para salir.
        }
    }
}


Class1.cs

Código (csharp) [Seleccionar] Expandir

using System;

namespace Textos_Clases_02
{
    class Class1
    {
        public void MostrarTextoClass1()
        {
            Console.WriteLine("Hola desde Class1 con el método MostrarTextoClass1");
        }
    }
}

Class2.cs

Código (csharp) [Seleccionar] Expandir

namespace Textos_Clases_02
{
    class Class2
    {
        public string metodo(string variable)
        {
            variable = "Texto variable de la clase Class2 y método o función metodo.";
            return variable;
        }
    }
}

¿Cuál es la mejor forma de hacerlo?

En resumen: Quiero añadir textos en clases externas, así cualquier método lleno de textos no los tengo en el programa principal y me ahorro leer muchos códigos que se que funcionan.En el programa principal solo los llamo.

Saludos.

Hola todos y a todas:

Estoy en primera fase haciendo una interfaz con Visual C# (ya se hará lo mismo para Visual Basic .net) reconocimento por voz usando cascos con micro.

Este ejemplo que puedes descargar solo hace lo siguiente, decir palabras, como: Azul, izquierda, siete, salir, palabras de ese tipo que con el micro intenta reconocer una palabra.

Quiero que prueben este programa en fase alfa todavía, si les funcione me cuentan sus experiencias o primera impresión y si les interesa.



Mi idea principal es: Controlar Arduino con su LCD, si dices amarillo, el cuadro se pone en amarillo del programa y aparece esa palabra en el LCD de Arduino. Cada palabra que digas en el programa, lo refrejará Arduino con el LCD. A parte de esto, se ampliarán funciones como encender un LEd y apagarlo con la voz.

Es un proyecto tonto de experimentación y lo hago como curiosidad, usando el puerto serie del PC.

Descargar programa.

Felices fiestas 2016.

Hola:

1) Tenemos el diseño hecho de una interfaz en C#.


2) Introducimos los datos configurados del puerto serie indicado abajo.


3) Con esta documentación, hacemos los pasos necesarios para hacer las funciones o métedos.

https://github.com/fbriere/linux-dexdrive/blob/master/protocol.txt
https://web.archive.org/web/20100123200342/http://www.darklock.com/thps/dexdrive.html

4) Cuando ya tengamos las funciones del protocolo hecho, nos metemos en hacer los botones.

Backup: Leer la Memory Card.
Restore: Guardar los datos de la Memory Card en el PC.
Format: Formatear la Memory Card.
Refresh: Refrescarlos datos de la Memory Card.
Duplicate: Duplicar la Memory Card, es decir, hacer una copia de la tarjeta completo y guardar los datos en el PC.

5) Emepzamos aprobar el botón Backup, que es leer la tarjeta o Memory Card.

6) Dejo el proyecto vacío para empezar desde cero. Solo tiene el diseño hecho. Así ahorras tiempo.

Descargar

7) Animarse a hacer esta interfaz.

Hola:

Estoy intentado seguir este protocolo de comunicación indicado en esta Web.
https://web.archive.org/web/20100123200342/http://www.darklock.com/thps/dexdrive.html

Quiero hacer un programa en Visual C#. Solo lee datos del puerto serie y lo pasa en un archivo al PC. También pasarel archivo que está en el PCy lo pasa al puerto serie con el programa hecho en C#.

Lo veo muy complicado, tengo el DexDrive físico y con ayuda de ustedes puedo hacer pruebas.

¿Algún atrevido en la aventura con C#?

Saludos.

Hola:

Para los que entiendan bien el C++ bajoj Linux, quiero hacer esta aplicación en Windows bajo C#. Me parecemuy complicado y eso que he estado mirando archivo por archivos, no tengo conocimientos muy bien del C++ y pesco a lo lindo.

Al menos quiero saber que archivos hay que adaptarlo, haber si cojo el truco. Funciona en modo consola.
Hay partes del programa que si puedo,como los if else, switch y demás, lo sencillo, en cuanto a otros aspecto no lo veo en C# ni loco.

El programa que quiero traducir es este.

Ver enlace.

Un cordial saludos.

Hola:

Quiero cambiar este programa encontrado en este enlace.
https://github.com/fbriere/linux-dexdrive

Aquí abajo te lo explica, aún así no tengo ni idea. Por lo que se ve, este programa funciona solo en modo consola.
https://github.com/fbriere/linux-dexdrive/blob/master/README

¿Alguna ayudita?

Yo de Linux muy poco, por algo se empieza.

Saludos.

PD: ¿Ya no hay intensión de sacar más versiones de openSUSE en el futuro?
Todavía siguen con lamisma versión 42.1

Hola:

Si hay noticias de una nueva entrega aunque sea en inglés, o forma de rumor, lo publican aquí.
Est ejuego me encanta, ya saben lo que tienen que mejorar.
Como habrá dos películas más sobre Mad Max, un spin-off donde solo sale Furiosa y la última peli donde solo sale Max, puede aprovechar el tirón que se merece este juego que no todo el mundo conoce, sino va conociendo. Se que el inicio no tuvo la sventas deseasa y eso me preocupaporque WB a pesar de tener dinero, no gasta por gastar.

¿Alguna sugerencia?

Saludos.

Tengo la PS3, me compraré la PS4 NEO cuando salga y ya se verá al final si será así por valorar cuanto vale la pena a pesar que no tengo la PS4 actual.

Desde la PS3, veo que tengo trofeos conseguidos de los juegos de la PS4 en casa de un amigo.

Puede acceder cuando quiera a mi cuenta sin pedir contraseña, es más, no te pide el famoso checkBox para dejar la contraseña guardada o no.

¿El amigo si se cabrea puede putearme de forma fácil?

¿Qué me puede hacer si tengo la cuenta ahí?

Por ahora me llevo bien con él y cuando voy a la casa lo que hago es actualizar trofeos de PS4. Lo que no se si me podrá putear algo con mi cuenta. Lo que se me ocurre es cambiarla desde mi casa con la PS3 por si persivo algún problema. Se la contraseña y él no.

¿Alguna información que debo saber?

Saludos.

Hola:

Si tengo un string que tiene una contraseña guardada en el formulario WindowsForm de Visual C#. ¿Se puede averigual?
Bueno, cualquier variable tipo string.

Por ejemplo, el programa te pide login y contraseña, los dos están escritos en la propia aplicación (cosa que no debería pero estamos en pruebas), alguien que sea capaz de explicar como se hace.

Cuando lo averigüen, ya puedas entrar con su login y password. Y que diga un mensaje. Hola mundo.

¿Alguien se atreve?

Saludos.

Hola:

Haciendo una aplicación Java con Spring, Hibernate, MAven y demás bajo Eclipse, me dan estos errores indicado aquí.



Buscando el spring-context me llevó hasta aquí.

https://mvnrepository.com/artifact/org.springframework/spring-context

Selecciono el 4.3.1 Release.
https://mvnrepository.com/artifact/org.springframework/spring-context/4.3.1.RELEASE

Me aparece esto.

Código [Seleccionar] Expandir

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.1.RELEASE</version>
</dependency>

No tengo ni idea sobre esto.

¿Alguna ayuda?

Y suponiendo que esto tenga algo que ver.

Saludos.

Hola:

Con este pequeño trozo de código:

Código (java) [Seleccionar] Expandir



@Component
@Scope("view")
public class Clase {

No me encuentra estas dos librerías llamadas.

Código (csharp) [Seleccionar] Expandir

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

¿Qué es lo que tengo que tener instalado realmente para que se pongan bien los import y no me de como fallo?



Saludos.

[Led_8_ON]

Hola:

Uso STS-Eclipse, spring de Java y el servidor el JBoss. El proyecto que quiero hacer es enviar y recibir datos string por el puerto serie. Hace tiempo hice un tutorial en pdf sobre Java con NetBeans haciendo una interfaz de escritorio y se puede encender, apagar y recibir datos de los Led.

Ver tutorial.

Primer paso, empezar enviar datos por el puerto serie, cuando funcione, ya empezaremos lo de recibir datos.

En este caso, usaré la tecnología indicada arriba, una interfaz hecha con xhtml y usar clases en Java. Por ejemplo. Tengo hecho una interfaz en xhtml sencilla como indica abajo.



Como puedes ver arriba, debe encender un Led del pin 8, tiene dos botones, en este ejemplo he puesto que si pulsas el botón ON, en el texto de abajo aparece Led_8_ON, si pulsas el botón OFF, aparecerá el texto Led_8_OFF.

Dicho texto Led_8_ON y Led_8_OFF, son string que debo enviar por el puerto serie.

test.xhtml

Código (xml) [Seleccionar] Expandir

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui">
<h:head>
<title>Test</title>
<h1>Haciendo pruebas</h1>
</h:head>
<h:body>
<h:form>
<p:panel header="Cuadro de control">
<p:panelGrid columns="1" id="gridname">
<p:outputLabel  value="Led 8: " />
<p:commandButton id="led8on" value="ON" actionListener="#{test.led8ON}" update="resultado" />
<p:commandButton id="led8off" value="OFF" actionListener="#{test.led8OFF}" update="resultado" />
<p:inputText required="false" id="resultado" value="#{test.guardarUltimoValor}" />
</p:panelGrid>
</p:panel>
</h:form>
</h:body>
</html>


He creado una clase Java llamada Test.java.

Código (java) [Seleccionar] Expandir

package net.meta.practica.business.test;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("view")
public class Test {

// Variables.
final String LED8ON = "Led_8_ON";
final String LED8OFF = "Led_8_OFF";
String guardarUltimoValor = "";

// Métodos.
public void led8ON(){
guardarUltimoValor = LED8ON;
}

public void led8OFF(){
guardarUltimoValor = LED8OFF;
}

// Getters y Setters.
public String getGuardarUltimoValor() {
return guardarUltimoValor;
}

public void setGuardarUltimoValor(String guardarUltimoValor) {
this.guardarUltimoValor = guardarUltimoValor;
}

public String getLED8ON() {
return LED8ON;
}

public String getLED8OFF() {
return LED8OFF;
}
}


Para que entiendan de que va. xhtml hace de interfaz, la clase Test.java ahí está la estructura del programa para este ejemplo sencillo.


Ver zoom.

Hace tiempo que no toco Java, con STS-Eclipse ando perdido, es nuevo para mi.

Siguiendo este ejemplo. ¿Qué hay que hacer?
- Intentar configurar el puerto serie, en este caso puede ser COM4 o el que sea a 115200 de baudios, 2 bit de stop.
- Enviar estos dos string llamada Led_8_ON que lanza el botón ON y el Led_8_OFF que lanza el botón OFF al puerto serie.

Pueden aportar ideas de como hacerlo lo mejor posible y sin complicaciones.

1) Para la clase Test.java, ¿cómo o cuál es la mejor manera de enviar el dato de la variable llamado en este caso LED8ON?

2) ¿Hago todo el código en la misma clase?

Un cordial saludos.

PD: Menudo tostón de post. Espero que se entienda algo hasta donde quiero llegar, nos acompañharemos a llegar...

Hola:

Antes cuando mostraba los datos la pantalla de modo consola en C# parpadeada porque ponía el Console.Clear();

Ahora uso las coordenadas donde supuestamente deben de parpadear cuando cambia el valor.

Lo que le ocurre y quiero solucionar. Recibo datos de 0 a 1023, en el cual muestra la barra de progreso, cuando aumento de valor, la barra de progreso escrito en modo consola, aunmenta.

Si bajo el valor, la barra de progreso no baja, se queda donde alcanzó su valor máximo.

Quiero saber la forma de solucionarlo. Aquí abajo dejo el código.

Código (csharp) [Seleccionar] Expandir

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

namespace Porcentaje_Barra_P_Serie_Consola_3_CS
{
    class Program
    {
        public static string Recibidos = "";
        public static double Resultado_Porcentaje = 0;
        public static double Resultado_Voltios = 0;
        public static double Mitad_barra = 0;


        static void Main(string[] args)
        {
            string COM = "";

            // Tamaño ventana consola.
            Console.WindowWidth = 55; // X.
            Console.WindowHeight = 15; // Y.
            Console.Title = "Serial Port C# - v.02"; // Título de la ventana.

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

            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Console.Read();
            Puerto_serie.Close(); // Cerrar puerto.
        }

        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)

        {

            try
            {
                SerialPort sp = (SerialPort)sender;
                Recibidos = sp.ReadExisting();
                //Console.Clear();

                Recibidos = Recibidos.Replace("\n\r", "");

                int Variar_este_valor = Convert.ToInt32(Recibidos);

                Resultado_Porcentaje = Variar_este_valor * (100.00 / 1023.00);
                Resultado_Voltios = Variar_este_valor * (5.00 / 1023.00);

               
                Console.SetCursorPosition(0, 1);
                Console.Write("Datos recibidos: ");
                Console.SetCursorPosition(17, 1);
                Console.Write("    ");
                Console.SetCursorPosition(17, 1);
                Console.Write(Recibidos);

               
                Console.SetCursorPosition(0, 3);
                Console.Write("0 %                     50 %                   100 %");
                Console.SetCursorPosition(0, 4);
                Console.Write("┌────────────────────────┬───────────────────────┐");
                Console.Write("                                                  ");
                Console.ForegroundColor = ConsoleColor.Yellow;

                // Se dibide por dos la barra del porcentaje para que quepa decuadamente en la pantalla.
                Mitad_barra = Resultado_Porcentaje / 2;

                if (Mitad_barra > 50)
                {
                    Mitad_barra = 50;
                }

                Console.SetCursorPosition(0, 5);
                // Barra de progreso.
                for (int i = 1; i <= Mitad_barra; i++)
                {
                    Console.Write("█"); // Muestra ASCII 219 Dec y DB en Hex.
                }
                //Console.SetCursorPosition(0, 5);
                //Console.Write("                                                  ");
                Console.SetCursorPosition(0, 5);
                Console.Write("--------------------------------------------------");

                // Si sobre pasa 100, muestra # al final de la barra del porcentaje de color rojo.
                if (Resultado_Porcentaje >= 100)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Write("#");
                }

                Console.ForegroundColor = ConsoleColor.Gray; // Vuelve al color gris.

                // Línea 7.
                Console.SetCursorPosition(0, 7);
                Console.Write("Porcentaje: ");
                Console.SetCursorPosition(12, 7);
                Console.Write("            ");
                Console.SetCursorPosition(12, 7);
                Console.Write(Resultado_Porcentaje.ToString("N0") + " %.");

                // Línea 8.
                Console.SetCursorPosition(0, 8);
                Console.Write("Voltios: ");
                Console.SetCursorPosition(12, 8);
                Console.Write("            ");
                Console.SetCursorPosition(12, 8);
                Console.Write(Resultado_Voltios.ToString("N2") + " V.");

            }

            catch (FormatException)
            {
                // Console.WriteLine("La cadena de entrada no tiene el formato correcto.");
                return;
            }
        }
    }
}



Saludos.

Hola:

DE Call of Duty de la X-Box 360 o PlayStation 3.

Los de PS3 dicen que son los de 360 más hackeados, los de la 360 dicen que son los de PS3.

¿En qué quedamos?

Saludos.

Hola:

Tengo un programa que recibe datos una y otra vez por el puerto serie. A 0.1 segundos datos del 0 al 1023. Si no hay datos que esté leyendo porque en el otro lado no lo está enviando, puedo cerrar el programa sin problemas. Si hay datos que le llega y lee, al cerrar el programa aunque pongas SerialPort1.Close(); El programa se cuelga.

En el Load de Windwos Form he puesto esto.

Código (csharp) [Seleccionar] Expandir

Control.CheckForIllegalCrossThreadCalls = false;
https://msdn.microsoft.com/es-es/library/system.windows.forms.control.checkforillegalcrossthreadcalls%28v=vs.100%29.aspx

Se sigue colgando. No ha funcionado.

Por lo que he leído hay que usar hilos y es más complejo, no lo se.

¿Alguna solución?

Saludos.

[Código Arduino:]

Hola:

Quiero recibir datos por el puerto serie. He hecho varios ejemplos. Lo más sencillo es este código de abajo, solo tiene que mostrar número en la posición que yo quiera X, Y del 0 al 1023 que recibe todo el rato. El código le llega desde Arduino y su código es.

Código Arduino:

Código (c) [Seleccionar] Expandir

int valorPot=0;

void setup(){ Serial.begin(115200); }

void loop(){
     valorPot=analogRead(2);
     Serial.println(valorPot);
     delay(100); // 0.1 segundos.
}

Código C#:

Código (csharp) [Seleccionar] Expandir

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

namespace Porcentaje_Barra_P_Serie_Consola_2_CS
{
    class Program
    {
        public static string Recibidos = "";

        // Como variables de clase
        public static string[] Separador = new string[] { ",", "\r", "\n", "/n" };
        public static List<string> Leo_Dato = new List<string>();

        static void Main(string[] args)
        {
            Console.Title = "Serial Port C#";

            int Variar_este_valor = 0; // De 0 a 1023.

            SerialPort Puerto_serie;

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

            // Configuración.
            Puerto_serie.PortName = "COM4"; // 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;
               
            Puerto_serie.Open(); // Abre el puerto serie.

            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
        }

        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {

            // En el evento.
            Leo_Dato.Clear();
            Leo_Dato.AddRange(Recibidos.Split(Separador, StringSplitOptions.RemoveEmptyEntries));

            SerialPort sp = (SerialPort)sender;
            Recibidos = sp.ReadLine();
            Console.SetCursorPosition(5, 10); // Posición X, Y.
            Console.Write(Recibidos);
        }
    }
}


Cuando varío el potenciómetro de Arduino, en el puerto serie del PC, en pantalla de C# o modo consola, tiene que aparecer valores que lee el programa, la pantalla se apaga rápido.

¿Alguna idea?

Saludos.

[Las otras ventanas de depuración:]

Hola:

En documento dice.

Las otras ventanas de depuración:
Hay muchas otras ventanas disponibles para la depuración, pero algunas no son realmente útiles
para el desarrollo de aplicaciones con Visual C#. Se reservan más para la prueba de aplicaciones
desarrolladas con otros lenguajes, C++ por ejemplo.
Por ejemplo, es el caso de la ventana de memoria que permite la visualización del contenido de una
zona de memoria de la cual conocemos la dirección.



Sobre todo en la MEmoria, que para ver esto uso programa de editor hexadecimales externos como este.

He estado buscan doe en Visual Stduuio .net Community 2015 y nada. Al menos quiero saber si lo incluye en esta versión.

Saludos.

Hola:

Hice un pequeño programa, más bien adaptado del AWP a WPF bajo Visual C# 2015. En AWP me funciona en tiempo real a la hora de recibir datos diferentes, en WPF se queda congelado en el momento de recibir el primer dato. Si cambio los datos, cierro el programa y lo vuelvo abrir, se muestra los nuevos valores y se queda congelado.



El código fuente de C# WPF.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

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

namespace Arduino_In_Analogico_Prueba_01_WPF
{
    /// <summary>
    /// Lógica de interacción para MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        // Utilizaremos un string como buffer de recepción.
        string Recibidos;
        SerialPort serialPort1 = new SerialPort();

        public MainWindow()
        {
            InitializeComponent();

            // Configuramos el puerto serie.
            serialPort1.BaudRate = 115200; // Baudios, tiene que ser el mismo que Arduino.
            serialPort1.PortName = "COM4"; // Elegijos el mismo puerto que de Arduino.
            serialPort1.Parity = Parity.None; // Nada de paridad.
            serialPort1.DataBits = 8; // 8 bits.
            serialPort1.StopBits = StopBits.Two; // Recomendado con 2 bits de Stop o parada.

            // Abrir y mantener abierto el puerto serie mientras se ejecute la aplicación.
            if (!serialPort1.IsOpen)
            {
                try
                {
                    serialPort1.Open();
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }

            // Ejecutar la función Recepción por disparo del evento ¡DataReived!
            serialPort1.DataReceived += Recepcion;
        }

        private void Recepcion(object sender, SerialDataReceivedEventArgs e)
        {
            // Acumular los caracteres recibidos a nuestro "buffer" (string).
            Recibidos += serialPort1.ReadExisting();

            // Invocar o llamar al proceso de tramas.
            this.Dispatcher.Invoke(Actualizar);
        }


        // Como variables de clase
        private string[] Separador = new string[] { ",", "\r", "\n", "/n" };
        private List<string> Leo_Dato1 = new List<string>();

        // Procesar los datos recibidos en el bufer y extraer tramas completas.
        private void Actualizar()
        {
            double Voltaje = 0;
            double Porcentaje = 0;

            // En el evento
            Leo_Dato1.Clear();
            Leo_Dato1.AddRange(Recibidos.Split(Separador, StringSplitOptions.RemoveEmptyEntries));

            label_Lectura_Potenciometro.Content = Leo_Dato1[0].ToString();
            progressBar.Value = Convert.ToInt32(Leo_Dato1[0].ToString());

            double Dato_Voltaje = Convert.ToDouble(Leo_Dato1[0]);
            double Dato_Porcentaje = Convert.ToDouble(Leo_Dato1[0]);

            Voltaje = Dato_Voltaje * (5.00 / 1023.00);
            Porcentaje = Dato_Porcentaje * (100.00 / 1023.00);

            label_Voltaje.Content = Voltaje.ToString("N2") + " V.";
            label_Portentaje.Content = Porcentaje.ToString("N0") + " %";
        }
    }
}


¿Hay alguna solución?

Saludos.

Hola:

Estoy haciendo una pequeña prueba. Recibo en el puerto serie / USB datos que recoge Visual C# de 0 a 1023 y lo muestro en un label.



Hasta ahí funciona bien.

Tengo dos label más. El segundo tiene que demostrar el porcentaje del 0 % a 100% según el dato obtenido del 0 a 1023.

En el otro label, el tercero debemostrar número con decimales del 0.00 a 5.00.

A pesar de encontrar la fórmula, no se implementarlo en C#.

El código es este:

Código (csharp) [Seleccionar] Expandir

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

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

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

       public Form1()
       {
           InitializeComponent();

           if (!serialPort1.IsOpen)
           {
               try
               {
                   serialPort1.Open();
               }
               catch (System.Exception ex)
               {
                   MessageBox.Show(ex.ToString());
               }
           }

           serialPort1.DataReceived += new SerialDataReceivedEventHandler(serialPort1_DataReceived);
       }

       // Al recibir datos.
       private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
       {

           // Acumula los caracteres recibidos a nuestro 'buffer' (string).
           Recibidos = serialPort1.ReadLine();

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


       // Como variables de clase

       private string[] separador = new string[] { ",", "\r", "\n", "/n" };
       private List<string> leodato1 = new List<string>();

       
       
       // Procesar los datos recibidos en el bufer y extraer tramas completas.
       private void Actualizar(object sender, EventArgs e)
       {
           // En el evento
           leodato1.Clear();
           leodato1.AddRange(Recibidos.Split(separador,StringSplitOptions.RemoveEmptyEntries));

           label_Lectura_Potenciometro.Text = leodato1[0].ToString();
           progressBar1.Value = Convert.ToInt32(leodato1[0].ToString());
           progressBar1.PerformStep();
       }
   }
}

Saludos.

Presento tutorial sobre entrada de datos digitales por puerto serie con Arduino controlado por tu propia interfaz hecho bajo Visual Studio .net

Ver enlace.

Ver vídeos.
Vídeo 1.

Vídeo 2.

Ahora me toca seguir con entradas y salidas analógicas.

Para recordar, ya hubo tutorial sobre controlar un Led.

Más tutoriales que puedes ver aquí.

Saludos.

Hola:

Como en las películas de antes, no recuerdo en qué peli sale, un ordenador que al imprimir mensajes, se oye un ruido por cada letra muy rápido.

Hice lo de imprimir cada letra en 10 milisegundos, 0.010 segundos.

Código [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Threading; // No olvidar.

namespace Texto_consola_CS
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WindowWidth = 80;
            Console.WindowHeight = 43;

            Console.Title = "Título del programa en la ventana de la consola.";

            Console.BackgroundColor = ConsoleColor.Black; // Fondo pantalla blanco.
            Console.Clear(); // Limpiar pantalla.
            Console.ForegroundColor = ConsoleColor.Green; // Color texto azul.

            string Cadena = @"El hombre moderno es un viajero que ha olvidado el lugar de donde va, y que
ha de volver a donde viene para saber a donde va.

No busques al amigo para matar las horas, sino búscale con horas para vivir.

Los amigos se convierten con frecuencia en ladrones de nuestro tiempo.

Es difícil decir quién hace el mayor daño: los enemigos con sus peores intenciones o los amigos con las mejores.

Recorre a menudo la senda que lleva al huerto de tu amigo, no sea que la maleza te impida ver el camino.";

            Console.CursorVisible = true;

            foreach (char Letra in Cadena)
            {
                Console.Write(Letra);
                Thread.Sleep(2); //medio segundo
            }
            Console.Beep();
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
    }
}


Al final de impresión de oye un beep. No encuentro un vídeo de ejemplo por ahora para que vean a lo que me refiero. Cuando el hombre habla con el ordenador en la película y le responde con mesajes que se oye el ruido por cada letra que escriba en pantalla.

Si alguien sabe como se hace, lo explican, no he encontrado nada igual por Internet, lo más parecido es esto.

https://msdn.microsoft.com/es-es/library/4fe3hdb1%28v=vs.110%29.aspx

Pero no es lo mismo.

Cualquier información es de ayuda.

Saludos.

Hola:

En C# para enviar un byte al puerto serie uso esto.

Código [Seleccionar] Expandir

private void button_t_Click(object sender, EventArgs e)
{
   byte[] mBuffer = new byte[1];
   mBuffer[0] = 0x74; //ASCII letter "t".
   serialPort1.Write(mBuffer, 0, mBuffer.Length);
}

En C++/CLR su código es este.


Para enviar de forma de cadena en C# se hace así:

Código [Seleccionar] Expandir

private void button_b_Click(object sender, EventArgs e)
{
   byte[] mBuffer = Encoding.ASCII.GetBytes("Hello World");
   serialPort1.Write(mBuffer, 0, mBuffer.Length);
}

¿Cómo se hace en C++/CLR?

Saludos.

Hola:

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

Código (csharp) [Seleccionar] Expandir

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

using System.IO.Ports; // No olvidar.
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.

Código (cpp) [Seleccionar] Expandir

#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í:

Código (csharp) [Seleccionar] Expandir

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

Código (cpp) [Seleccionar] Expandir

// 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.
[youtube=640,360]https://www.youtube.com/watch?v=Ra2PBfLFuHk[/youtube]

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

Código (c) [Seleccionar] Expandir

/*
* 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:

Código (vbnet,28) [Seleccionar] Expandir

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.
[youtube=640,360]https://www.youtube.com/watch?v=-jwYuZDKydE[/youtube]

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.

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

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


Gravedad   Código   Descripción   Proyecto   Archivo   Línea
Error   CS0103   El nombre 'bytes' no existe en el contexto actual   Leer_MAC   C:\Users\Usuario\Documents\Visual Studio 2015\Projects\Leer_MAC\Leer_MAC\Program.cs   65

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:

Código [Seleccionar] Expandir

// include el código de la librería.
#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);

unsigned long inicio, fin, transcurrido;
long Veces = 0;

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

void setup()
{
   // Formato de pantalla.
  lcd.begin(16, 2);
  lcd.print("Foro ELECTRONICA");

  /*
  delay(2000);
  lcd.setCursor(0,0);
  lcd.print("Cambio de giro  ");
  lcd.setCursor(0,1);
  lcd.print("motor lavadora. ");
  delay(2000);
  lcd.clear(); // Limpia la pantalla.
  lcd.setCursor(0,0); // En el primer carácter y primera fila.
*/

  pinMode(3,OUTPUT);
  pinMode(2,OUTPUT);
  pinMode(LuzFondo,OUTPUT);

  digitalWrite(LuzFondo, HIGH);
  //digitalWrite(2, !LOW); // !LOW es HIGH.
  //digitalWrite(3, !LOW);
  Serial.begin(115200);
}

void loop()
{
  lcd.setCursor(0,1);
  lcd.print(inicio=millis()/15000); // 15 seg. antes de empezar.

     for (int i=0; i <= 10; i++)
   {
 
  digitalWrite(2, !LOW);
  lcd.setCursor(3,1); // RL 1.
  lcd.print("1 OFF");
  digitalWrite(3, !LOW);
  lcd.setCursor(9,1); // RL 2.
  lcd.print("2 OFF");
  delay(2000);

  digitalWrite(2, !HIGH);
  lcd.setCursor(3,1); // RL 1.
  lcd.print("1 ON ");
  delay(2000);

  digitalWrite(2, !LOW);
  lcd.setCursor(3,1); // RL 1.
  lcd.print("1 OFF");
  delay(2000);

  digitalWrite(3, !HIGH);
  lcd.setCursor(9,1); // RL 2.
  lcd.print("2 ON ");
  delay(2000);

  digitalWrite(3, !LOW);
  lcd.setCursor(9,1); // RL 2.
  lcd.print("2 OFF");
  delay(2000);

Veces++;
lcd.setCursor(0,1);
lcd.print(Veces);

  }

  delay(1000000);

     // Cuando llegue aquí, tiene que pararse el motor siempre.
     // No se que instrucciones darle para que lo haga.
}

Imágen:


Vídeo:
[youtube=640,360]https://www.youtube.com/watch?v=5zZ8jc8QUD0[/youtube]

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.

[1.]

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.

       

Código (csharp) [Seleccionar] Expandir

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.

Código (csharp) [Seleccionar] Expandir

        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.

Código (csharp) [Seleccionar] Expandir

        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.

Código (csharp) [Seleccionar] Expandir

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

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

Código (csharp) [Seleccionar] Expandir

            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?

       

Código (csharp) [Seleccionar] Expandir

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.

Código (csharp) [Seleccionar] Expandir

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

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

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

Hola

Hice un ejemplo muy pequeño, que detecta los puertos COM físico y virtuales en el ComboBox, en el cual solo muestra COM1 y COM4 a seas.



Como se puede ver en el Administrador de dispositivos.



¿Cómo puedo hacer que se muestre el nomrbre del dispositivo detectado por el comboBox que muestre el nombre?

El código de lo que he hecho es este.

Código (csharp) [Seleccionar] Expandir

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

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

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

        private void Form1_Load(object sender, EventArgs e)
        {
            // Añado los puertos disponible en el PC con SerialPort.GetPortNames() al combo
            try
            {
                comboBox_Puerto.DataSource = SerialPort.GetPortNames();
            }

            catch
            {
                MessageBox.Show("No encuentra ningún puerto físico ni virtual.", "Aviso:",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }

            // Añado los puertos disponible en el PC con SerialPort.GetPortNames() al combo
            comboBox_Puerto.DataSource = SerialPort.GetPortNames();

            // // Añade puertos disponibles físicos  y virtuales.
            serialPort1.PortName = comboBox_Puerto.Text.ToString();
        }

        // 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.
        }

        private void button_Conectar_Click(object sender, EventArgs e)
        {
            try
            {
                serialPort1.PortName = comboBox_Puerto.Text.ToString(); // Puerto seleccionado previamente.
                serialPort1.Open(); // Abrir puerto.
                comboBox_Puerto.Enabled = false;
                button_Conectar.Enabled = false;
                button_Desconectar.Enabled = true;
            }

            catch
            {
                MessageBox.Show("El puerto no existe.", "Aviso:",
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void button_Desconectar_Click(object sender, EventArgs e)
        {
            serialPort1.Close(); // Cerrar puerto.
            comboBox_Puerto.Enabled = true;
            button_Conectar.Enabled = true;
            button_Desconectar.Enabled = false;
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (serialPort1.IsOpen) // ¿El puerto está abierto?
            {
                serialPort1.Close(); // Cerrar puerto.
            }
        }
    }
}

Felices fiestas 2.015.

Hola:

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



Lo he desarmado.



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

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

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

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

He intentado hacer caso esta parte en Visual C#.

COMMANDS
--------

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

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

0x00  INIT

 Args: <17 bytes>
 Reply: ID

 Initializes the DexDrive; see the POUTING section below.

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

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

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

Enviar esos 17 bytes pero no pasa nada.

Código [Seleccionar] Expandir

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

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

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


Saludos.

Hola:

El componente richTextBox en la aplicación WPF, al introducir datos, se crea el auto scroll, luego se va viendo lo lúltimo recibido abajo. El código es este.

Código (csharp) [Seleccionar] Expandir

           // Asignar el valor de la trama al richTextBox.
           richTextBox1.Text = Recibidos + "\n";

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

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

El problema es usarlo con WPF, no hace ningún tipo de scrollbar.

¿Cuál es su equivalencia para WPF?

Un cordial saludos.

PD: Uso Visual Studio Community 2015.

Hola:

En el formulario tengo un label y dos buttons. En el label muestra 00:00:00, que son horas, minutos, segundos.

El primer botón empieza llamado Start el contador, el otro botón llamado Stop es detener el temporizador y se pone a 00:00:00 y se queda detenido.

¿Cómo se hace en C#?

Por ahora he hecho esto.

Código (csharp) [Seleccionar] Expandir

public class form1{

  private Timer _timer = null;

  public void Form_Load(...){

       _timer= new Timer();

       _timer.Interval = 1000; // 1seg

       _timer.tick += timer_Tick;

  }

  private void btnIniciar_Click(...){

     _timer.Start();

 }

  private void btnIniciar_Click(...){

    _timer.Stop();

 }

  private void timer_Tick(...){

       label.Text = DateTime.Now.ToString("HH:mm:ss")

 }

}

La salida muestra la hora, quiero que muestre 00:00:00 cuando está en Stop, que empieze a contar el tiempo, cuando le de desconectar, se pone a 00:00:00. El problema que me muestra la hora actual, y no deseo eso.

Saludos.

[Enviar datos:]

Hola:

Antes que nada, ya que es modo consola, lo pongo en español bien español.

Enviar datos:

1. Configuración del puerto serie.

2. Abrir puerto.

3. La consola espera que introduza datos.

4. Al introducir datos, lo guarda en una variable string, da igual lo que escribas, letras, números o símbolos.

5. Si pulsas Enter envía datos al puerto serie.

Recibir datos:

1. La Consola está en espera de recibir algún dato.

2. Lo guarda en una variable string.

3. La Consola muestra en pantalla los datos recibidos.

4. Si cierra la consola o palicación, cierra el puerto.

El código de enviar datos que he hecho paso a paso es este.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

namespace Puerto_serie_consola_CS
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Puerto serie C#";

            string Enviar_datos = "";
           
            SerialPort Puerto_serie;

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

            // Configuración.
            Puerto_serie.PortName = "COM4"; // 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;

            while (true)
            {
                Console.WriteLine("Introduce comandos:"); // Muestra texto en pantalla.
                Enviar_datos = Console.ReadLine(); // Almacena los datos introducidos en consola a la variable.

                switch (Enviar_datos)
                {
                    case "Led_ON":
                        Puerto_serie.Open(); // Abrir puerto serie.
                        byte[] miBuffer = Encoding.ASCII.GetBytes(Enviar_datos); // Guarda un array los datos y codificado en ASCII.
                        Puerto_serie.Write(miBuffer, 0, miBuffer.Length); // Envía al puerto el array almacenado del buffer.
                        Console.WriteLine(); // Salto de línea.

                        //Puerto_serie.Write(Enviar_datos); // Con solo esta línea también vale pero no está codificado.

                        Puerto_serie.Close(); // Cerrar puerto serie.
                        break;

                    case "Led_OFF":
                        Puerto_serie.Open(); // Abrir puerto serie.
                        byte[] miBuffer2 = Encoding.ASCII.GetBytes(Enviar_datos); // Guarda un array los datos y codificado en ASCII.
                        Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length); // Envía al puerto el array almacenado del buffer.
                        Console.WriteLine(); // Salto de línea.

                        //Puerto_serie.Write(Enviar_datos); // Con solo esta línea también vale pero no está codificado.

                        Puerto_serie.Close(); // Cerrar puerto serie.
                        break;
                }
            }
        }
    }
}

Este código de enviar datos lo he probado en Arduino, funciona de maravilla. Antes de continuar con la parte de recibir datos, quiero saber si la forma que lo he programado es suficiente o lo tengo al estilo chapuza. Si alguien sabe mejorarlo de mejor manera, mejor que mejor.

Luego me centro en la parte de enviar datos.

Un cordial salduo.

Hola:

Si navego desde Linux, mando correo electrónico y más cosas desde una Raspberry Pi 2.


La gente que sabe, puede saber qué Sistema Operativo uso, como si es Linux por ejemplo, Windows, e incluso RISC OS para Raspberry Pi, un SO queno es Linux ni Unix.

¿Qué datos puede saber si estás con Raspberry Pi y como lo consiguen?

Saludos.

Hola:

Estoy buscando a personas con experiencias sobre grabador de Blu-ray, tengo tantas fotos y vídeos de calida alta que no me cabe en el disco duro y no quiero borrarlos, cada vez que salgo de senderismo, me ocupa la tarjeta de unos 4 GB a 8 GB entre tanta foros y víedos a 1080p. Cada viaje un DVD.

Estab a pensando en saltar al blu-ray sea el de 25 GB o el de 50 GB el disco. Cuando vi el precio aquí, de los disco a casi 100 € casi se me parte el alma.

A parte de esto. ¿Alguien tiene un grabador de BD-ROM en el PC de sobremesa?

Quiero que cuente sus experiencia de ello, si tiene algún problema, te tumba mucho discos, su velocidad o algo que deba saber. Lo pregunto porque no conozco a nadie que lo tenga, nadie me habla de ello, si los DVD-ROM de siempre, hasta CD-ROM.

Saludos.