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.
using System;
using System.IO.Ports;
using System.Text;
using System.Threading;
using System.Windows.Forms;
namespace Velocímetro_Arduino_Puerto_serie_01
{
public partial class Form1 : Form
{
// Utilizaremos un string como buffer de recepción.
string recibidos;
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
// Añado los puertos disponible en el PC con SerialPort.GetPortNames() al comboBox_Puerto.
try
{
comboBox_Puerto.DataSource = SerialPort.GetPortNames();
}
catch
{
MessageBox.Show("No encuentra ningún puerto físico ni virtual.", "Aviso:",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
// // Añade puertos disponibles físicos y virtuales.
serialPort1.PortName = comboBox_Puerto.Text.ToString();
}
#region Funciones.
void UsbConectado()
{
byte[] miBuffer = Encoding.ASCII.GetBytes("USB_CONECTADO");
serialPort1.Write(miBuffer, 0, miBuffer.Length);
}
void UsbDesconectado()
{
byte[] miBuffer = Encoding.ASCII.GetBytes("USB_DESCONECTADO");
serialPort1.Write(miBuffer, 0, miBuffer.Length);
}
// 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();
}
// Detecta si hay cambios en el usb y si los hay los refleja.
base.WndProc(ref USB);
}
// Procesar los datos recibidos en el buffer y extraer las tramas completas.
void Actualizar(object sender, EventArgs e)
{
// Asignar el valor de la trama al label_Recibir_Km.
label_Recibir_Km.Text = recibidos;
switch (recibidos)
{
case "OK":
byte[] miBuffer = Encoding.ASCII.GetBytes("Conectado. ");
serialPort1.Write(miBuffer, 0, miBuffer.Length);
label_Recibir_Km.Text = "Arduino conectado.";
break;
default:
break;
}
// Limpiar.
recibidos = "";
}
#endregion
#region Botones.
private void button_Conectar_Click(object sender, EventArgs e)
{
try
{
serialPort1.PortName = comboBox_Puerto.Text.ToString(); // Puerto seleccionado previamente.
serialPort1.Open(); // Abrir puerto.
UsbConectado();
comboBox_Puerto.Enabled = false;
comboBox_Baudios.Enabled = false;
button_Conectar.Enabled = false;
button_Desconectar.Enabled = true;
button_Enviar.Enabled = true;
}
catch
{
MessageBox.Show("El puerto no existe.", "Aviso:",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void button_Desconectar_Click(object sender, EventArgs e)
{
UsbDesconectado();
serialPort1.Close(); // Cerrar puerto.
comboBox_Puerto.Enabled = true;
comboBox_Baudios.Enabled = true;
button_Conectar.Enabled = true;
button_Desconectar.Enabled = false;
button_Enviar.Enabled = false;
}
private void button_Enviar_Click(object sender, EventArgs e)
{
byte[] miBuffer = Encoding.ASCII.GetBytes("KM" + textBox_Km.Text);
serialPort1.Write(miBuffer, 0, miBuffer.Length);
}
#endregion
// Al cerrar el formulario, cierra el puerto si está abierto.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
try
{
// Al cerrar este programa, indica a Arduino cerrado.
// Arduino sigue con su rutina al detectar CERRADO.
byte[] miBuffer = Encoding.ASCII.GetBytes("C#_CERRADO");
serialPort1.Write(miBuffer, 0, miBuffer.Length);
// Cerrar puerto.
serialPort1.Close();
}
catch (Exception error)
{
MessageBox.Show(error.Message, "Aviso:",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void serialPort1_DataReceived(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));
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Codificación_UTF_8_01
{
internal class Program
{
static void Main(string[] args)
{
#region Configuración ventana.
// Título de la ventana.
Console.Title = "Encoder UTF-8";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(80, 25);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Gray;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Black;
// Limpiar pantalla y dejarlo todo gris.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
#endregion
// Cree una codificación UTF-8.
UTF8Encoding utf8 = new UTF8Encoding();
// Una cadena Unicode con dos caracteres fuera de un rango de código de 8 bits.
String unicodeString =
"Esta cadena Unicode tiene 2 caracteres fuera del " +
"rango ASCII:\n" +
"Pi (\u03a0), y Sigma (\u03a3).";
Console.WriteLine("Cadena original:");
Console.WriteLine(unicodeString);
// Codifica la cadena.
Byte[] encodedBytes = utf8.GetBytes(unicodeString);
Console.WriteLine();
Console.WriteLine("Bytes codificados:");
for (int ctr = 0; ctr < encodedBytes.Length; ctr++)
{
Console.Write("{0:X2} ", encodedBytes[ctr]);
if ((ctr + 1) % 25 == 0)
Console.WriteLine();
}
Console.WriteLine();
// Decodifica bytes de nuevo a cadena.
String decodedString = utf8.GetString(encodedBytes);
Console.WriteLine();
Console.WriteLine("Bytes decodificados:");
Console.WriteLine(decodedString);
// Pulse cualquier tecla para salir.
Console.ReadKey();
}
}
}
// Activar / desactivar Acceso de aplicaciones poco seguras en Google.
// https://myaccount.google.com/lesssecureapps
using System;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Text;
namespace Enviar_email_Consola_07
{
internal class Program
{
static void Main(string[] args)
{
#region Configuración ventana.
// Título de la ventana.
Console.Title = "Gestor correo electrónico";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(80, 25);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Black;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Gray;
// Limpiar pantalla y dejarlo todo en color de fondo.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
#endregion
// Variables.
string usuario, contraseña, destinatario, asunto, mensaje;
// Título del programa.
Console.WriteLine("\t\t----------------------------------------");
Console.WriteLine("\t\t\tEnviar Correo Electrónico");
Console.WriteLine("\t\t----------------------------------------");
try
{
Console.WriteLine("\n");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("\t\tTu correo electrónico: ");
Console.ForegroundColor = ConsoleColor.Gray;
usuario = Console.ReadLine();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("\t\tIntroducir contraseña: ");
Console.ForegroundColor = ConsoleColor.Gray;
contraseña = LeerPassword();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("\t\tDestinatario: ");
Console.ForegroundColor = ConsoleColor.Gray;
destinatario = Console.ReadLine();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("\t\tAsunto: ");
Console.ForegroundColor = ConsoleColor.Gray;
asunto = Console.ReadLine();
Console.WriteLine();
//----------------------------------------------
byte[] bytes = new byte[2000]; // Nuevo tamanho máximo.
Stream inputStream = Console.OpenStandardInput(bytes.Length);
Console.SetIn(new StreamReader(inputStream));
//----------------------------------------------
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("\t\tMensaje: ");
Console.ForegroundColor = ConsoleColor.Gray;
mensaje = Console.ReadLine();
Console.WriteLine();
MailMessage correo = new MailMessage(usuario, destinatario, asunto, mensaje);
SmtpClient servidor = new SmtpClient("smtp.gmail.com")
{
Port = 587
};
NetworkCredential credenciales = new NetworkCredential(usuario, contraseña);
servidor.Credentials = credenciales;
servidor.EnableSsl = true;
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("\t\tEnviando correo...");
servidor.Send(correo);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\t\tCorreo enviado satisfactoriamente.");
correo.Dispose();
Console.CursorVisible = false;
Console.ReadKey();
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERROR: \n");
Console.WriteLine("\t\t" + ex.Message);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("\t\tNo se ha enviado el correo.");
Console.ReadKey();
}
}
// A la hora de introducir la contraseña, se sustituye por asterístos (*) en pantalla.
public static string LeerPassword()
{
ConsoleKeyInfo cki;
StringBuilder sb = new StringBuilder();
int contador = 0;
do
{
cki = Console.ReadKey(true);
if (cki.Key != ConsoleKey.Enter)
{
sb.Append(cki.KeyChar);
if (contador < 4)
{
Console.Write("*");
}
contador++;
}
else
{
break;
}
} while (true);
Console.WriteLine();
return sb.ToString();
}
}
}using System;
using System.IO;
namespace LCD_nombre_archivo_consola_12
{
class Program
{
// Variables.
static string guardarNombre = ""; // Guardar nombre escrito.
static int coordenadaX = 0; // Coordenada X del setCursorPisition.
static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
static int index = 0; // Índice.
// Caracteres de este array.
static readonly char[] roALFANUMERICO = new char[]
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
'¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\'', '"', ' '
};
// Dirección del carácter del array. El 83 presenta al espacio ' ' del array roALFANUMERICO indicado justo arriba.
// Hay un total de 85 caracteres. Se cuenta desde el 0 al 84.
static readonly int[] roINDICE_ARRAY = new int[]
{
84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84
};
// Palabras del array para imprimir en pantalla.
static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
static void Main(string[] args)
{
// Título de la pantalla.
Console.Title = "Cambiar nombre";
Inicio();
}
static void MainMenu()
{
Console.Clear(); // Limpiar pantalla.
Console.SetCursorPosition(0, 0);
Console.Write("Nombre del relé 1: ");
Console.SetCursorPosition(0, 1);
// Recorre el índice del array, del 0 hasta donde llegue.
for (int i = 0; i < roINDICE_ARRAY.Length; i++)
{
// Imprime los caracteres del array.
Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
}
Console.SetCursorPosition(3, 3);
Console.Write(roTEXTO[0]); // ATRÁS.
Console.SetCursorPosition(12, 3);
Console.Write(roTEXTO[1]); // GUARDAR.
}
#region Inicio.
static void Inicio()
{
Console.SetWindowSize(20, 5); // Residemensiona pantalla. X = 20, Y = 5.
Console.BackgroundColor = ConsoleColor.Gray; // Fondo gris.
Console.ForegroundColor = ConsoleColor.Black; // Letras negras.
// ¿El archivo Existe?
if (File.Exists("Archivo.txt"))
{
// Sí. Lee el archivo de texto.
string nombre = File.ReadAllText("Archivo.txt");
int a, b; // Almacena ídice array.
for (a = 0; a < nombre.Length; a++)
{
for (b = 0; roALFANUMERICO[b] != nombre[a]; b++)
{
;
}
roINDICE_ARRAY[a] = b; // b indica índice y lo añade al roINDICE_ARRAY.
}
}
// No. El Archivo.txt no existe.
else
{
// Crea un archivo nuevo, escribe el contenido en el archivo y, a continuación, lo cierra.
// Si el archivo de destino ya existe, se sobrescribe.
File.WriteAllText("Archivo.txt", guardarNombre);
}
MainMenu(); // Dibuja el menú.
while (true)
{
Console.CursorVisible = true; // Cursor invisible.
index = 0;
// Si se cumple estas condiciones, Enter, flecha izquierda, flecha derecha
if ((tecla == ConsoleKey.Enter) || (tecla == ConsoleKey.RightArrow) || (tecla == ConsoleKey.LeftArrow))
{
MainMenu(); // Dibuja el menú.
}
// Posiciona cursor.
Console.SetCursorPosition(coordenadaX, 1);
// Almacena en la variable tecla, la tecla pulsada.
tecla = Console.ReadKey(true).Key;
// Si coincide una tecla pulsada.
switch (tecla)
{
case ConsoleKey.RightArrow: // Flecha derecha detectada.
// ¿CoordenadaX menor que 15?
if (coordenadaX < 15)
{
coordenadaX++; // Sí. Añada + 1 en la coordenadaX.
}
// No. Sale de aquí.
break;
case ConsoleKey.LeftArrow: // Flecha izquierda detectada.
// ¿coordenadaX es mayor que 0?
if (coordenadaX > 0)
{
coordenadaX--; // Sí. Decremente o quita -1.
}
// No. Sale de aquí.
break;
case ConsoleKey.UpArrow: // Flecha arriba.
roINDICE_ARRAY[coordenadaX]++; // En el índice del array añade + en coordenadaX.
// ¿El índice del array es mayor o igual que el array Alfanumérico?
if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
{
roINDICE_ARRAY[coordenadaX] = 0; // Sí. Deja en 0 la coordenada del índice del array.
}
Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
break;
case ConsoleKey.DownArrow: // Flecha abajo detectado.
roINDICE_ARRAY[coordenadaX]--; // Decrementa a -1 el índice del array.
// ¿La coordenadaX del indice del array es menor que 0?
if (roINDICE_ARRAY[coordenadaX] < 0)
{
// Sí. Imprimir el valor alfanumérico.
roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
}
Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
break;
case ConsoleKey.Enter: // Detecta la tecla Enter.
Console.SetCursorPosition(1, 3); // Posición del cursor.
Console.CursorVisible = false; // Se oculta el cursor.
Console.Write(">"); // Imprime en pantalla >.
// ¿La tecla almacenada es distinto a la tecla Enter?
while ((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)
{
// Sí.
switch (tecla)
{
case ConsoleKey.RightArrow:
index = 1;
Console.SetCursorPosition(1, 3);
Console.Write(" ");
Console.SetCursorPosition(10, 3);
Console.Write(">");
break;
case ConsoleKey.LeftArrow:
Console.SetCursorPosition(10, 3);
Console.Write(" ");
Console.SetCursorPosition(1, 3);
Console.Write(">");
index = 0;
break;
case ConsoleKey.UpArrow:
Inicio();
break;
case ConsoleKey.DownArrow:
Inicio();
Console.SetCursorPosition(coordenadaX, 1);
break;
}
}
if (index == 0)
{
Atras();
}
if (index == 1)
{
Guardar();
}
break;
}
}
}
#endregion
static void Atras()
{
Console.Clear();
Console.SetCursorPosition(0, 1);
Console.Write("HAS PULSADO ATRÁS ");
Console.ReadKey(); // Pulse cualquier tecla para salir.
}
static void Guardar()
{
guardarNombre = "";
Console.Clear(); // Limpia la pantalla.
// Lee todo el contennido del array y lo guarda en guardarNombre.
for (int a = 0; a < roINDICE_ARRAY.Length; a++)
{
guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
}
Console.SetCursorPosition(0, 2);
Console.Write(guardarNombre); // Imprime el contenido.
// Crear Archivo.txt y el contenido de guardarNombre.
File.WriteAllText("Archivo.txt", guardarNombre);
Console.SetCursorPosition(0, 1);
Console.Write("HAS GUARDADO ");
// Pulsa otra vez tecla.
Console.ReadKey();
}
}
}int Variar_este_valor = Convert.ToInt32(Recibidos);using System;
using System.IO.Ports; // No olvidar.
using System.IO;
namespace Porcentaje_Barra_Puerto_Serie_Consola_03
{
class Program
{
public static string recibidos = "";
public static double Resultado_Porcentaje = 0;
public static double Resultado_Voltios = 0;
public static double Mitad_barra = 0;
public static int Contador = 1;
static void Main(string[] args)
{
#region Configuración ventana.
// Título de la ventana.
Console.Title = "Puerto serie C# - 2019";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(100, 35);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.DarkBlue;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Yellow;
// Limpiar pantalla y dejarlo todo en color de fondo.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
#endregion
string COM = "";
// Crear un nuevo objeto SerialPort con la configuración predeterminada.
SerialPort serialPort1 = 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();
serialPort1.PortName = "COM" + COM; // Número del puerto serie.
// Crear un nuevo objeto SerialPort con la configuración predeterminada.
// Configuración del puerto serie.
serialPort1.BaudRate = 9600; // Baudios o velocidad. 115200
serialPort1.Parity = Parity.None; // Sin paridad.
serialPort1.DataBits = 8; // 8 Bits de datos.
serialPort1.StopBits = StopBits.Two; // Bits de parada.
serialPort1.Handshake = Handshake.None; // Control de flujo.
serialPort1.ReadBufferSize = 4096; // Tamaño del Búffer de lectura en Bytes.
serialPort1.WriteBufferSize = 2048; // Tamaño del Búffer de escritura en Bytes.
serialPort1.ReadTimeout = 500; // Establecer lectura de espera.
serialPort1.WriteTimeout = 500; // Establecer escritura de espera.
serialPort1.DtrEnable = false;
serialPort1.RtsEnable = false;
try
{
serialPort1.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 " + serialPort1.PortName + @" no existe
o no lo encuentra.");
}
serialPort1.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
Console.Read();
serialPort1.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);
// Dibujamos la barra del portentaje.
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);
ClearCurrentConsoleLine();
// Barra de progreso.
for (int i = 1; i <= Mitad_barra; i++)
{
Console.Write("█"); // Muestra ASCII 219 Dec y DB en Hex.
// Console.Write((char)219);
// Console.Write(Encoding.ASCII.GetBytes((char)219));
}
// Si sobre pasa 100, muestra # al final de la barra del porcentaje de color rojo.
if (Resultado_Porcentaje >= 100)
{
Console.SetCursorPosition(50, 5);
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.");
Console.SetCursorPosition(0, 10);
Console.Write(" ");
Console.SetCursorPosition(0, 10);
Console.Write("Contador: " + Contador++);
// return;
}
}
public static void ClearCurrentConsoleLine()
{
int currentLineCursor = Console.CursorTop;
Console.SetCursorPosition(0, Console.CursorTop);
Console.Write(new string(' ', Console.WindowWidth));
Console.SetCursorPosition(0, currentLineCursor);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Delimitador_consola_03
{
class Program
{
static void Main(string[] args)
{
#region Configuración ventana.
// Título de la ventana.
Console.Title = "Probando manipulación de cadena";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(100, 35);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.DarkBlue;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Yellow;
// Limpiar pantalla y dejarlo todo en color de fondo.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
#endregion
// Cree una codificación ISO-8859-1.
Encoding ISO_8859_1 = Encoding.GetEncoding("ISO-8859-1");
#region Variables.
// Partir a trocitos estos caracteres.
char[] delimitadorComandoB = { '#', ',', 'O', 'I', 'L', 'B', 'V', 'F', 'H', 'R', 'S', };
// Es la cadena de caracteres que me llegó desde el puerto serie.
// En este ejemplo lo dejo en la varible directamente.
// Una cadena completa empieza con # y termina en <cr>, o lo que es lo mismo, /r.
string respuestaB = "#I223.3O224.0L000B100V26.4F50.2H50.2R0080S,,€€,,À"; // Comando B.
// Se guarga en este array tipo string los datos ya partidos a tozos.
string[] palabrasB = respuestaB.Split(delimitadorComandoB);
// Tabla S1 descripción.
string[] DESCRIPCION_S1 =
{
"Indica que este byte está disponible y es válido. [Siempre 1]", // Posición [0].
"Indica falla de energía de la red pública; ver detalles en S2.0 y S2.1.",
"Indica que la capacidad de la batería es menor que el umbral de apagado.",
"Indica que el zumbador está en estado de pitido.",
"Indica que la prueba de batería se está procesando.",
"Indica que el apagado programado está pendiente.",
"Indica que la restauración programada está pendiente.",
"Indica falla de hardware; ver detalles sobre el comando X71." // Posición [7].
};
string[] DESCRIPCION_S2 =
{
"Para indicar que este byte está disponible y es válido. [Siempre 1].",
"--",
"XX",
"Indica sobretemperatura del inversor.",
"Indica que el inversor tiene una falla.",
"Indica que el inversor está apagado.",
"Indica que la frecuencia de la utilidad está fuera de rango.",
"Indica que el voltaje de la red pública está fuera de rango."
};
string[] DESCRIPCION_S3 =
{
"Para indicar que este byte está disponible y es válido. [Siempre 1].",
"Indica que la batería está completamente cargada.",
"Indica que la capacidad de la batería aún es menor que el umbral restaurado del UPS cuando la energía de la red pública restaurado.",
"Indica que la batería se está cargando.",
"Indica que la batería se está descargando.",
"Indica que la capacidad de la batería es inferior al 80 por ciento.",
"Reservado, debe ser 0.",
"Indica que la batería no está presente."
};
string[] DESCRIPCION_S4 =
{
"Para indicar que este byte está disponible y es válido. [Siempre 1].",
"Indica que el bypass es una sobrecarga.",
"Indica que la derivación está activa.",
"Indica que la salida sufre un cortocircuito.",
"Indica que la salida tiene carga.",
"Indica que la salida está sobrecargada.",
"Indica que la frecuencia de salida está fuera de rango en bypass.",
"Indica que el voltaje de salida está fuera de rango en derivación."
};
string[] DESCRIPCION_S5 =
{
"Para indicar que este byte está disponible y es válido. [Siempre 1].",
"Indica que no hay salida.",
"Para indicar que el tiempo de ejecución restante es inferior al umbral.",
"Para indicar que el zumbador está silenciado (no permanente) en este momento.",
"Para indicar falla de cableado.",
"Para indicar SAI en modo ECO.",
"Para indicar UPS en Bypass manual.",
"Arreglar 0."
};
string[] DESCRIPCION_S6 =
{
"Para indicar que este byte está disponible y es válido. [Siempre 1].",
"Indica UPS encendido.",
"Reservado, debe ser 0.",
"Reservado, debe ser 0.",
"Reservado, debe ser 0.",
"Reservado, debe ser 0.",
"Reservado, debe ser 0.",
"Reservado, debe ser 0."
};
bool boolS1 = true;
bool boolS2 = false;
bool boolS3 = false;
bool boolS4 = false;
bool boolS5 = false;
bool boolS6 = false;
bool boolContador = true;
bool boolContador2 = false;
#endregion
// Comando B.
Console.WriteLine();
// Muestra los resultados en pantalla.
Console.WriteLine();
Console.WriteLine("El voltaje de la utilidad es de {0} voltios. ", palabrasB[2]); // I.
Console.WriteLine("El voltaje de salida del UPS es de {0} voltios. ", palabrasB[3]); // O.
Console.WriteLine("La carga actual de UPS es del {0} por ciento. ", palabrasB[4]); // L.
Console.WriteLine("La capacidad de la batería es del {0} por ciento. ", palabrasB[5]); // B.
Console.WriteLine("El voltaje de la batería es de {0} voltios. ", palabrasB[6]); // V.
//Console.WriteLine("La temperatura del gabinete del UPS es de {0} grados centígrados. ", palabrasB[7]); // T. No hay T. en mi versión.
Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[7]); // F.
Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[8]); // H.
Console.WriteLine("El tiempo de funcionamiento restante de la batería es de {0} minutos. ", palabrasB[9]);
//Console.WriteLine(@"Estos son los bits de estados que no se entiende.S:
//Aquí hay que leer cada bits como cuando se leyeron cada Byte arriba: ", (char)palabrasB[10]);
char[] bits = palabrasB[10].ToCharArray();
//int byteS1 = (byte)bits[0];
//int byteS2 = (byte)bits[1];
//int byteS3 = (byte)bits[2];
//int byteS4 = (byte)bits[3];
//int byteS5 = (byte)bits[4];
//int byteS6 = (byte)bits[5];
//Console.WriteLine("Byte S1: {0}", byteS1.ToString());
//Console.WriteLine("Byte S2: {0}", byteS2.ToString());
//Console.WriteLine("Byte S3: {0}", byteS3.ToString());
//Console.WriteLine("Byte S4: {0}", byteS4.ToString());
//Console.WriteLine("Byte S5: {0}", byteS5.ToString());
//Console.WriteLine("Byte S6: {0}", byteS6.ToString());
//Console.WriteLine();
//Console.WriteLine(((byteS1 & 128) == 128) ? "ACTIVADO" : "DESACTIVADO");
//Console.WriteLine(((byteS1 & 128) == 128) ? "1" : "0");
//Console.WriteLine();
Tabla();
int contador = 0;
for (int b = 0; b < bits.Length; b++)
{
for (int a = 7; a >= 0; a--)
{
Console.Write((((byte)bits[b]) & (1 << a)) >> a);
Console.Write(" | ");
if ((contador <= 7) && (boolS1 == true))
{
Console.WriteLine(DESCRIPCION_S1[contador]);
if (contador == 7)
{
boolS1 = false;
boolS2 = true;
boolContador2 = true;
contador = 0;
}
}
else if ((contador <= 7) && (boolS2 == true))
{
Console.WriteLine(DESCRIPCION_S2[contador]);
boolContador2 = false;
if (contador == 7)
{
boolS2 = false;
boolS3 = true;
boolContador2 = true;
contador = 0;
}
}
else if ((contador <= 7) && (boolS3 == true))
{
Console.WriteLine(DESCRIPCION_S3[contador]);
boolContador2 = false;
if (contador == 7)
{
boolS3 = false;
boolS4 = true;
boolContador2 = true;
contador = 0;
}
}
else if ((contador <= 7) && (boolS4 == true))
{
Console.WriteLine(DESCRIPCION_S4[contador]);
boolContador2 = false;
if (contador == 7)
{
boolS4 = false;
boolS5 = true;
boolContador2 = true;
contador = 0;
}
}
else if ((contador <= 7) && (boolS5 == true))
{
Console.WriteLine(DESCRIPCION_S5[contador]);
boolContador2 = false;
if (contador == 7)
{
boolS5 = false;
boolS6 = true;
boolContador2 = true;
contador = 0;
}
}
else if ((contador <= 7) && (boolS6 == true))
{
Console.WriteLine(DESCRIPCION_S6[contador]);
boolContador2 = false;
if (contador == 7)
{
boolS6 = true;
boolContador2 = true;
contador = 0;
}
}
if (boolContador == true)
{
contador++;
if (boolContador2 == true)
{
contador = 0;
}
}
//Console.WriteLine();
}
Console.WriteLine();
}
#region Tabla.
void Tabla()
{
Console.WriteLine();
Console.WriteLine("Byte | Bit | Estado | Descripción");
Console.WriteLine("-----+-----+-----------------------------------------------------------------------");
}
#endregion
// Pulse cualquier tecla para salir.
Console.ReadKey();
}
}
}
// Título de la ventana.
Console.Title = "Configuración ventana consola C#";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(100, 35);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.DarkBlue;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Yellow;
// Limpiar pantalla y dejarlo todo en color de fondo.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
cXLimIzq EQU 32 ; X-Limite izquierda juego
cXLimDer EQU 320-cXLimIzq ; X-Limite derecha juego
cYLimSup EQU 60 ; Y-Limite superior juego
cYLimInf EQU 180 ; Y-Limite inferior juego
cIncYEDisp EQU 1 ; Y-incremento de los e-disparos
cTamDefFig EQU 7*2 ; Los words que definen la figura
cSepIniEDisp EQU 4 ; Separación inicial del disparo enemigo
cColorEDisp EQU 14 ; Color del disparo enemigo
cColorPDisp EQU 7 ; Color del disparo del jugador
cFigAlto EQU 7 ; Altura de las figuras
cFigAncho EQU 16 ; Anchura de las figuras
cAncho EQU 256 ; Anchura de la pantalla de juego
cAlto EQU cYLimInf-cYLimSup+1 ; Altura de la pantalla de juego
cSepMargen EQU 3 ; Margen de separación con el borde
cLinColor EQU 6 ; Color de la línea contenedora
cFrecBomb EQU 010h ; Frecuencia con la que empiezan a caer bombas
cNumEColumn EQU 11 ; Número de columnas de enemigos
cNumEnemigos EQU 5*cNumEColumn ; Número de enemigos
cDispEne EQU 5 ; Máximo num disparos x cada enemigo
cNumDispEne EQU 7;cDispEne*cNumEColumn; Máximo disparos activos enemigos
cXESep EQU 1 ; X-separación entre enemigos
cYESep EQU 3 ; Y-separación entre enemigos
cXESup EQU (cAncho-((16+cXESep)*10+16))/2 ; X-inicial-superior enemigos
cYESup EQU cYLimSup-cYLimSup ; Y-superior enemigos
cYPSup EQU cYLimInf-7-cYLimSup ; Y-superior player
cXPIzq EQU 0 ; X-lim izquierda player
cXPDcha EQU 256-11 ; X-lim derecha player
cTimePlayer EQU 0 ; Tiempo retardo movimiento player
cTimeEnemigos EQU 20 ; Tiempo retardo movimiento enemigos
cTimePDisp EQU 0 ; Tiempo retardo movimiento player-disparo
cTimeEDisp EQU 0 ; Tiempo retardo movimiento enemigos-disparos
cTimeESgteDisp EQU 10 ; Tiempo retardo siguiente enemigos-disparos
cChgTEnemigos EQU 2 ; Cada cuántos enemigos destruidos incrementan velocidad
cFilasBaja EQU 2 ; Filas que bajan los enemigos cada vez
cYTope EQU cYPSup-10 ; Tope superior que no pueden sobrepasar enemigos
cSoyInmune EQU 0 ; 1-soy inmune, 0-no soy inmune
cTAMTOT EQU 1024*6 ; Este programa y su pila caben en 6Kb
cnNotas EQU 7+6+7+5
TEnemigos STRUC
PosX DW ?
PosY DW ?
OldPosX DW ?
Def DW ? ; La dirección donde está definido
Despl DW ? ; El desplazamiento de offsets (+7?)
Tipo DB ? ; 1, 2, 3, 4, 5
Color DB ?
Vida DB ?
Abajo DB ? ; Sólo disparan los que estén abajo
TEnemigos ENDS
TCabEDisp STRUC ; Estructura de la cabecera de los disparos enemigos
DirDisp DW ? ; Dirección donde se encuentra el disparo
Vida DB ? ; ¿Está vivo?
TCabEDisp ENDS
TEDisparos STRUC ; Disparos de los enemigos
PosX DW ?
PosY DW ?
Def DW ? ; Matriz de definición del disparo
Despl DW ? ; junto con el desplazamiento de offsets (+7?)
Color DB ?
TEDisparos ENDS
TPlayer STRUC
PosX DW ?
PosY DW ?
Def DW ? ; La dirección donde está definido
Color DB ?
Vida DB ?
TPlayer ENDS
TPDisparos STRUC ; Disparos del jugador
PosX DW ?
PosY DW ?
Def DW ?
Despl DW ? ; El desplazamiento de offsets (+7?)
Color DB ?
Vida DB ?
TPDisparos ENDS
TNota STRUC
Frecuencia DW ?
Duracion DB ?
TNota ENDS
LTEnemigos EQU SIZEOF TEnemigos
LTEDisparos EQU SIZEOF TEDisparos
LTCabEDisp EQU SIZEOF TCabEDisp
LTPlayer EQU SIZEOF TPlayer
LTPDisparos EQU SIZEOF TPDisparos
LTNota EQU SIZEOF TNota
IF1
INCLUDE ..\LIB\CtesGphM.inc ; Constantes gráficas
INCLUDE ..\LIB\GraphMM.inc ; Incorporamos las macros gráficas
ENDIF
codigo SEGMENT PARA PUBLIC 'CODE' ; Abre el segmento de código
ASSUME CS:codigo, DS:codigo, ES:codigo, SS:codigo
ORG 100h ; COM -> comienza en 100h
Entrada PROC ; Abre el procedimiento
; *** Reasigna memoria
MOV SP, cTAMTOT ; La base de la pila
MOV AH, 4Ah
MOV BX, cTAMTOT/16 ; Lo pasamos a párrafos
INT 21h ; Redimensionamos el bloque de memoria
JNC $_Bien1
MOV AH, 9
MOV DX, OFFSET msg1
INT 21h
JMP $_Salimos
$_Bien1:
CALL VGAColor ; Comprobamos si existe VGA en color
; Reserva memoria para el búfer pant1
MOV BX, (cXLimDer-cXLimIzq+1)*(cYLimInf-cYLimSup+1)/16+1 ; En párrafos
CALL ResMem
MOV WORD PTR [ScrSeg], AX
SetMode 13h ; Ponemos el modo gráfico
CALL DibMarco
CALL SaveValSPK
CALL Randomize
CALL SaveOldInt9h
CALL SetNewInt9h
CALL SaveOldInt1Ch
CALL SetNewInt1Ch
CALL IniCabEDisp
CALL ResetNivel ; Inicializamos el nivel del juego
$_Nueva_Partida:
CALL IniElementos ; Inicializa valores en función de variables y constantes
$_Main:
CALL GetPShoot ; ¿Hemos pulsado ctrl?
CALL GetEShoot ; ¿Debe disparar un enemigo?
CALL SetMotion ; Movemos las piezas si toca
JNC $_Next0
; Si STC = 1 significa que los enemigos han llegado al nivel inferior: ganaron
CALL ResetNivel ; Inicializamos el nivel del juego
CALL WaitUntilCtrl ; Esperamos hasta Ctrl pulsado
JMP $_Nueva_Partida
$_Next0:
CMP BYTE PTR [NumEnemigos], 0
JA $_Next1
CALL incNivel ; Incrementamos el nivel del juego
JMP $_Nueva_Partida
$_Next1:
CMP BYTE PTR [Player.Vida], 0
JA $_Next2
CALL ResetNivel ; Inicializamos el nivel del juego
CALL WaitUntilCtrl ; Esperamos hasta Ctrl pulsado
JMP $_Nueva_Partida
$_Next2:
CALL ClearBuffer ; Limpiamos el búfer
CALL DibujaEnemigos ; Dibujamos los enemigos en el búfer
CALL DibujaJugador ; Dibujamos el jugador en el búfer
CALL DibujaPDisparo ; Dibujamos el disparo del jugador en búfer
CALL DibujaEDisparo ; Dibujamos los disparos de los enemigos en búfer
CALL CheckPDEDColision ; ¿El disparo del jugador alcanzo al de algun enemigo?
CALL CheckMPDColision ; ¿El disparo del jugador alcanzo algun enemigo?
CALL CheckMEDColision ; ¿El disparo de los enemigos alcanzaron al jugador?
WRetrace 8 ; Esperamos al final del retrazo
MOV AX, WORD PTR [ScrSeg] ; Segmento Origen
MOV BX, __VgaSeg ; Segmento destino: mem vídeo
CALL Copy64K ; Vuelca búfer en mem vídeo
CMP BYTE PTR [Escape], 1
JNZ $_Main
SetMode 3h ; Volvemos al modo texto
CALL RestoreOldInt1Ch
CALL RestoreOldInt9h
CALL TurnOffSpk
MOV AX, WORD PTR [ScrSeg] ; Libera memoria pantalla
CALL LibMem
$_Salimos:
; Salimos al DOS
MOV AX, 4C00h ; Servicio 4Ch, mensaje 0
INT 21h ; volvemos AL DOS
Entrada ENDP ; cierra el procedimiento
IF1
INCLUDE ..\LIB\VGA_M.inc ; Incorporamos procedimientos
INCLUDE ..\LIB\SpcM.inc ; Incorporamos procedimientos
ENDIF
; ****************
TurnOffSpk PROC
; Propósito: Apaga el altavoz
; Entrada : Ninguna
; Salida : Ninguna
; Destruye : AX
MOV AL, BYTE PTR [vbSpeaker]
AND AL, 11111100b ; Apagamos y descconectamos el altavoz del canal 2 del PIT
OUT 61h, AL
RET
TurnOffSpk ENDP
SaveValSPK PROC
; Propósito: Guarda el valor original del puerto 61h
; Entrada : Ninguna
; Salida : Ninguna
; Destruye : AX
IN AL, 61h
AND AL, 11111100b
MOV BYTE PTR [vbSpeaker], AL
RET
SaveValSPK ENDP
Frec_Periodo PROC
; Propósito: Convertimos la frecuencia en período
; Entrada : CX: frecuencia
; Salida : DX: período
; Destruye : AX, DX
MOV DX, 12h
MOV AX, 34DCh
DIV CX
MOV DX, AX ; Lo guardamos en DX
RET
Frec_Periodo ENDP
PIT_REG_COMM PROC
; Propósito: Le indicamos al PIT lo que vamos a hacer
; Entrada : DX:periodo
; Salida : Ninguna
; Destruye : AX
MOV AL, 0B6h
OUT 43h, AL
MOV AL, DL ; Pasamos el byte bajo del contador
OUT 42h, AL
MOV AL, DH ; Y ahora el alto
OUT 42h, AL
RET
PIT_REG_COMM ENDP
SpkOn PROC
; Propósito: Encendemos el altavoz con duración determinada
; Entrada : Ninguna
; Salida : Ninguna
; Destruye : AX
MOV AL, BYTE PTR CS:[vbSpeaker]
OR AL, 3
OUT 61h, AL
RET
SpkOn ENDP
SpkOff PROC
; Propósito: Encendemos el altavoz con duración determinada
; Entrada : Ninguna
; Salida : Ninguna
; Destruye : AX
MOV AL, BYTE PTR CS:[vbSpeaker]
AND AL, 11111100b
OUT 61h, AL
RET
SpkOff ENDP
Sonido PROC
; Propósito: Toca una nota en el altavoz del PC a través del PIT
; Entrada : CX:frecuencia
; Salida : Ninguna
; Destruye : Ninguna
.IF CX == 0
CALL SpkOff
.ELSE
CALL Frec_Periodo
CALL PIT_REG_COMM
CALL SpkOn
.ENDIF
RET
Sonido ENDP
ResetNota PROC
; Propósito: Recogemos los valores de la nueva nota en MNota
; entrada : KeyTable
; salida : KeyTable
; Destruye : AX
PUSH AX
PUSH BX
MOV BX, WORD PTR CS:[vwActual]
MOV AX, WORD PTR CS:[Notas1+BX]
MOV WORD PTR CS:[MNota.Frecuencia], AX
MOV AX, WORD PTR CS:[Notas1+BX+2]
MOV BYTE PTR CS:[MNota.Duracion], AL
POP BX
POP AX
RET
ResetNota ENDP
; ****************
SaveOldInt1Ch PROC NEAR
; Propósito: Guarda la dirección de la antigua ISR de Int 1Ch
; entrada : OldInt1Ch
; salida : Ninguna
; Destruye : AX
MOV AX, 351Ch ; Obtiene la dirección de la
INT 21h ; interrupción 1Ch
MOV WORD PTR OldInt1Ch[2],ES ; Guarda segmento
MOV WORD PTR OldInt1Ch[0],BX ; y dirección
RET
SaveOldInt1Ch ENDP
RestoreOldInt1Ch PROC NEAR
; Propósito: Restaura la dirección de la antigua ISR de Int 1Ch
; entrada : OldInt1Ch
; salida : Ninguna
; Destruye : AX, DX
PUSH DS ; Guardamos DS
LDS DX, OldInt1Ch ; Carga la dirección original
MOV AX, 251Ch ; Lo restaura a la tabla de vectores
INT 21h
POP DS
RET
RestoreOldInt1Ch ENDP
SetNewInt1Ch PROC NEAR
; Propósito: Establece la dirección de la nueva ISR para Int 1Ch
; entrada : NuevaInt1Ch
; salida : Ninguna
; Destruye : AX, DX
MOV DX, OFFSET NuevaInt1Ch ; Carga la dirección de nueva rutina
MOV AX, 251Ch ; Establece la nueva interrupción
INT 21h
RET
SetNewInt1Ch ENDP
NuevaInt1Ch PROC FAR
; Propósito: Nueva ISR para la INT 1Ch, crea un retardo
; entrada : Ninguna
; salida : Ninguna
; Destruye : Ninguna
PUSHF
PUSH AX
PUSH BX
PUSH CX
PUSH DX
PUSH DS
PUSH ES
.IF BYTE PTR CS:[vbEjecutando] == 1
; Si está sonando la nota
DEC BYTE PTR CS:[MNota.Duracion] ; Decrementamos la duración
.IF BYTE PTR CS:[MNota.Duracion] == 0
; Si ya ha terminado la duración de la nota
ADD WORD PTR CS:[vwActual], 4 ; Incrementamos puntero a notas
CALL ResetNota ; Recogemos nueva nota
.IF WORD PTR CS:[vwActual] >= cnNotas*4
; Si ya hemos terminado todas las notas
MOV BYTE PTR CS:[vbEjecutando], 0 ; Marcamos que no tocamos
MOV WORD PTR CS:[vwActual], 0 ; Reseteamos el puntero a notas
CALL TurnOffSpk
.ELSE
; Si todavía no hemos terminado todas las notas
MOV CX, WORD PTR CS:[MNota.Frecuencia]
CALL Sonido
.ENDIF
.ENDIF
.ELSE
; Si no está sonando ninguna nota
.IF BYTE PTR CS:[vbEjecutar] == 1
; Si debemos ejecutar las notas
.IF WORD PTR CS:[vwActual] == 0
; Si estamos al inicio, reseteamos
CALL ResetNota
.ENDIF
.IF BYTE PTR CS:[MNota.Duracion] != 0
; Si todavía dura la nota, la tocamos
MOV BYTE PTR CS:[vbEjecutando], 1 ; Marcamos para tocar
MOV CX, WORD PTR CS:[MNota.Frecuencia]
CALL Sonido
.ENDIF
.ENDIF
.ENDIF
CMP BYTE PTR CS:[TimePlayer], 0
JZ $_Next1
DEC BYTE PTR CS:[TimePlayer] ; Decrementamos el contador de pulsos
$_Next1:
CMP BYTE PTR CS:[TimeEnemigos], 0
JZ $_Next2
DEC BYTE PTR CS:[TimeEnemigos] ; Decrementamos el contador de pulsos
$_Next2:
CMP BYTE PTR CS:[TimePDisp], 0
JZ $_Next3
DEC BYTE PTR CS:[TimePDisp] ; Decrementamos el contador de pulsos
$_Next3:
CMP BYTE PTR CS:[TimeEDisp], 0
JZ $_Next4
DEC BYTE PTR CS:[TimeEDisp] ; Decrementamos el contador de pulsos
$_Next4:
CMP BYTE PTR CS:[TimeESgteDisp], 0
JZ $_GT_Next5
DEC BYTE PTR CS:[TimeESgteDisp] ; Retardo para el siguiente disparo de los enemigos
$_GT_Next5:
POP ES
POP DS
POP DX
POP CX
POP BX
POP AX
POPF
JMP [CS:OldInt1Ch] ; Saltamos a la vieja rutina
NuevaInt1Ch ENDP
TopInvader1 DW 0c00h,1e00h,2d00h,3f00h,1200h,2100h,1200h
; 0c00 0000110000000000
; 1e00 0001111000000000
; 2d00 0010110100000000
; 3f00 0011111100000000
; 1200 0001001000000000
; 2100 0010000100000000
; 1200 0001001000000000
TopInvader2 DW 0c00h,1e00h,2d00h,3f00h,1200h,2100h,4080h
; 0c00 0000110000000000
; 1e00 0001111000000000
; 2d00 0010110100000000
; 3f00 0011111100000000
; 1200 0001001000000000
; 2100 0010000100000000
; 4080 0100000010000000
MiddleInvader1 DW 2100h,9e40h,0ad40h,7f80h,3f00h,2100h,4080h
MiddleInvader2 DW 2100h,1e00h,2d00h,7f80h,0bf40h,0a140h,1200h
BottomInvader1 DW 01e00h,7f80h,0ccc0h,0ffc0h,2100h,4c80h,2100h
BottomInvader2 DW 01e00h,7f80h,0ccc0h,0ffc0h,2100h,4c80h,8040h
PlayersShip DW 0400h,0e00h,7fc0h,0ffe0h,0ffe0h,0ffe0h,0000h
; 0400 0000010000000000
; 0e00 0000111000000000
; 7fc0 0111111111000000
; ffe0 1111111111100000
; ffe0 1111111111100000
; ffe0 1111111111100000
; 0000 0000000000000000
TwistedMissile1 DW 0000h,0000h,0000h,0800h,0400h,0800h,0400h
; 0000 0000000000000000
; 0000 0000000000000000
; 0000 0000000000000000
; 0800 0000100000000000
; 0400 0000010000000000
; 0800 0000100000000000
; 0400 0000010000000000
TwistedMissile2 DW 0000h,0000h,0000h,0400h,0800h,0400h,0800h
StraightMissile DW 0000h,0000h,0000h,0400h,0400h,0400h,0400h
MEnemigos TEnemigos cNumEnemigos DUP (<>) ; Enemigos sin inicializar
MCabEDisp TCabEDisp cNumDispEne DUP (<>) ; Disparos de los enemigos
; align 16
; db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ;16
MEDisparos TEDisparos cNumDispEne DUP (<>) ; Disparos de los enemigos
Player TPlayer <> ; Jugador sin inicializar
MPDisparos TPDisparos <> ; Disparos de los enemigos
vbSpeaker DB ?
vbEjecutar DB 1 ; Lo definimos indicando que suenen las notas
vbEjecutando DB 0
vwActual DW 0
Notas1 DW 262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 294, 3, 0, 8 ; 7
DW 262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 0, 8 ; 6
DW 262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 294, 3, 0, 8 ; 7
DW 330, 3, 349, 3, 330, 3, 262, 3, 262, 3 ; 5
MNota TNota <>
msg1 DB "Error al REDIMENSIONAR memoria$"
msg2 DB "Error al RESERVAR memoria$"
msg3 DB "Error al LIBERAR memoria$"
msgAOE DB "(c)Abre los ojos al ensamblador", 13, 10
DB "Ejemplo de space invaders$"
msgExito DB "Enhorabuena, has salvado al planeta Tierra$"
msgFracaso DB "Por tu impericia la Tierra ha sido destruida$"
msgBlanco DB " $"
NumEnemigos DB ? ; Número de enemigos que quedan
OldInt9h DD ? ; Dirección antigua de Int 9h
OldInt1Ch DD ? ; Dirección antigua de Int 1Ch
ScrSeg DW ? ; Segmento del búfer de pantalla
DirEnemigos DW ? ; Dirección del mvto de los enemigos
DesplDefFig DW ? ; Para pintar el mvto de la figura
TimePlayer DB ? ; Retardo para el mvto del jugador
TimeEnemigos DB ? ; Retardo para el mvto de los enemigos
TimePDisp DB ? ; Retardo para el mvto disparo jugador
TimeEDisp DB ? ; Retardo para el mvto disparo enemigos
TimeESgteDisp DB ? ; Retardo para el siguiente disparo enemigos
vNextTEnemigos DB ? ; Siguiente retardo de los enemigos
TicksReloj DD ? ; Ticks de reloj
ActFrecBomb DB ? ; Frecuencia actual disparos enemigos (cambia)
NumEColumn DW ? ; Número de columnas de enemigos que quedan
ChgTEnemigos DB ? ; Cada cuantos enemigos muertos incr su velocidad
vSoyInmune DB cSoyInmune ; Ser o no ser inmune
; Datos modificados en cada nivel
vYESup DW ? ; X-inicial-superior de los enemigos
; Datos que modifica la nueva ISR del teclado
PlayerLeft DB 0
PlayerRight DB 0
PlayerFire DB 0
Escape DB 0
codigo ENDS
END Entrada
00100011 11000111 10010111 11000000 10110000 00001101
-------- -------- -------- -------- -------- --------
Byte I Byte a Byte b Byte c Byte d Byte F
// Pasar a binario.
foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
{
richTextBox1.Text += leer.ToString();
} @Echo OFF
title Arduino CMD y puerto serie
CHCP 1252 >Nul
MODE.com COM4 BAUD=115200 PARITY=n DATA=8 STOP=1
:Menu
CLS
echo.
echo.
echo. 1.- Luz ON
echo.
echo. 2.- Luz OFF
echo.
echo. 3.- Salir
echo.
echo.
echo.
CHOICE.exe /C "123" /M " Escoge una opción "
echo.
echo.
echo.
If %ErrorLevel% EQU 1 (
copy puerto_Luz_ON.txt COM1:
echo Puerto COM1: B
timeout 5 >nul
goto Menu
)
If %ErrorLevel% EQU 2 (
copy puerto_Luz_OFF.txt COM1:
echo Puerto COM1: X72
timeout 5 >nul
goto Menu
)
Pause
Exit /BCitarUnidad F:
Etiqueta de volumen : 58 Fotos 2020 Tamaño total de la unidad: 4,26 GB.
Unidad G:
Etiqueta de volumen : Visual Tamaño total de la unidad: 3,09 GB.
using System;
using System.IO;
namespace Informacion_lector_Consola_01
{
class Program
{
static void Main(string[] args)
{
#region Configuración ventana.
// Título de la ventana.
Console.Title = "Información lector.";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(80, 35);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.White;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Black;
// Limpiar pantalla y dejarlo todo en color de fondo.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
#endregion
DriveInfo[] allDrives = DriveInfo.GetDrives();
foreach (DriveInfo d in allDrives)
{
Console.WriteLine("Unidad {0}", d.Name);
Console.WriteLine(" Tipo de unidad: {0}", d.DriveType);
if (d.IsReady == true)
{
Console.WriteLine(" Etiqueta de volumen : {0}", d.VolumeLabel);
Console.WriteLine(" Sistema de archivo: {0}", d.DriveFormat);
Console.WriteLine(
" Espacio disponible para el usuario actual:{0, 15} bytes",
d.AvailableFreeSpace);
Console.WriteLine(
" Espacio total disponible: {0, 15} bytes",
d.TotalFreeSpace);
Console.WriteLine(
" Tamaño total de la unidad: {0, 15} bytes ",
d.TotalSize);
}
}
// Pulse cualquier tecla para continuar.
Console.ReadKey();
}
}
}
# Para comprobar los puertos series disponibles en el sistema:
[System.IO.Ports.SerialPort]::getportnames()
# O bien de una manera más exhaustiva:
Get-WMIObject Win32_SerialPort
# Establecer los parámetros básicos de conexión. Una tipica conexión 9600 bps, 8N1 sin control de flujo sería la siguiente:
$puertoCOM = "COM1" # El puerto serie que se quiere emplear
$bps = 2400 # La tasa de baudios por segundo del puerto. Típicos valores entre 1200 (o incluso menos) y 115200 (o incluso más)
$paridad = [System.IO.Ports.Parity]::None # Paridad de datos. Puede ser Even (par), Odd (impar) o None (sin paridad)
$dataBits = 8 # Bits de datos. Puede ser 7 u 8
$stopBits = [System.IO.Ports.StopBits]::one # Bits de parada. Puede ser one (1), onepointfive (1.5) o two (dos)
$puerto = New-Object System.IO.Ports.SerialPort $puertoCOM,$bps,$paridad,$dataBits,$stopBits # Crea la nueva instancia
# Se pueden establecer otros parámetros, como la activación del control del flujo por RTS/CTS , DTR/DSR, Handshake, fijar el tamaño de los buffers de lectura y escritura o establecer los timeouts de lectura. Todos estos parámetros, así como el estado general del resto, se pueden consultar llamando al objeto:
$puerto
$puerto.ReadTimeout = 500 # Establece un timeout de lectura de 500 mseg
$puerto.WriteTimeout = 500 # Establece un timeout de escritura de 250 mseg
# Abre el puerto
$puerto.Open()
# Lectura del puerto
$mensaje=$puerto.ReadLine()
# Escritura del puerto
$mensaje="B"
$puerto.WriteLine($mensaje)
# Cierra el puerto
$puerto.Close() private static void GetMyCPUInfo(string hwclass, string syntax)
{
ManagementObjectSearcher mos = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM " + hwclass);
foreach (ManagementObject mj in mos.Get())
{
Console.WriteLine(Convert.ToString(mj[syntax]));
}
}GetMyCPUInfo("Win32_CDROMDrive", "Id");comboBox_Unidad.Items.Add(datos);
using System;
namespace Delimitador_consola_01
{
class Program
{
static void Main(string[] args)
{
string phrase = "#2000,1400,230,45.0,55.0,8.6";
string[] words = phrase.Split('#', ',');
foreach (var word in words)
{
Console.WriteLine($"<{word}>");
}
// Pulse cualquier tecla para salir.
Console.ReadKey();
}
}
}using System;
using System.Management;
namespace CPU_GPU_Hardware_informacion_consola_01
{
class Program
{
static void Main(string[] args)
{
// Título de la ventana.
Console.Title = "Título de la ventana.";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(120, 63);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Gray;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Black;
// Limpiar pantalla y dejarlo todo gris.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
// Nombre del procesador.
GetMyCPUInfo("Win32_Processor", "Name");
// CD ROM.
GetMyCPUInfo("Win32_CDROMDrive", "Name");
Console.Write("Medio cargado: (Disco en el lector:) ");
GetMyCPUInfo("Win32_CDROMDrive", "MediaLoaded");
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("FIN DEL PROGRAMA.");
// Pulse cualquier tecla para salir.
Console.ReadKey();
}
private static void GetMyCPUInfo(string hwclass, string syntax)
{
ManagementObjectSearcher mos = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM " + hwclass);
foreach (ManagementObject mj in mos.Get())
{
Console.WriteLine(Convert.ToString(mj[syntax]));
}
}
}
}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;
namespace _74xx595_Vumetro_01_Net5._0
{
public partial class Form1 : Form
{
int valorADC = 1000;
public Form1()
{
InitializeComponent();
}
private void trackBar1_Scroll(object sender, EventArgs e)
{
// Variar valor con el tarackBar.
valorADC = int.Parse("" + trackBar1.Value);
this.Text = valorADC.ToString();
switch (valorADC)
{
case 1000:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.Red;
panel4.BackColor = Color.Red;
panel5.BackColor = Color.Red;
panel6.BackColor = Color.Red;
panel7.BackColor = Color.Red;
panel8.BackColor = Color.Red;
break;
case 900:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.Red;
panel4.BackColor = Color.Red;
panel5.BackColor = Color.Red;
panel6.BackColor = Color.Red;
panel7.BackColor = Color.Red;
panel8.BackColor = Color.DarkRed;
break;
case 800:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.Red;
panel4.BackColor = Color.Red;
panel5.BackColor = Color.Red;
panel6.BackColor = Color.Red;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
case 700:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.Red;
panel4.BackColor = Color.Red;
panel5.BackColor = Color.Red;
panel6.BackColor = Color.DarkRed;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
case 600:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.Red;
panel4.BackColor = Color.Red;
panel5.BackColor = Color.DarkRed;
panel6.BackColor = Color.DarkRed;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
case 500:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.Red;
panel4.BackColor = Color.DarkRed;
panel5.BackColor = Color.DarkRed;
panel6.BackColor = Color.DarkRed;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
case 400:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.Red;
panel3.BackColor = Color.DarkRed;
panel4.BackColor = Color.DarkRed;
panel5.BackColor = Color.DarkRed;
panel6.BackColor = Color.DarkRed;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
case 300:
panel1.BackColor = Color.Red;
panel2.BackColor = Color.DarkRed;
panel3.BackColor = Color.DarkRed;
panel4.BackColor = Color.DarkRed;
panel5.BackColor = Color.DarkRed;
panel6.BackColor = Color.DarkRed;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
case 200:
panel1.BackColor = Color.DarkRed;
panel2.BackColor = Color.DarkRed;
panel3.BackColor = Color.DarkRed;
panel4.BackColor = Color.DarkRed;
panel5.BackColor = Color.DarkRed;
panel6.BackColor = Color.DarkRed;
panel7.BackColor = Color.DarkRed;
panel8.BackColor = Color.DarkRed;
break;
default:
this.Text = "Fuera de rango.";
break;
}
}
}
}
50, 80/*
Te explico la formula
float fDeltaAngulo = (((nRPM * 360) / (60 * 1000)) * timer.Interval) * ((float)trackBar_Velocidad_motor.Value / (float)trackBar_Velocidad_motor.Maximun)
1. (nRPM * 360) -> Grados por minuto.
2. (60 * 1000) -> Milisegundos por minuto.
3. ((nRPM * 360) / (60 * 1000)) -> Grados por milisegundo.
4. (((nRPM * 360) / (60 * 1000)) * timer.Interval) -> Grados por tick del timer.
5. ((float)trackBar_Velocidad_motor.Value / (float)trackBar_Velocidad_motor.Maximun) -> Porcentaje de la velocidad.
6. (((nRPM * 360) / (60 * 1000)) * timer.Interval) * ((float)trackBar_Velocidad_motor.Value / (float)trackBar_Velocidad_motor.Maximun) -> Calcula los grados por tick del timer aplicando un porcentaje.
Según esta formula, si el trackbar esta en 0, grados por tick * 0 = 0 (esta parado), si el trackbar esta al maximo, grados por tick * 1 = grados por tick (el angulo aumenta al máximo).
*/
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Lavadora_05
{
public partial class Form1 : Form
{
// Variables.
private Pen lápiz2;
private Pen lápiz3;
private Pen lápiz4;
private float angulo;
private SolidBrush agua;
private GraphicsPath m_lavadora;
private GraphicsPath m_agua;
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
Text = "Simulador lavadora";
pictureBox1.Size = new Size(300, 300);
pictureBox1.BackColor = Color.LightGray;
lápiz2 = new Pen(Color.DarkGray, 10);
lápiz2.StartCap = LineCap.ArrowAnchor;
lápiz2.EndCap = LineCap.RoundAnchor;
lápiz3 = new Pen(Color.Black, 5);
lápiz4 = new Pen(Color.Gray, 10);
angulo = 0;
agua = new SolidBrush(Color.FromArgb(200, 0, 155, 219)); // Transparencia del agua 200.
trackBar_Nivel_de_agua.Value = -90; // Para que empiece sin agua.
}
// Dibuja y colorea.
private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
e.Graphics.DrawRectangle(lápiz3, 10, 10, pictureBox1.ClientSize.Width - 20, pictureBox1.ClientSize.Height - 20);
e.Graphics.DrawEllipse(lápiz4, 10, 10, pictureBox1.ClientSize.Height - 20, pictureBox1.ClientSize.Height - 20);
e.Graphics.TranslateTransform(pictureBox1.ClientSize.Width / 2, pictureBox1.ClientSize.Height / 2);
e.Graphics.RotateTransform(angulo);
e.Graphics.TranslateTransform(-pictureBox1.ClientSize.Width / 2, -pictureBox1.ClientSize.Height / 2);
//e.Graphics.DrawLine(lápiz2, 20, pictureBox1.ClientSize.Height / 2, pictureBox1.ClientSize.Width / 2, pictureBox1.ClientSize.Height / 2);
e.Graphics.DrawPath(lápiz2, m_lavadora);
e.Graphics.ResetTransform();
e.Graphics.FillPath(agua, m_agua);
}
// Refresca el valor actual.
private void trackBar_Giro_del_motor_ValueChanged(object sender, EventArgs e)
{
angulo = (float)trackBar_Giro_del_motor.Value;
pictureBox1.Refresh();
}
// Cambia el tamaño del control.
private void pictureBox1_Resize(object sender, EventArgs e)
{
int ancho = pictureBox1.ClientSize.Width;
int alto = pictureBox1.ClientSize.Height;
m_lavadora = new GraphicsPath();
m_lavadora.AddEllipse(20, 20, ancho - 40, alto - 40);
m_lavadora.CloseFigure();
m_lavadora.AddLine(20, (alto / 2), ancho - 20, (alto / 2));
m_lavadora.CloseFigure();
m_lavadora.AddLine(ancho / 2, 20, ancho / 2, alto - 20);
m_lavadora.CloseFigure();
m_agua = new GraphicsPath();
m_agua.AddArc(20, 20, ancho - 40, alto - 40, trackBar_Nivel_de_agua.Value, 180 - 2 * trackBar_Nivel_de_agua.Value);
m_agua.CloseFigure();
}
private void trackBar_Nivel_de_agua_ValueChanged(object sender, EventArgs e)
{
m_agua = new GraphicsPath();
m_agua.AddArc(20, 20, pictureBox1.ClientSize.Width - 40, pictureBox1.ClientSize.Height - 40, -trackBar_Nivel_de_agua.Value, 180 - 2 * -trackBar_Nivel_de_agua.Value);
m_agua.CloseFigure();
pictureBox1.Refresh();
}
private void timer1_Tick(object sender, EventArgs e)
{
//60 vueltas por minuto
float nRPM = 60;
float fDeltaAngulo = (((nRPM * 360) / (60 * 1000)) * (float)timer1.Interval) * ((float)trackBar_Velocidad_motor.Value / (float)trackBar_Velocidad_motor.Maximum);
float track = (float)trackBar_Velocidad_motor.Value;
angulo += fDeltaAngulo;
label_angulo.Text = "angulo " + angulo.ToString();
label_fDeltaAngulo.Text = "fDeltaAngulo " + fDeltaAngulo.ToString();
pictureBox1.Refresh();
}
private void button_Empezar_Click(object sender, EventArgs e)
{
timer1.Start();
//timer1.Enabled = true; // También válido.
}
private void button_parar_Click(object sender, EventArgs e)
{
timer1.Stop();
//timer1.Enabled = false; // También válido.
}
}
}using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Lavadora_07
{
public partial class Form1 : Form
{
// Utilizaremos un string-builder como búfer auxiliar.
// La trama llegará fragmentada.
StringBuilder sb;
// Nuestro delegado recibe como argumento el string con la trama.
readonly Action<string> NuevaTrama;
// Variables.
private Pen lápiz2;
private Pen lápiz3;
private Pen lápiz4;
private float angulo;
private SolidBrush agua;
private GraphicsPath m_lavadora;
private GraphicsPath m_agua;
// Variables sustituto del trackBar.
private int trackBar_Nivel_de_agua = 0;
private int trackBar_Velocidad_motor = 0;
public Form1()
{
InitializeComponent();
sb = new StringBuilder();
NuevaTrama = Actualizar;
}
private void Form1_Load(object sender, EventArgs e)
{
// Añado los puertos disponible en el PC con SerialPort.GetPortNames() al comboBox_Puerto.
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 comboBox_Puerto.
comboBox_Puerto.DataSource = SerialPort.GetPortNames();
// // Añade puertos disponibles físicos y virtuales.
serialPort1.PortName = comboBox_Puerto.Text.ToString();
serialPort1.DataReceived += new SerialDataReceivedEventHandler(serialPort1_DataReceived);
// Dibujo tambor lavadora.
pictureBox1.Size = new Size(300, 300);
pictureBox1.BackColor = Color.LightGray;
lápiz2 = new Pen(Color.DarkGray, 10);
lápiz2.StartCap = LineCap.ArrowAnchor;
lápiz2.EndCap = LineCap.RoundAnchor;
lápiz3 = new Pen(Color.Black, 5);
lápiz4 = new Pen(Color.Gray, 10);
angulo = 0;
agua = new SolidBrush(Color.FromArgb(200, 0, 155, 219)); // Transparencia del agua 200.
trackBar_Nivel_de_agua = -90; // Para que empiece sin agua.
}
// 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.
}
// Dibuja y colorea.
private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
e.Graphics.DrawRectangle(lápiz3, 10, 10, pictureBox1.ClientSize.Width - 20, pictureBox1.ClientSize.Height - 20);
e.Graphics.DrawEllipse(lápiz4, 10, 10, pictureBox1.ClientSize.Height - 20, pictureBox1.ClientSize.Height - 20);
e.Graphics.TranslateTransform(pictureBox1.ClientSize.Width / 2, pictureBox1.ClientSize.Height / 2);
e.Graphics.RotateTransform(angulo);
e.Graphics.TranslateTransform(-pictureBox1.ClientSize.Width / 2, -pictureBox1.ClientSize.Height / 2);
//e.Graphics.DrawLine(lápiz2, 20, pictureBox1.ClientSize.Height / 2, pictureBox1.ClientSize.Width / 2, pictureBox1.ClientSize.Height / 2);
e.Graphics.DrawPath(lápiz2, m_lavadora);
e.Graphics.ResetTransform();
e.Graphics.FillPath(agua, m_agua);
}
// Cambia el tamaño del control.
private void pictureBox1_Resize(object sender, EventArgs e)
{
int ancho = pictureBox1.ClientSize.Width;
int alto = pictureBox1.ClientSize.Height;
m_lavadora = new GraphicsPath();
m_lavadora.AddEllipse(20, 20, ancho - 40, alto - 40);
m_lavadora.CloseFigure();
m_lavadora.AddLine(20, (alto / 2), ancho - 20, (alto / 2));
m_lavadora.CloseFigure();
m_lavadora.AddLine(ancho / 2, 20, ancho / 2, alto - 20);
m_lavadora.CloseFigure();
m_agua = new GraphicsPath();
m_agua.AddArc(20, 20, ancho - 40, alto - 40, trackBar_Nivel_de_agua, 180 - 2 * trackBar_Nivel_de_agua);
m_agua.CloseFigure();
}
// Conectar comunicación con el puerto serie.
private void button_Conectar_Click(object sender, EventArgs e)
{
try
{
serialPort1.PortName = comboBox_Puerto.Text.ToString(); // Puerto seleccionado previamente.
serialPort1.BaudRate = Convert.ToInt32(comboBox_Baudios.Text); // Baudios.
serialPort1.Open(); // Abrir puerto.
comboBox_Puerto.Enabled = false;
comboBox_Baudios.Enabled = false;
button_Conectar.Enabled = false;
button_Desconectar.Enabled = true;
}
catch
{
MessageBox.Show("El puerto no existe.", "Aviso:",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
// Desconectar comunicación con el puerto serie.
private void button_Desconectar_Click(object sender, EventArgs e)
{
try
{
serialPort1.Close(); // Cerrar puerto.
comboBox_Puerto.Enabled = true;
comboBox_Baudios.Enabled = true;
button_Conectar.Enabled = true;
button_Desconectar.Enabled = false;
}
catch (Exception error)
{
MessageBox.Show(error.Message, "Aviso:",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
// Al cerrar el formulario, antes cierra el puerto si está abierto.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
try
{
serialPort1.Close(); // Cerrar puerto.
}
catch (Exception error)
{
MessageBox.Show(error.Message, "Aviso:",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
// Recibe datos por el puerto serie.
private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
// Caracter/es disponible/s desde la última vez.
string recibidos = serialPort1.ReadExisting();
// analizamos cada caracter recibido
foreach (char item in recibidos)
{
switch (item)
{
// Ignoramos el \u000D
case '\r':
break;
// Aquí detectamos el final de la trama \u000A
case '\n':
// y la enviamos al control.
Invoke(NuevaTrama, sb.ToString());
// Luego limpiamos el búfer.
sb.Clear();
break;
// Cualquier otro caracter recibido, lo agregamos al búfer.
default:
sb.Append(item);
break;
}
}
}
private void Actualizar(string trama)
{
// Delimitador. Ignoramos las comas.
string[] datosArray = trama.Split(',');
// Compara si dos datos del array es igual a la cantidad total que en este
// caso son 2. Si es igual a 2, entonces ejecuta todo el código dentro del if.
if (datosArray.Length == 2)
{
// Mostrar datos.
label_Entrada_analogica_A1.Text = "Entrada Analógica A1: " + datosArray[0];
label_Entrada_analogica_A2.Text = "Entrada Analógica A2: " + datosArray[1];
}
}
private void trackBar_Nivel_de_agua_ValueChanged(object sender, EventArgs e)
{
m_agua = new GraphicsPath();
m_agua.AddArc(20, 20, pictureBox1.ClientSize.Width - 40, pictureBox1.ClientSize.Height - 40, -trackBar_Nivel_de_agua, 180 - 2 * -trackBar_Nivel_de_agua);
m_agua.CloseFigure();
pictureBox1.Refresh();
}
}
}using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Threading;
namespace Lectura_seis_potenciometros_Arduino_consola_01
{
class Program
{
// Utilizaremos un string "Recibidos" como buffer de recepción.
public static string Recibidos;
public static bool _continua;
public static SerialPort Puerto_serie;
static void Main(string[] args)
{
string COM = "";
StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
Thread readThread = new Thread(Leer);
// Título de la ventana.
Console.Title = "Lectura 6 potenciómetros desde Arduino";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(45, 20);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Gray;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Black;
// Limpiar pantalla y dejarlo todo gris.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
// Crear un nuevo objeto SerialPort con la configuración predeterminada.
Puerto_serie = new SerialPort();
// Obtenga una lista de nombres de puertos serie.
string[] puertos = SerialPort.GetPortNames();
Console.WriteLine("Se encontraron los siguientes puertos series:");
// Muestre el nombre de cada puerto en la consola.
foreach (string puerto in puertos)
{
Console.WriteLine(puerto);
}
// 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(); // Limpiar pantalla.
Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
// Configuración del puerto serie.
Puerto_serie.BaudRate = 115200;
Puerto_serie.Parity = Parity.None;
Puerto_serie.StopBits = StopBits.One;
Puerto_serie.DataBits = 8;
Puerto_serie.Handshake = Handshake.None;
Puerto_serie.RtsEnable = true;
// Establecer los tiempos de espera de lectura / escritura.
//Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
//Puerto_serie.WriteTimeout = 500; // 500
// Comprueba si puede abrir el puerto serie.
try
{
Puerto_serie.Open(); // Abrir el puerto serie.
}
// En caso que diera algún error como que no encuentra el puerto seleccionado
// muestra una excepción.
catch (IOException)
{
Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
Console.CursorVisible = false;
Console.SetCursorPosition(16, 6);
Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
o no lo encuentra.");
Console.ReadKey(); // Pulse cualquier tecla.
Environment.Exit(1); // Salir de la aplicación.
}
_continua = true;
readThread.Start();
// Cursos invisible.
Console.CursorVisible = false;
// Mostrar dibujo en pantalla.
Console.SetCursorPosition(3, 3);
Console.Write("Potenciómetro A0: ");
Console.SetCursorPosition(3, 5);
Console.Write("Potenciómetro A1: ");
Console.SetCursorPosition(3, 7);
Console.Write("Potenciómetro A2: ");
Console.SetCursorPosition(3, 9);
Console.Write("Potenciómetro A3: ");
Console.SetCursorPosition(3, 11);
Console.Write("Potenciómetro A4: ");
Console.SetCursorPosition(3, 13);
Console.Write("Potenciómetro A5: ");
// Posición para empezar a dibijar las ─.
Console.SetCursorPosition(0, 15);
// Generar línea.
for (int i = 0; i <= 44; i++)
{
Console.Write("─"); // ASCII: Alt + 196: ─
}
Console.SetCursorPosition(17, 17);
Console.Write("Puerto: COM" + COM);
// Bloquea el subproceso.
readThread.Join();
// Cierra el puerto serie.
Puerto_serie.Close();
}
// Lee mensaje recibido.
public static void Leer()
{
// Si _continue es true se ejecuta todas las instrucciones dentro de while.
while (_continua) // _continua
{
try
{
// Almacena en la variable mensaje cualquier caracter o mensaje recibido.
Recibidos = Puerto_serie.ReadLine();
// Muestra en pantalla mensaje recibido.
Console.WriteLine(Recibidos);
string[] datosArray = Recibidos.Split(',');
if (datosArray.Length == 6) // 6 potenciómetros.
{
Console.SetCursorPosition(20, 3);
Console.Write(datosArray[0]); // Entrada analógica A0.
Console.SetCursorPosition(20, 5);
Console.Write(datosArray[1]); // Entrada analógica A1.
Console.SetCursorPosition(20, 7);
Console.Write(datosArray[2]); // Entrada analógica A2.
Console.SetCursorPosition(20, 9);
Console.Write(datosArray[3]); // Entrada analógica A3.
Console.SetCursorPosition(20, 11);
Console.Write(datosArray[4]); // Entrada analógica A4.
Console.SetCursorPosition(20, 13);
Console.Write(datosArray[5]); // Entrada analógica A5.
}
// Limpiar buffer.
Recibidos = "";
}
catch (TimeoutException)
{
Console.WriteLine("ERROR");
}
}
}
}
}int pinA0 = A0;
int pinA1 = A1;
int pinA2 = A2;
int pinA3 = A3;
int pinA4 = A4;
int pinA5 = A5;
int valorPotA0 = 0;
int valorPotA1 = 0;
int valorPotA2 = 0;
int valorPotA3 = 0;
int valorPotA4 = 0;
int valorPotA5 = 0;
void setup()
{
Serial.begin(115200);
pinMode(pinA0, INPUT);
pinMode(pinA1, INPUT);
pinMode(pinA2, INPUT);
pinMode(pinA3, INPUT);
pinMode(pinA4, INPUT);
pinMode(pinA5, INPUT);
}
void loop()
{
valorPotA0 = analogRead(pinA0);
valorPotA1 = analogRead(pinA1);
valorPotA2 = analogRead(pinA2);
valorPotA3 = analogRead(pinA3);
valorPotA4 = analogRead(pinA4);
valorPotA5 = analogRead(pinA5);
Serial.print(valorPotA0);
Serial.print(",");
Serial.print(valorPotA1);
Serial.print(",");
Serial.print(valorPotA2);
Serial.print(",");
Serial.print(valorPotA3);
Serial.print(",");
Serial.print(valorPotA4);
Serial.print(",");
Serial.println(valorPotA5);
delay(100); // 100 mili segundos o 0.1 segundos..
}using System;
using System.IO;
using System.IO.Ports;
using System.Threading;
namespace Introducir_datos_puerto_serie_consola_02
{
class Program
{
static bool _continua;
// Cree un nuevo objeto SerialPort con la configuración predeterminada.
static readonly SerialPort Puerto_serie = new SerialPort("COM2");
static void Main(string[] args)
{
string nombre;
string mensaje;
StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
Thread readThread = new Thread(Leer);
// Título de la ventana.
Console.Title = "Enviar datos al puerto serie";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(70, 25);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Blue;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Yellow;
// Limpiar pantalla y dejarlo todo gris.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
Puerto_serie.BaudRate = 115200;
Puerto_serie.Parity = Parity.None;
Puerto_serie.StopBits = StopBits.One;
Puerto_serie.DataBits = 8;
Puerto_serie.Handshake = Handshake.None;
Puerto_serie.RtsEnable = true;
// Establecer los tiempos de espera de lectura / escritura.
Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
Puerto_serie.WriteTimeout = 500; // 500
// Abrir puerto serie.
Puerto_serie.Open();
_continua = true;
readThread.Start();
// Mostrar texto Nombre y se
Console.Write("Nombre: ");
// guarda en la variable nombre.
nombre = Console.ReadLine();
Console.WriteLine("Escriba salir para salir");
while (_continua)
{
// Cualquier caracter recibido se guarda en la variable mensaje.
mensaje = Console.ReadLine();
// Compara salir con el mensaje salir si lo haz escrito igual.
// ¿Escribiste la palabra salir?
if (comparaString.Equals("salir", mensaje))
{
// Sí. Entonces, pone esta variable _continue en false.
_continua = false;
}
// No. Entonces, envía por el puerto serie tu nick
// y mensaje que haz escrito.
else
{
Puerto_serie.WriteLine(
String.Format("<{0}>: {1}", nombre, mensaje));
}
}
// Bloquea el subproceso.
readThread.Join();
// Cierra el puerto serie.
Puerto_serie.Close();
}
// Lee mensaje recibido.
public static void Leer()
{
// Si _continue es true se ejecuta todas las instrucciones dentro de while.
while (_continua)
{
try
{
// Almacena en la variable mensaje cualquier caracter o mensaje recibido.
string mensaje = Puerto_serie.ReadLine();
// Muestra en pantalla mensaje recibido.
Console.WriteLine(mensaje);
}
catch (TimeoutException) { }
}
}
}
}
using System;
using System.IO.Ports;
using System.Threading;
namespace Introducir_datos_puerto_serie_consola_02
{
class Program
{
static bool _continua;
// Cree un nuevo objeto SerialPort con la configuración predeterminada.
static SerialPort Puerto_serie = new SerialPort("COM2");
static void Main(string[] args)
{
string nombre;
string mensaje;
StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
Thread readThread = new Thread(Leer);
// Título de la ventana.
Console.Title = "Enviar datos al puerto serie";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(70, 25);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Blue;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Yellow;
// Limpiar pantalla y dejarlo todo gris.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
Puerto_serie.BaudRate = 115200;
Puerto_serie.Parity = Parity.None;
Puerto_serie.StopBits = StopBits.One;
Puerto_serie.DataBits = 8;
Puerto_serie.Handshake = Handshake.None;
Puerto_serie.RtsEnable = true;
// Establecer los tiempos de espera de lectura / escritura.
Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
Puerto_serie.WriteTimeout = 500; // 500
// Abrir puerto serie.
Puerto_serie.Open();
_continua = true;
readThread.Start();
// Mostrar texto Nombre y se
Console.Write("Nombre: ");
// guarda en la variable nombre.
nombre = Console.ReadLine();
Console.WriteLine("Escriba salir para salir");
while (_continua)
{
// Cualquier caracter recibido se guarda en la variable mensaje.
mensaje = Console.ReadLine();
// Compara salir con el mensaje salir si lo haz escrito igual.
// ¿Escribiste la palabra salir?
if (comparaString.Equals("salir", mensaje))
{
// Sí. Entonces, pone esta variable _continue en false.
_continua = false;
}
// No. Entonces, envía por el puerto serie tu nick
// y mensaje que haz escrito.
else
{
Puerto_serie.WriteLine(
String.Format("<{0}>: {1}", nombre, mensaje));
}
}
// Bloquea el subproceso.
readThread.Join();
// Cierra el puerto serie.
Puerto_serie.Close();
}
// Lee mensaje recibido.
public static void Leer()
{
// Si _continue es true se ejecuta todas las instrucciones dentro de while.
while (_continua)
{
try
{
// Almacena en la variable mensaje cualquier caracter o mensaje recibido.
string mensaje = Puerto_serie.ReadLine();
// Muestra en pantalla mensaje recibido.
Console.WriteLine(mensaje);
}
catch (TimeoutException) { }
}
}
}
}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;
namespace Movimiento_armonico_simple_01_cs
{
public partial class Form1 : Form
{
private int pt1a = 0, pt2y = 300, pt2s = -1, pt3x = 80, pt3s = 1;
private void Form1_Load(object sender, EventArgs e)
{
timer1.Start();
}
private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
int ptx, pty;
g.Clear(Color.White);
g.DrawEllipse(Pens.Black, new Rectangle(40, 40, 300, 300));
g.DrawLine(Pens.Black, 20, 40, 20, 340);
g.DrawLine(Pens.Black, 40, 360, 340, 360);
ptx = (int)(Math.Cos((double)pt1a * Math.PI / 180.0) * 150.0);
pty = (int)(Math.Sin((double)pt1a * Math.PI / 180.0) * 150.0);
g.FillEllipse(Brushes.Black, new Rectangle(190 + ptx - 5, 190 - pty - 5, 11, 11));
g.FillEllipse(Brushes.Black, new Rectangle(15, pt2y - 5, 11, 11));
g.FillEllipse(Brushes.Black, new Rectangle(pt3x - 5, 355, 11, 11));
}
private void timer1_Tick(object sender, EventArgs e)
{
pt1a += 2;
if (pt1a >= 360)
pt1a -= 360;
pt2y += 4 * pt2s;
if (pt2y <= 40 || pt2y >= 340)
pt2s = -pt2s;
pt3x += 4 * pt3s;
if (pt3x <= 40 || pt3x >= 340)
pt3s = -pt3s;
pictureBox1.Invalidate();
}
public Form1()
{
InitializeComponent();
}
}
}
using System;
using System.Windows.Forms;
namespace Regular_nivel_batería_01
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void trackBar1_Scroll(object sender, EventArgs e)
{
progressBar1.Value = (trackBar1.Value - 19) * 100 / (95 - 19);
//progressBar1.Value = trackBar1.Value;
label_Porcentaje.Text = trackBar1.Value.ToString() + " %";
}
private void Form1_Load(object sender, EventArgs e)
{
// Valores del trackBar.
trackBar1.Maximum = 100;
trackBar1.Minimum = 0;
trackBar1.SmallChange = 5;
trackBar1.Value = 19;
// Valores barra de progreso.
progressBar1.Maximum = 95;
progressBar1.Minimum = 19;
progressBar1.Step = 5;
progressBar1.Value = trackBar1.Value;
}
}
} Si pulso X con el ratón
{
Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
Puerto_serie.Close(); // Cierra el puerto serie.
Environment.Exit(0); // Cerrar aplicación.
} Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
Puerto_serie.Close(); // Cierra el puerto serie.
Environment.Exit(0); // Cerrar aplicación.using System;
using System.IO.Ports;
namespace Introducir_datos_puerto_serie_consola_01
{
class Program
{
static void Main(string[] args)
{
// Título de la ventana.
Console.Title = "Enviar datos al puerto serie";
// Tamaño de la ventana, x, y.
Console.SetWindowSize(70, 25);
// Color de fondo.
Console.BackgroundColor = ConsoleColor.Blue;
// Color de las letras.
Console.ForegroundColor = ConsoleColor.Yellow;
// Limpiar pantalla y dejarlo todo gris.
Console.Clear();
// Visible el cursor.
Console.CursorVisible = true;
// Cree un nuevo objeto SerialPort con la configuración predeterminada.
SerialPort Puerto_serie = new SerialPort("COM3");
Puerto_serie.BaudRate = 115200;
Puerto_serie.Parity = Parity.None;
Puerto_serie.StopBits = StopBits.One;
Puerto_serie.DataBits = 8;
Puerto_serie.Handshake = Handshake.None;
Puerto_serie.RtsEnable = true;
// Establecer los tiempos de espera de lectura / escritura.
Puerto_serie.ReadTimeout = 500; // Milisegundos.
Puerto_serie.WriteTimeout = 500;
// Detecta cualquier dato recibido.
Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
Puerto_serie.Open(); // Abrir puerto.
//Console.CursorSize = 1;
do
{
Console.Write("Introduzca un texto: ");
string texto;
texto = Console.ReadLine();
Console.WriteLine("El texto introducido es: " + texto);
//texto = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
Puerto_serie.Write(texto); // Envía los datos del string todo su contenido.
Console.WriteLine("Comando {0} enviado.", texto); // Muestra en pantalla comandos enviado.
Console.WriteLine();
// ################ Pregunta aquí si quieres salir. ################
//Si pulso X con el ratón
//{
// Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
// Puerto_serie.Close(); // Cierra el puerto serie.
// Environment.Exit(0); // Cerrar aplicación.
//}
// #####################################################################
} while (true);
}
// Detecta cualquier dato entrante.
private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
{
SerialPort sp = (SerialPort)sender;
string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
Console.WriteLine("Datos recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
}
}
}
// Variables.
static string guardarNombre = ""; // Guardar nombre escrito.
static int coordenadaX = 0; // Coordenada X del setCursorPisition.
//static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
static int index = 0; // Índice.
// Caracteres de este array.
static char[] roALFANUMERICO = new char[]
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
'¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
};
// Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
static int[] roINDICE_ARRAY = new int[]
{
80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
};
// Palabras del array para imprimir en pantalla.
static string[] roTEXTO = new string[]{ "ATRÁS", "GUARDAR" };
using System;
using System.Speech.Recognition; // No olvidar. Micro.
using System.Speech.Synthesis; // No olvidar. Altavoz.
// No olvidar añadir en "Referencias" Speech en el "Explorador de soluciones".
namespace Calculo_cilindro_voz_consola_02_cs
{
class Program
{
static void Main(string[] args)
{
// Mostrar título de la ventana.
Console.Title = "Cálculo litros de un depósito - By Meta. Electrónica PIC";
// Tamaño de la ventna. 55 X y 16 Y.
Console.SetWindowSize(55, 16);
#region Variables.
// Variables.
const double Pi = 3.14;
float PI = Convert.ToSingle(Pi);
float radio, altura, volumen, litros, nivelAgua, resultadoPorcentaje,
resultadoLitros, volumenLitros, mitadBarra, cantidadTubosLitros,
totalLitros;
float cantidadTubos;
#endregion
do
{
try
{
// Inicializar una nueva instancia de SpeechSynthesizer.
using (SpeechSynthesizer altavoz = new SpeechSynthesizer())
{
#region Introducción de datos en la pantalla.
// Configure la salida de audio.
altavoz.SetOutputToDefaultAudioDevice();
// Velocidad de la voz.
altavoz.Rate = -2; // Valores entre -10 a 10.
// Volumen de la voz.
altavoz.Volume = 100; // Valores entre 0 y 100.
// Limpiar pantalla.
Console.Clear();
// Cursor visible.
Console.CursorVisible = true;
// Introducción de datos.
Console.Write("Introduce el radio en m.: ");
altavoz.Speak("Introduce el radio en metros.");
radio = float.Parse(Console.ReadLine());
Console.Write("Introduce la altura del tubo en m.: ");
altavoz.Speak("Introduce la altura del tubo en metros.");
altura = float.Parse(Console.ReadLine());
Console.Write("Introduce altura del agua. Máximo es de {0} m.: ", altura);
altavoz.Speak("Introduce altura del agua. Máximo es de " + altura + "metros.");
nivelAgua = float.Parse(Console.ReadLine());
Console.Write("Introduce cantidad de tubos: ");
altavoz.Speak("Introduce cantidad de tubos.");
cantidadTubos = int.Parse(Console.ReadLine());
#endregion
#region Cálculos.
// Cálculo volumen.
volumen = PI * (radio * radio) * altura;
// Cálculo litros.
litros = volumen * 1000;
// Cálculo porcentaje en % del litro de agua.
resultadoPorcentaje = nivelAgua * (100 / altura);
// Cálculo litros de agua.
volumenLitros = PI * (radio * radio) * nivelAgua;
resultadoLitros = volumenLitros * 1000;
// Cálculo litros por cantidad de tubos
cantidadTubosLitros = cantidadTubos * resultadoLitros;
// Cálculo cantidad de litros con total de tubos.
totalLitros = litros * cantidadTubos;
#endregion
#region Dibujado barra de progreso.
// Posición.
Console.SetCursorPosition(0, 4);
// Dibujo de la barra.
Console.WriteLine();
Console.WriteLine("0 % 50 % 100 %");
Console.WriteLine("┌────────────────────────┬───────────────────────┐");
// Mitad de la barra para que no sea muy grande en la pantalla.
mitadBarra = resultadoPorcentaje / 2;
if (resultadoPorcentaje <= 15)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (resultadoPorcentaje <= 40)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
else if (resultadoPorcentaje <= 100)
{
Console.ForegroundColor = ConsoleColor.Green;
}
if (mitadBarra > 50)
{
mitadBarra = 50;
}
Console.SetCursorPosition(0, 7);
// Rellenar la barra.
for (int i = 1; i <= mitadBarra; i++)
{
Console.Write("█");
}
Console.ForegroundColor = ConsoleColor.Gray;
// Si llega a 100 se pone el # en rojo.
if (resultadoPorcentaje > 100)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("#");
Console.ForegroundColor = ConsoleColor.Gray;
}
#endregion
#region Mostrar textos en pantalla.
// Cursor invisible.
Console.CursorVisible = false;
// Pisición del texto a mostrar.
Console.SetCursorPosition(0, 9);
// Muestra porcentaje del depósito.
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("\nPorcentaje: ");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(resultadoPorcentaje.ToString("N2") + " %.");
altavoz.Speak("Cantidad de agua que hay en el depósito es de " +
//resultadoPorcentaje.ToString("N2") + "%.");
resultadoPorcentaje + "%.");
// Muestra cantidad de agua que hay actualmente y el total.
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("\nLitros de agua: ");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(resultadoLitros.ToString("N2"));
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(" / " + litros.ToString("N2") + " L. total de un tubo.");
altavoz.Speak("Cantidad de litros de agua en un tubo de " +
resultadoLitros.ToString("N2") + "de " +
litros.ToString("N2") + " litros total de un tubo.");
// Cantidad de tubos sin contar la base conectada, solo tubos independiente.
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("\nCantidad de Litros total por " + cantidadTubos + " tubos: ");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(cantidadTubosLitros.ToString("N2"));
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(" / " + totalLitros.ToString("N2") + " L.");
altavoz.Speak("Cantidad de litros en total por " + cantidadTubos.ToString("N2") +
" tubos: " + cantidadTubosLitros.ToString("N2") +
" de " + totalLitros.ToString("N2") + " litros.");
#endregion
}
}
catch (FormatException)
{
Console.BackgroundColor = ConsoleColor.Gray;
Console.ForegroundColor = ConsoleColor.Red;
Console.Clear();
Console.SetCursorPosition(8, 5);
Console.Write(@"La cadena de entrada no tiene el
formato correcto.
Solo debes introducir números y comas.");
Console.CursorVisible = false;
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Gray;
}
// Pulse cualquier tecla para continuar.
Console.ReadKey();
} while (true);
}
}
}
#include <iostream>
#include <windows.h> // Para mostrar texto en el título de la ventana.
#include <stdio.h> // Cambio color de fondo y letras.
using namespace std;
//using std::cout;
//using std::cin;
// Función posición del cursor.
void gotoxy(int x, int y)
{
HANDLE hcon;
hcon = GetStdHandle(STD_OUTPUT_HANDLE);
COORD dwPos;
dwPos.X = x;
dwPos.Y = y;
SetConsoleCursorPosition(hcon, dwPos);
}
int main()
{
// Mostrar caracteres correctamente en pantalla y título de la ventana.
SetConsoleOutputCP(65001);
wchar_t titulo[128];
MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
SetConsoleTitle(titulo);
// Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
SMALL_RECT r = { 0, 0, 49, 9 }; // X = 49, Y = 9.
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
// Cambio color de 8 (gris), color letras 0 (negro).
//system("color 80");
// Ocultar cursor.
CONSOLE_CURSOR_INFO cci;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
// Mostrar textos en pantalla.
cout << "Terminarías. Conocerías. Título. Analógico. \n";
cout << "Muchas gracias mi muy distinguido amigo.";
// Limpiar pantalla.
system("cls");
// Mostrar textos en pantalla.
cout << "Se escribe este texto después de haber " << endl;
cout << "borrado el anterior." << endl;
// Posición del cursor.
gotoxy(5, 5);
cout << "Posición." << endl;
// Ocultar cursor.
CONSOLE_CURSOR_INFO cci2;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci2);
cci2.bVisible = 1; // 0 oculta. 1 muestra cursor.
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci2);
// Esperando pulsar Enter para salir.
cin.get();
return 0;
} // Cambio color de 8 (gris), color letras 0 (negro).
system("color 80");Serial.println("Se muestra este texto en el Monitor serie.");sing System;
namespace Cambiar_tamaño_array_consola_02_cs
{
class Program
{
static void Main(string[] args)
{
// Título de la ventana.
Console.Title = "Tamaño del array";
// Crea e inicializa una nueva matriz de cadenas.
String[] miArray = {"Hola", "mi", "muy", "distinguido", "amigo",
"¿Cómo", "estás", "por", "aquí?"};
// Muestra los valores de la matriz.
Console.WriteLine(
"La matriz de cadenas contiene inicialmente los siguientes valores:");
MostrarIndicesYValores(miArray);
// Cambiar el tamaño de la matriz a un tamaño más grande (cinco elementos más grandes).
Array.Resize(ref miArray, miArray.Length + 5);
// Muestra los valores de la matriz.
Console.WriteLine("Después de cambiar el tamaño a un tamaño más grande,");
Console.WriteLine("la matriz de cadenas contiene los siguientes valores:");
MostrarIndicesYValores(miArray);
// Cambiar el tamaño de la matriz a un tamaño más pequeño (cuatro elementos).
Array.Resize(ref miArray, 4);
// Muestra los valores de la matriz.
Console.WriteLine("Después de cambiar el tamaño a un tamaño más pequeño,");
Console.WriteLine("la matriz de cadenas contiene los siguientes valores:");
MostrarIndicesYValores(miArray);
// Pulse cualquier tecla para salir.
Console.ReadKey();
}
public static void MostrarIndicesYValores(String[] miArray)
{
for (int i = 0; i < miArray.Length; i++)
{
Console.WriteLine(" [{0}] : {1}", i, miArray[i]);
}
Console.WriteLine();
}
}
}
h V
1 4,429446918
2 6,264183905
3 7,672027112
4 8,858893836
5 9,904544412
6 10,84988479
7 11,71921499
8 12,52836781
9 13,288340754,429446918
=RAIZ(2*9,81*A2)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LCD_nombre_archivo_consola_08
{
class Program
{
static string guardarNombre = "";
static int coordenadaX = 0;
private static ConsoleKey tecla;
// Caracteres de este array.
static readonly char[] roALFANUMERICO = new char[]
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
'¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
};
// Dirección del carácter del array. El 80 presenta al espacio del array roALFANUMERICO.
static readonly int[] roINDICE_ARRAY = new int[]
{
80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
};
private static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
static int index = 0;
static void Main(string[] args)
{
// Título de la pantalla.
Console.Title = "Cambiar nombre";
Inicio();
}
#region Inico.
private static void Inicio()
{
// Tamaño de la ventana.
Console.SetWindowSize(20, 5); // X
// Fondo verde, azul, gris.
Console.BackgroundColor = ConsoleColor.Gray;
// Letras negras, blanco, negro.
Console.ForegroundColor = ConsoleColor.Black;
// Limpiar pantalla.
Console.Clear();
Console.SetCursorPosition(0, 0);
Console.Write("Nombre del relé 1: ");
Console.SetCursorPosition(0, 1);
//Console.Write("AAAAAAAAAAAAAAAA");
// Recorre todo el índice del array y el de los datos alfanumérico
// y los rellena.
for (int i = 0; i < roINDICE_ARRAY.Length; i++)
{
Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
}
Console.SetCursorPosition(2, 3);
Console.Write(roTEXTO[0]); // ATRÁS.
Console.SetCursorPosition(12, 3);
Console.Write(roTEXTO[1]); // GUARDAR.
while (true)
{
Console.SetCursorPosition(coordenadaX, 1);
// Almacena cualquier tecla pulsada en la variable key.
tecla = Console.ReadKey(true).Key;
switch (tecla)
{
case ConsoleKey.RightArrow:
if (coordenadaX < 15)
{
coordenadaX++;
}
break;
case ConsoleKey.LeftArrow:
if (coordenadaX > 0)
{
coordenadaX--;
}
break;
case ConsoleKey.UpArrow:
roINDICE_ARRAY[coordenadaX]++;
if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
{
roINDICE_ARRAY[coordenadaX] = 0;
}
Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
break;
case ConsoleKey.DownArrow:
roINDICE_ARRAY[coordenadaX]--;
if (roINDICE_ARRAY[coordenadaX] < 0)
{
roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
}
Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
break;
case ConsoleKey.Enter:
Console.SetCursorPosition(1, 3);
Console.CursorVisible = false;
Console.Write(">");
while (true)
{
tecla = Console.ReadKey(true).Key;
switch (tecla)
{
case ConsoleKey.RightArrow:
case ConsoleKey.LeftArrow:
index = 1 - index;
break;
case ConsoleKey.UpArrow:
case ConsoleKey.DownArrow:
Console.SetCursorPosition(coordenadaX, 1);
break;
case ConsoleKey.Enter:
break;
}
for (int a = 0; a < 2; a++)
{
Console.SetCursorPosition(1 + (10 * a), 3);
if (a == index)
{
Console.Write(">");
}
else
{
Console.Write(" ");
}
}
if (index == 0) // se pulsó Atrás
{
Atras();
//break; // vuelve a la edición de letras
}
if (index == 1) // se pulsó Guardar
{
Guardar();
}
}
}
}
}
#endregion
private static void Atras()
{
Console.Clear();
Console.SetCursorPosition(0, 1);
Console.Write("HAS PULSADO ATRÁS ");
Console.ReadKey(); // Pulse cualquier tecla para salir.
}
private static void Guardar()
{
Console.Clear();
Console.SetCursorPosition(0, 1);
Console.Write("HAS GUARDADO ");
for (int a = 0; a < roINDICE_ARRAY.Length; a++)
{
guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
}
Console.SetCursorPosition(0, 2);
Console.Write(guardarNombre);
}
}
}
#include <iostream>
#include <windows.h> // Para mostrar texto en el título de la ventana.
using namespace std;
//using std::cout;
//using std::cin;
// Función posición del cursor.
void gotoxy(int x, int y)
{
HANDLE hcon;
hcon = GetStdHandle(STD_OUTPUT_HANDLE);
COORD dwPos;
dwPos.X = x;
dwPos.Y = y;
SetConsoleCursorPosition(hcon, dwPos);
}
int main(void)
{
// Mostrar caracteres correctamente en pantalla y título de la ventana.
SetConsoleOutputCP(65001);
wchar_t titulo[128];
MultiByteToWideChar(CP_UTF8, 0, "Consola C++ nativo 2019.", -1, titulo, 128);
SetConsoleTitle(titulo);
// Variable.
char entrada[] = "\0"; // Guarda A, a, C, y c tipo string que introduces desde la consola.
// Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
SMALL_RECT r = { 0, 0, 29, 8 }; // X = 29, Y = 8.
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
// Ocultar cursor.
CONSOLE_CURSOR_INFO cci;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
// Muestra textos en pantalla.
cout << "Control bandeja del lector: " << endl << endl;
cout << "A - Abrir bandeja." << endl;
cout << "C - Cerrar bandeja." << endl;
cout << "===========================" << endl;
while (true)
{
// Aquí introduces letras A, a, C y c.
cin >> entrada;
cout << "\n" << endl;
// Abrir bandeja.
if ((entrada[0] == 'a') || (entrada[0] == 'A'))
{
// Posición del cursor.
gotoxy(0, 6);
cout << "Abriendo..." << endl << endl; // Muestra texto en pantalla.
mciSendString(L"set cdaudio door open", nullptr, 0, nullptr);
gotoxy(0, 6);
cout << "Abierto. " << endl << endl; // Muestra texto en pantalla.
}
// Cerrar bandeja.
else if ((entrada[0] == 'c') || (entrada[0] == 'C'))
{
gotoxy(0, 6);
cout << "Cerrando..." << endl << endl; // Muestra texto en pantalla.
mciSendString(L"set cdaudio door closed", nullptr, 0, nullptr);
gotoxy(0, 6);
cout << "Cerrado. " << endl << endl; // Muestra texto en pantalla.
}
// Si haz pulsado otro caracter distinto de A, C, a y c aparece
else
{
gotoxy(0, 6);
// este mensaje.
cout << "Solo pulsa A o C." << endl << endl;
}
}
return EXIT_SUCCESS;
}using System;
using System.Runtime.InteropServices;
using System.Text;
namespace Bandeja_consola_cs
{
class Program
{
[DllImport("winmm.dll")]
public static extern Int32 mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
int uReturnLength, IntPtr hwndCallback);
public static StringBuilder rt = new StringBuilder(127);
public static void DoEventsAbriendo()
{
Console.SetCursorPosition(0, 6);
Console.Write("Abriendo...");
}
public static void DoEventsCerrando()
{
Console.SetCursorPosition(0, 6);
Console.Write("Cerrando...");
}
static void Main(string[] args)
{
// Título de la ventana.
Console.Title = "Consola C# 2017";
// Tamaño ventana consola.
Console.WindowWidth = 29; // X. Ancho.
Console.WindowHeight = 8; // Y. Alto.
// Cursor invisible.
Console.CursorVisible = false;
// Posición del mansaje en la ventana.
Console.SetCursorPosition(0, 0);
Console.Write(@"Control bandeja del lector:
A - Abrir bandeja.
C - Cerrar bandeja.
===========================");
ConsoleKey key;
//Console.CursorVisible = false;
do
{
key = Console.ReadKey(true).Key;
string mensaje = string.Empty;
//Asignamos la tecla presionada por el usuario
switch (key)
{
case ConsoleKey.A:
// mensaje = "Abriendo...";
Console.SetCursorPosition(0, 6);
DoEventsAbriendo();
mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
mensaje = "Abierto. ";
break;
case ConsoleKey.C:
// mensaje = "Cerrando...";
Console.SetCursorPosition(0, 6);
DoEventsCerrando();
mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero);
mensaje = "Cerrado. ";
break;
}
Console.SetCursorPosition(0, 6);
Console.Write(" ");
Console.SetCursorPosition(0, 6);
Console.Write(mensaje);
}
while (key != ConsoleKey.Escape);
}
}
}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;
namespace prueba_cs
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
timer1.Start();
}
void cambioColor()
{
this.BackColor = Color.Black; // Formulario negro.
//this.ForeColor = Color.White; // Cambia textos en blanco.
label1.ForeColor = Color.White;
}
void cambioColor2()
{
this.BackColor = Color.White; // Formulario blanco.
//this.ForeColor = Color.Black; // Cambia textos en negro.
label1.ForeColor = Color.Black;
}
private void timer1_Tick(object sender, EventArgs e)
{
cambioColor();
timer1.Stop();
timer2.Start();
}
private void timer2_Tick(object sender, EventArgs e)
{
cambioColor2();
timer2.Stop();
timer1.Start();
}
}
}#include "pch.h"
extern "C"
{
__declspec(dllexport) LPTSTR __stdcall Mensaje();
__declspec(dllexport) float __stdcall Volumen(float, float, float, float);
__declspec(dllexport) float __stdcall Litros(float, float);
__declspec(dllexport) float __stdcall ResultadoPorcentaje(float, float, float);
__declspec(dllexport) float __stdcall VolumenLitros(float, float, float, float, float);
__declspec(dllexport) float __stdcall CantidadTubosLitros(float, float, float);
__declspec(dllexport) float __stdcall TotalLitros(float, float, float);
};
// Mensaje.
LPTSTR __stdcall Mensaje() { return LPTSTR(L"Hola. Saludos desde la dll. Versión: 1.0.0"); }
// Cálculo volumen.
float __stdcall Volumen(float volumen, float PI, float radio, float altura)
{
return volumen = PI * (radio * radio) * altura;
}
// Cálculo litros.
float __stdcall Litros(float litros, float volumen)
{
return litros = volumen * 1000;
}
// Cálculo porcentaje en % del litro de agua.
float __stdcall ResultadoPorcentaje(float resultadoPorcentaje, float nivelAgua, float altura)
{
return resultadoPorcentaje = nivelAgua * (100 / altura);
}
// Cálculo litros de agua.
float __stdcall VolumenLitros(float volumenLitros, float PI, float radio, float nivelAgua, float resultadoLitros)
{
return volumenLitros = PI * (radio * radio) * nivelAgua;
return resultadoLitros = volumenLitros * 1000;
}
// Cálculo litros por cantidad de tubos
float __stdcall CantidadTubosLitros(float cantidadTubosLitros, float cantidadTubos, float resultadoLitros)
{
return cantidadTubosLitros = cantidadTubos * resultadoLitros;
}
// Cálculo cantidad de litros con total de tubos.
float __stdcall TotalLitros(float totalLitros, float litros, float cantidadTubos)
{
return totalLitros = litros * cantidadTubos;
}LIBRARY DLL_al_poder
EXPORTS
Mensaje
Volumen
Litros
ResultadoPorcentaje
VolumenLitros
CantidadTubosLitros
TotalLitros#include <iostream>
#include <windows.h> // Para mostrar texto en el título de la ventana.
using namespace std;
//using std::cout;
//using std::cin;
// Función posición del cursor.
void gotoxy(int x, int y)
{
HANDLE hcon;
hcon = GetStdHandle(STD_OUTPUT_HANDLE);
COORD dwPos;
dwPos.X = x;
dwPos.Y = y;
SetConsoleCursorPosition(hcon, dwPos);
}
// Definir estas funciones.
typedef LPTSTR(__stdcall* Mensaje)();
typedef float(__stdcall* Volumen)(float, float, float, float);
typedef float(__stdcall* Litros)(float, float);
typedef float(__stdcall* ResultadoPorcentaje)(float, float, float);
typedef float(__stdcall* VolumenLitros)(float, float, float, float, float);
typedef float(__stdcall* CantidadTubosLitros)(float, float, float);
typedef float(__stdcall* TotalLitros)(float, float, float);
int main(void)
{
// Variables.
const double Pi = 3.14;
float radio;
float altura;
//double volumen;
//double litros;
float nivelAgua;
//float resultadoPorcentaje;
//double resultadoLitros;
//double volumenLitros;
float mitadBarra;
float cantidadTubos;
//double cantidadTubosLitros;
//double totalLitros;
// Importar dll.
HINSTANCE hDLL = 0;
Mensaje mensaje;
Volumen volumen;
Litros litros;
ResultadoPorcentaje resultadoPorcentaje;
VolumenLitros volumenLitros;
CantidadTubosLitros cantidadTubosLitros;
TotalLitros totalLitros;
hDLL = LoadLibrary(L"C:\\Users\\Meta\\Documents\\Visual Studio 2019\\Projects\\DLL_y_interfaz_nativo_01_cpp\\Debug\\DLL_y_interfaz_nativo_01_cpp.dll");
mensaje = (Mensaje)GetProcAddress(hDLL, "Mensaje");
volumen = (Volumen)GetProcAddress(hDLL, "Volumen");
litros = (Litros)GetProcAddress(hDLL, "Litros");
resultadoPorcentaje = (ResultadoPorcentaje)GetProcAddress(hDLL, "ResultadoPorcentaje");
volumenLitros = (VolumenLitros)GetProcAddress(hDLL, "VolumenLitros");
cantidadTubosLitros = (CantidadTubosLitros)GetProcAddress(hDLL, "CantidadTubosLitros");
totalLitros = (TotalLitros)GetProcAddress(hDLL, "totalLitros");
// Mostrar caracteres correctamente en pantalla y título de la ventana.
SetConsoleOutputCP(65001);
wchar_t titulo[128];
MultiByteToWideChar(CP_UTF8, 0, "Interfaz leer dll C++ nativo 2019.", -1, titulo, 128);
SetConsoleTitle(titulo);
// Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
SMALL_RECT r = { 0, 0, 49, 35 }; // X = 49, Y = 9.
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
// Ocultar cursor.
CONSOLE_CURSOR_INFO cci;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
cci.bVisible = 1; // 0 oculta cursor. 1 muestra cursor.
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
// Posición del cursor.
gotoxy(3, 2);
// Mostrar textos en pantalla.
wcout << mensaje() << endl;
gotoxy(0, 4);
cout << "Introduce el radio en m.: ";
cin >> radio;
cout << "Introduce la altura en m. ";
cin >> altura;
cout << "Introduce altura del agua. Máximo es de " << altura << ":";
cin >> nivelAgua;
cout << "Introduces cantidad de tubos: ";
cin >> cantidadTubos;
// ########## Dibujo de la barra.
cout << "\n";
cout << ("0 % 50 % 100 %") << endl;
cout << ("┌────────────────────────┬───────────────────────┐") << endl;
// Mitad de la barra para que no sea muy grande en la pantalla.
mitadBarra = resultadoPorcentaje / 2;
if (mitadBarra > 50)
{
mitadBarra = 50;
}
// Rellenar la barra.
for (float i = 1; i <= mitadBarra; i++)
{
cout << ("█");
}
// Si llega a 100 se pone el # en rojo.
if (resultadoPorcentaje > 100)
{
cout << ("#");
}
//########## Fin dibujo de la barra.
// Pisición del texto a mostrar.
gotoxy(0, 11);
//cout << "\nPorcentaje: " << resultadoPorcentaje << " %.";
FreeLibrary(hDLL);
// Esperando pulsar Enter para salir.
cin.get();
return 0;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace radioButton_consola_03_cs
{
class Program
{
#region Variables.
private static readonly string[] TEXTO = new string[]
{
"( ) Opción A ",
"( ) Opción B ",
"( ) Opción C ",
"( ) Opción D ",
"( ) Opción E ",
"( ) Opción F ",
"( ) Opción G ",
" SALIR"
};
private static int itemSeñalado;
private static int itemSeleccionado;
#endregion
static void Main(string[] args)
{
// Título de la ventana.
Console.Title = "RadioButton";
// Tamaño de la ventana.
Console.SetWindowSize(20, 5);
// Fondo azul.
Console.BackgroundColor = ConsoleColor.Blue;
// Letras blanco.
Console.ForegroundColor = ConsoleColor.White;
// Oculto el cursor.
Console.CursorVisible = false;
// Almacena la tecla pulsada en la variable.
ConsoleKey teclaInicial;
do
{
// Limpiar pantalla.
Console.Clear();
// Posición del cursor del título del MENÚ PRINCIPAL.
Console.SetCursorPosition(0, 0);
// Título.
Console.Write(" MENÚ PRINCIPAL ");
// Pocisión de la hora.
Console.SetCursorPosition(4, 2);
// Formato numérico dd/MM/yyyy.
Console.Write(DateTime.Now.ToString("ddd dd MMM"));
// Almacena en la variable una tecla pulsada.
teclaInicial = Console.ReadKey(true).Key;
// ¿Haz pulsado la tecla Enter?
if (teclaInicial == ConsoleKey.Enter)
{
// Sí. Se ejecuta esta función.
MenuPrincipal();
}
} while (teclaInicial != ConsoleKey.Escape);
}
#region Menú Principal.
private static void MenuPrincipal()
{
bool salir = false;
// En itemSelecionado:
// -1 = Sin seleccionar con * ninguna opción.
// 0 = Seleccionar con * la Opción A.
// 1 = Seleccionar con * la Opción B.
// 2 = Seleccionar con * la opción C.
// 3 = Seleccionar con * la opción D.
// 4 = Seleccionar con * la opción E.
// 5 = Seleccionar con * la opción F.
// 6 = Seleccionar con * la opción G.
// Capturar tecla para luego validar.
ConsoleKey tecla;
// Cada vez que se vuelva al menú, está señalizado con el *.
itemSeñalado = 0;
int pagina;
do
{
//******************************************************************
// Dibujo el menú principal.
// Limpiar pantalla.
Console.Clear();
pagina = 0;
if (itemSeñalado >= 4)
{
pagina = 4;
}
// Recorre la lista de las opciones.
for (int k = 0; k < 4; k++)
{
Console.SetCursorPosition(0, k);
Console.Write(itemSeñalado == k + pagina ? "> " : " ");
Console.Write(TEXTO[k + pagina]);
Console.SetCursorPosition(3, k);
Console.Write(itemSeleccionado == k + pagina ? "*" : " ");
}
// Fin de pintar el menú principal.
//******************************************************************
// Leer tecla ingresada por el usuario.
tecla = Console.ReadKey(true).Key;
switch (tecla)
{
// Al pulsar Enter, marcas un radioButton con *.
case ConsoleKey.Enter:
if (itemSeñalado < 7)
{
itemSeleccionado = itemSeñalado;
}
salir = (itemSeñalado == TEXTO.Length - 1);
break;
// Pulsar flecha abajo del teclado.
case ConsoleKey.DownArrow:
if (++itemSeñalado >= TEXTO.Length)
{
itemSeñalado = 0;
Console.Clear();
}
else if (itemSeñalado == 4)
{
Console.Clear();
}
break;
// Pulsar flecha arriba del teclado.
case ConsoleKey.UpArrow:
if (--itemSeñalado < 0)
{
itemSeñalado = TEXTO.Length - 1;
Console.Clear();
}
else if (itemSeñalado == 3)
{
Console.Clear();
}
break;
}
// Uso la tecla escape como salida.
} while (!salir);
}
#endregion
}
}import os, sys, tkFileDialog,Tkinter
root = Tkinter.Tk()
root.withdraw()
formats = [ ('Roms Super Nintendo SMC','.smc'),('Roms Super Nintendo SFC','.sfc'),('Fichier Bin','.bin'),('Roms Super Nintendo','.smc .sfc .bin') ]
input = tkFileDialog.askopenfile(parent=root,mode='rb',filetypes=formats,
title='Seleccione el archivo para intercambiar bin HI a LO como A16->A15, A17->A16...A21->A20 y A15->21')
if not input:
print "Error: no se puede abrir el archivo."
sys.exit()
output = tkFileDialog.asksaveasfile(parent=root,mode='wb',filetypes=formats,title='Crear nombre de archivo de salida.')
if not output:
print "Error: no se puede crear el archivo de salida."
sys.exit()
# reading input file to a byte array
data = bytearray(input.read())
# calculating rom size in 2 exponants
expsize = 0
bytesize = len(data)
while bytesize > 1:
expsize += 1
bytesize = bytesize // 2
# init a proper size empty bytearray
buffer = bytearray()
for i in range(2**expsize): buffer.append(0)
# let's do the swap
count = 0
for i in range(len(data)):
addr = (i & 0x7fff) + ((i & 0x008000) << (expsize - 16)) + ((i & 0x010000) >> 1) + ((i & 0x020000) >> 1) + ((i & 0x040000) >> 1)
+ ((i & 0x080000) >> 1) + ((i & 0x100000) >> 1) + ((i & 0x200000) >> 1)
if addr != i: count += 1
buffer[addr] = data[i]
print "Intercambiadas %s (%s) direcciones" % (count, hex(count))
# writing output file
output.write(buffer)
# close file handles
input.close()
output.close()