Hola:

Hace siglos que quice hacerlo pero no me salió. añado en el Windows Form un pictureBox, ahí dentro creo dos rayas, una vertical y otra horizontal con el círculo en medio, tal como indica la imagen de abajo.



Los puntos que muestran se tiene que mover tal como lo hace en el vídeo de abajo.

Ver vídeo.


Código hasta ahora.

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

¿Alguna idea?

Saludos.

Hola:

Tengo esta barra que pone de 0 % al 100 %.

0%     19 %                                                                  95 %        100%
|--------|-----------------------------------------------------------|--------------|

Mejor imagen de abjo.



Dentro de Windows Form incluyo la barra progressBar y el trackBar para regular una variable.

Internamente del programa, hay dos variables, una que pone 19 y otra variabe que pone 95. Esas con constantes.

Internamente una variable es capaz de moverse del 19 al 95. En otra variable indica que es un 0 al 100 %.

Por ejemplo, si con el trackBar lo pongo al valor 95, en un label tiene que indicar que estoy al 100.

Internamente funciona del 19 al 95 y cara del usuario lo ve como si fuera del 0 al 100 %.

Código que he hecho hasta ahora y no me funciona.

¿Es posible hacerlo?

Saludos.

Buenas:

Pues sí, es tal como lo dices, nunca lo he imaginado, ya que con otros lenguajes como C#, incluso el C++ CLR .net no me pasa, si cambio las letras, cambio el cursor automaticamente también.

system("color 1F");

Así está mejor.

Muchísimas gracias. 

Bueno:

Para no estar con tanto jaleo.

Mejor una cosa más fácil.

Sin preguntar nada al salir del programa, solo que antes de salir, indique el programa enviar un mensaje al puerto serie y luego cierra el puerto.

                                Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
                                Puerto_serie.Close(); // Cierra el puerto serie.

Eso lo prefiero más y no tanto rollo.

No es así, por mucho que formemos parte de la naturaleza.

Los científicos saben que tenemos un cerebro con cierta inteligencia, lo que no se sabe es como se forma la consciencia desde la nada a seres conscientes.

Lo del digital. es solo inventado por el hombre, no está en la naturaleza.

Hola:

Al final el código Morse es analogicamente analógico. Lo que no sabía, que todavía se usa hoy en día, a pesar que ya tiene unos 175 años de su historia.

Hasta hay códigos en C# con morse. La gente se abure.





Saludos.

Buenas:

Tengo un programa hecho a medias. Está hecho con la consola C#.

Al pulsar la X de la ventana, quiero que haga estas cosas.
Pregunta si realmente quiero salir, si salgo, pone esto.

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

Arriaba está mal planteado.

Primero pregunta si quiero salir, con un Sí y un No, si pulso No, el programa sigue su curso, si pongo Si, cierra el programa y me envía estos datos al puerto serie antes de que cierre del todo.

                                Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
                                Puerto_serie.Close(); // Cierra el puerto serie.
                                Environment.Exit(0); // Cerrar aplicación.

Código ejemplo casi completo.

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

Gracias camaradas.

Saludos.

Muchísimas gracias. Funciona a la primera.

No se el motivo, en C# no me deja ponerlo valores constantes con "const", me aconseja ponerle "readonly".

Diferencia const entre readonly.

Ejemplo tuyo modificado con const en C++ 2019.

#include <iostream>
#include <string>
#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;
 
int main()
{
    // Variables.
    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 const ALFANUMERICO[] =
    {
        '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 const INDICE_ARRAY[] =
    {
        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 const TEXTO[] = { "ATRÁS", "GUARDAR" };
 
    // 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");
 
    // mostrar contenido de las variables.
    cout << guardarNombre << endl;
    cout << coordenadaX << endl;
    cout << index << endl;
 
    for (int i = 0; i < sizeof(ALFANUMERICO) / sizeof(ALFANUMERICO[0]); i++)
    {
        cout << ALFANUMERICO[i] << endl;
    }
 
    for (int i = 0; i < sizeof(INDICE_ARRAY) / sizeof(INDICE_ARRAY[0]); i++)
    {
        cout << INDICE_ARRAY[i] << endl;
    }
 
    for (int i = 0; i < sizeof(TEXTO) / sizeof(TEXTO[0]); i++)
    {
        cout << TEXTO[i] << endl;
    }
 
    // Esperando pulsar Enter para salir.
    cin.get();
    //getchar();
    return 0;
}

Edito:

Gracias por la ayuda. Porque en realidad quiero pasar este código completo de C# a C++ nativo. Esto ya es demasiado tiempo, pero lo haré.

using System;
using System.IO;
 
namespace LCD_nombre_archivo_consola_11
{
    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 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
        };
 
        // 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 Inico.
        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. El código continúa por aquí.
 
            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 arra 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();
 
            // 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();
        }
    }
}

Gracias por todo. Si te animas, mejor. Entonces, lo tienes bien puestos.

---

EI: Juntando mensajes, otra vez.

Me funciona hasta con Arduino.

#include <LiquidCrystal.h>
 
// Inicializa la librería con sus pines indicados.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
 
// Pin 10 para saber que es luz de fondo del LCD.
//int LuzFondo = 10;
 
 
// Variables.
String guardarNombre = ""; // Guardar nombre escrito.
int coordenadaX = 0; // Coordenada X del setCursorPisition.
int index = 0; // Índice.
// Caracteres de este array.
char const PROGMEM ALFANUMERICO[] =
{
  '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.
int const PROGMEM INDICE_ARRAY[] =
{
  80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
};
 
// Palabras del array para imprimir en pantalla.
String const TEXTO[] = { "ATRÁS", "GUARDAR" };
 
void setup()
{
  // La pantalla es de 16 caracteres y 2 filas.
  lcd.begin(16, 2);
  lcd.print(F("  Probando..."));
 
  // Baudios del puerto serie.
  Serial.begin(115200);
 
  // Indicar luz de fondo como salida.
  // pinMode(LuzFondo, OUTPUT);
 
  Serial.println(guardarNombre);
  Serial.println(coordenadaX);
  Serial.println(index);
 
  for (byte i = 0; i < 80; i++)
  {
    Serial.println(ALFANUMERICO[i]);
  }
 
  for (byte j = 0; j < 16; j++)
  {
    Serial.println(INDICE_ARRAY[j]);
  }
 
  for (byte k = 0; k < 2; k++)
  {
    Serial.println(TEXTO[k]);
  }
}
 
void loop()
{
  //return 0;
}

Hola:

Quiero pasar estas variables de C# a C++ con Visual studio 2019.

A pesar de mirarlo aquí, me da problemas.
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_cadenas_de_texto

    // 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" };

Vamos, que me lo acepte C++ nativo o win32.

Saludos.