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.

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.



Saludos.

Hola:

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

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:

Intentas hacer lo mismo pero con el Timer0.

¿Te atreves?

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

Saludos.

Buenas:

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

Muchas gracias mi muy distinguido amigo.

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.

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&#243;n.jpg", rawData); // Crea un archivo nuevo.
            Console.WriteLine("&#161;Hecho! &#191;Deseas ver la foto? S&#237; / No");
            string input = Console.ReadLine();
 
            if ((input == "Yes".ToLower()) || (input == "Y".ToLower()) ||
                (input == "S&#237;".ToLower()) || (input == "S".ToLower()))
            {
                Console.WriteLine("Mostrando imagen...");
                //Process.Start("fot&#243;n.jpg");
File.WriteAllBytes("fot&#243;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.

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

    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.

Hola:

Tengo hecho un mini programa en consola C#.

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.

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.

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

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.

Muchas gracias, me ha servido mi muy distinguido amigo.

Hola:

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

Dejo el código.

Program.cs

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

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

Class2.cs

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.