Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - Meta

#481
Hola:

Teniendo el código hecho.
Código (csharp) [Seleccionar]
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);

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


Para saber la cantidad de byte recibidos hice esto.
Código (csharp) [Seleccionar]
            SerialPort sp = (SerialPort)sender;
            int ByteLeidos = sp.Read(datosArray, 0, 28256);


Me da error.


Exactamente puse los mismos bytes que dice aquí.


El programa de Arduino IDE ya lo saqué.

// Enviar tramas de byte al puerto serie.

int estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
int anteriorBoton = 0;
char caracter;
String comando;
int flagMensaje = 0;

// Esta trama de bytes corto en realidad es extremadamente largo, en este caso es como ejemplo.
PROGMEM const unsigned char rawData[] = {
  0xFF, 0xD8, 0xFF, 0xE1, 0x00, 0x18, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00
};

void setup()
{
  pinMode(13, OUTPUT); // Donde está el Led 13.
  pinMode(8, INPUT); // Entrada digital donde está el pulsador.
  Serial.begin(115200);
}

void enviarImagen() {
  for (unsigned int i = 0; i < sizeof(rawData); i++)
    Serial.write(pgm_read_byte(&rawData[i]));
}

void loop()
{
  estadoBoton = digitalRead(8); // Leer entrada digital número 8.

  // Si el pulsador está pulsado, se enciende el Led 13 y
  // envía comando HIGH por el puerto serie.

  if (estadoBoton != anteriorBoton) // Comprueba si ha habido un cambio en el estado del botón.
  {
    flagMensaje = 0;                // Resetea la bandera a 0.
    anteriorBoton = estadoBoton;    // Guarda el estado actual del botón.
  }

  if (estadoBoton == HIGH && flagMensaje == 0) // Comprueba que el botón esté pulsado y que no se haya enviado el mensaje.
  {
    digitalWrite(13, HIGH);
    //Serial.write("ON");
    enviarImagen(); // Enviar imagen o foto hacia el puerto serie al PC.
    delay(50);

    if (flagMensaje == 0) // Si se envío el mensaje aumenta la variable a 1 para no enviarlo la próxima vez.
      flagMensaje++;
  }

  // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
  else if (flagMensaje == 0) // Si el botón no está presionado y aún no se envía el mensaje.
  {
    digitalWrite(13, LOW);
    //Serial.write("OFF");
    delay(50);

    if (flagMensaje == 0) // Si se envió el mensaje aumenta la variable en 1 para no enviarla la próxima vez.
      flagMensaje++;
  }
}


Dentro del los bytes hay una foto, en Arduino IDE, en el cual C# debe captar los datos y no me sale. Cuando lo capte, tiene que usar estas instrucciones que aún no he puesto, que es crear el archivo en el disco duro,luego ejecutar la foto.

Código (csharp) [Seleccionar]
File.WriteAllBytes("fotón.jpg", datosArray); // Crear archivo en el disco duro.

Código (csharp) [Seleccionar]
Process.Start("fotón.jpg"); // Ejecutar visualizador de imágenes.

Antes, C# tiene que ser capaz de capturar los datos desde el puerto serie y guardarlo en memoria en C#.

Feliz año nuevo 2017.
#482
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.
#483
También el más fácil es el basic. Prueba con YaBasic.
http://www.yabasic.de/download.html

De paso, hay una demo oficial en PS2 que lo programas igual y guardas los datos en la Memory Card.

https://foro.elhacker.net/buscador-t111926.0.html
https://www.iggy.net/knowledge/maths/content/module-1-the-basics-of-yabasic#index.html

En PS3 y PS4 ni aplicaciones en la store han sacado algo similar.
En la 360 han sacado el XNA Game Studio.
Y eso que estoy hablando de consolas. ;)

El más que serecomienda que hevisto por ahí, Java, Visual Studio .net, mucho el C++ nativo, asm de los PIC, hay de todo.

[youtube=640,360]https://www.youtube.com/watch?v=94RborlSzsI&t=315s[/youtube]

Saludos.
#484
Hola:

Tengo un array tipo byte[] en C# que es este:
Código (csharp) [Seleccionar]
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.
#485
Hola:

Intentas hacer lo mismo pero con el Timer0.

¿Te atreves?

Es más preciso y el PIC no se queda en esclavo.

Saludos.
#486
Buenas:

Muy buena explicación. Funciona a la perfección.

Muchas gracias mi muy distinguido amigo. ;)
#487
Cita de: crack81 en 30 Diciembre 2016, 03:48 AM
Para mi que tu quieres guardar malware o alguna cosa rara en tu programa y parace  te estas haciendo una especie de shellcode para guardarlos y que estén cifrados  o alguna cosa rara  y descifrarlos  en tiempo de ejecución de tu "programa".

Que risas cogí.  ;-) Curiosidad como se hace, para lo que sospechas, hay ya hechos de forma fácil y muy eficiente. ;)
Eso si, quiero ocultar información dentro de otra información, nada de malware o lo que se te pase por la cabeza. ;)


Bueno si eso o alguna otra a mi me da igual  :xD
Una alternativa "simple" es que le aplicas un xor a todo ese arreglo de bits y ya cuando lo quieres "descifrar" se lo vuelves a aplicar

Supongamos que a tu arreglo originalmente le aplicaste un xor 10 pues bastaria con le volvieras a aplicar ese xor 10  asi:

Código (csharp) [Seleccionar]
for (int i = 0; i < rawData.Length; i++)
{
    rawData[i] = (byte)(rawData[i] ^ 10);
}


Asi tu archivo o imagen seria restaurado a su estado original, quien tenga duda de la foto vea este enlace: https://i.gyazo.com/6762c171d0871999e12d04c5b627df69.png

PD: Aplicar desplazamiento de bit sin cuidado va a terminar dejando el archivo corrupto aunque se aplique el desplazamiento inverso.



Muy buena lo del XOR. Quiero hacerlo al revés con tu código.
¿Cómo sería?

El programa me funciona tal como me lo haz contado.
Código (csharp) [Seleccionar]

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

namespace Byte_Hex_ocultos_6
{
    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.";
            Program variable = new Program();
            variable.Cosas();
        }

        public void Cosas()
        {
            Console.WriteLine("Escribiendo archivo desde el arreglo de bytes");
            // ##############################################

            for (int i = 0; i < rawData.Length; i++)
            {
                rawData[i] = (byte)(rawData[i] ^ 10);
            }

            // ##############################################
            File.WriteAllBytes("fotón.jpg", rawData); // Crea un archivo nuevo.
            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");
File.WriteAllBytes("fotón.jpg", rawData_XOR10); // Crea un archivo nuevo.
                Console.WriteLine("Imagen cargada.");
            }

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



He puesto otra variable con elXOR 10 ya codificado en vez de poner la original, la foto,claro. Ya sería.
Código (csharp) [Seleccionar]
byte[] rawData_XOR10 = {
    0xF5, 0xD2, 0xF5, 0xEA, 0x0A, 0x1A, 0x40, 0x4C, 0x43, 0x4C, 0x0A, 0x0B,
    0x0B, 0x0B, 0x0A, 0x42, 0x0A, 0x42, 0x0A, 0x0A, 0xF5, 0xD1, 0x0A, 0x49,


Quiero probar el efecto contario, si no me equivoco..
Código (csharp) [Seleccionar]
    for (int i = 0; i < rawData_XOR10.Length; i++)
    {
        rawData_XOR10[i] = (byte)(rawData_XOR10[i] ^ -10);
    }


Lo de desplazamiento de byte tienes que tener en cuenta el bit de acarreo, por eso pasa lo que dices. No es lo mismo (0)11111111 que al desplazar un bit a la derecha (1)01111111. Es más complejo de lo que aparenta porque cada byte con su bit de acarreo y programarlo es más complicado de lo que uno pienza. Estoy acostumbrado al asm de los PIC.

Estoy haciendo pruebas gracias a ti y aprendiendo. ;)

Para curiosos.
https://msdn.microsoft.com/es-es/library/zkacc7k1.aspx
https://www.youtube.com/watch?v=tPfTZbEzcmM

Felices fiestas.
#488
Hola:

Tengo hecho un mini programa en consola C#.
Código (csharp) [Seleccionar]
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]
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.
#489
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]
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.
#490
Muchas gracias, me ha servido mi muy distinguido amigo. ;)