Duda si puedes leer la tabla ascii

Buenas gente:

Para estar con las LCD, quiero saber si puedo recorrer de algun amanera la tabla ascii como si lo puede hacer Windows, algo como esto.

Código:
       public static void CambiarChar(ref char c, bool posterior)
        {
            if (posterior) c++;
            else c--;
            if (c > 126) c = '0';
            if (c < '0') c = '}';
        }

O guardando uno en uno en una matriz o vector cada caracter como indica abajo.
Código:
char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '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', '.', ',', '-', '_', ':', ';', '¿', '?', '(', ')', '[', ']', '{', '}','=', '$',
            '&', '"', ' '};

Así me ahorro todo lo que hice.

Saludos.
 
Así me ahorro todo lo que hice

Y como es lo que hiciste? Quizas sea mejor lo que hiciste y no lo que quieres hacer.
Si utilizas un LCD, mayormente las librerias te dejan mandar el codigo ASCII directamente, si no me confundo.

Publica tu codigo para entender qué es lo que tienes hecho
 
Hola:

Todavía no he hecho nada en Arduino. Primero lo hago en consola de C#. Si todo está bien, lo paso a Arduino. Por eso la diferencia entre como escoger caracteres ASCII, en Pc se hace bien, en Arduino acaso hay una tabla de ASCII.

Si lo hay.
¿Cómo lo hago?

Por me vale ponerlo todo como hice en un array o matriz.

Lenguaje C#:
C#:
using System;

namespace LCD_nombre_archivo_consola_03
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la pantalla.
            Console.Title = "Cambiar nombre";

            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);

            string guardarNombre = "";
            int coordenadaX = 0;
            ConsoleKey key;

            char[] alfanumerico = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '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', '.', ',', '-', '_', ':', ';', '¿', '?', '(', ')', '[', ']', '{', '}','=', '$',
            '&', '"', ' '};

            int[] indiceArray = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
            string[] texto = new string[] { "ATRÁS", "GUARDAR" };

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.White;

            Console.Clear();

            Console.SetCursorPosition(0, 0);
            Console.Write("Nombre del relé 1:");
            Console.SetCursorPosition(0, 1);
            Console.Write("AAAAAAAAAAAAAAAA");
            Console.SetCursorPosition(2, 3);
            Console.Write(texto[0]);
            Console.SetCursorPosition(12, 3);
            Console.Write(texto[1]);

            while (true)
            {
                Console.SetCursorPosition(coordenadaX, 1);

                key = Console.ReadKey(true).Key;

                if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
                {
                    coordenadaX++;
                }
                else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
                {
                    coordenadaX--;
                }
                else if (key == ConsoleKey.UpArrow)
                {
                    indiceArray[coordenadaX]++;

                    if (indiceArray[coordenadaX] >= alfanumerico.Length)
                    {
                        indiceArray[coordenadaX] = 0;
                    }

                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                }
                else if (key == ConsoleKey.DownArrow)
                {
                    indiceArray[coordenadaX]--;

                    if (indiceArray[coordenadaX] < 0)
                    {
                        indiceArray[coordenadaX] = alfanumerico.Length - 1;
                    }

                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                }
                else if (key == ConsoleKey.Enter)
                {
                    Console.SetCursorPosition(1, 3);
                    Console.Write(">");

                    int index = 0;
                    while (true)
                    {
                        key = Console.ReadKey(true).Key;
                        if (key == ConsoleKey.RightArrow || key == ConsoleKey.LeftArrow)
                        {
                            index = 1 - index;
                        }
                        else if (key == ConsoleKey.UpArrow || key == ConsoleKey.DownArrow)
                        {
                            Console.SetCursorPosition(coordenadaX, 1);
                            break;
                        }
                        else if (key == ConsoleKey.Enter)
                        {
                            if (index == 0)  // se pulsó Atrás
                            {
                                Console.SetCursorPosition(0, 1);
                                Console.Write("HAS PULSADO ATRÁS   ");
                                Console.ReadLine();  // espera que se pulse Enter
                                Console.SetCursorPosition(0, 1);
                                for (int a = 0; a < indiceArray.Length; a++)
                                    Console.Write(alfanumerico[indiceArray[a]]);
                                break;  // vuelve a la edición de letras
                            }
                            else if (index == 1)  // se pulsó Guardar
                            {
                                Console.SetCursorPosition(0, 1);
                                Console.Write("HAS GUARDADO       ");
                                guardarNombre = "";
                                for (int a = 0; a < indiceArray.Length; a++)
                                    guardarNombre += alfanumerico[indiceArray[a]].ToString();
                            }
                        }

                        for (int a = 0; a < 2; a++)
                        {
                            Console.SetCursorPosition(1 + 10 * a, 3);
                            if (a == index)
                                Console.Write(">");
                            else
                                Console.Write(" ");
                        }
                    }
                    Console.SetCursorPosition(1, 3);
                    Console.Write(" ");
                }
            }
        }
    }
}

SAludos.
 
Si, si. Es basado en C, Arduino.
Aqui tienes el manual de referencia
Arduino - ASCIITable

PD: No uses C# para programar para Arduino porque no tiene nada que ver uno con otro, y vas a terminar rehaciendo todo el codigo, mejor programa cada uno en donde debes
 
Entonces lo paso a C, de Win32. Porque el C del CLR .net no tiene nada que ver.

¿Ese está bien?

Viendo el ejemplo del Arduino - ASCIITable

No ve ejemplo para sacar todo el ascii.

PD: No preocuparse C# con C, es casi igual. Es muy similar y se puede hacer. Luego cuando termine, lo paso todo a C/C++. Lo que no es aconsejable, es usar VB .net y pasarlo a C, ese si está bien jodido, lo mismo con pascal.
 

Dr. Zoidberg

Well-known-Papá Pitufo
No ve ejemplo para sacar todo el ascii.
C:
/*
  Prints out byte values in all possible formats:
  - as raw binary values
  - as ASCII-encoded decimal, hex, octal, and binary values*/

C:
int thisByte = 33;
// you can also write ASCII characters in single quotes.
// for example, '!' is the same as 33, so you could also use this:
// int thisByte = '!';

void loop() {
  // prints value unaltered, i.e. the raw binary version of the byte.
  // The Serial Monitor interprets all bytes as ASCII, so 33, the first number,
  // will show up as '!'
  Serial.write(thisByte);

...
...

// go on to the next character
  thisByte++;
}

Es bastante evidente lo que hace...que es lo mismo que vos querés hacer, solo que la conversión está en el método write de la clase Serial.
 
Última edición:
No entiendo que quieres hacer.
Si quieres leer un codigo ASCII desde el serial, tienes a Serial.read
Arduino Reference

Si quieres leer desde un display LCD, primero debes usar todos los pines, y no solo los minimos, luego leer desde la memoria del LCD, aunque es mas practico, rapido y sencillo hacerlo con variables.

Insisto, aunque parezcan iguales, no lo son, y menos como estas implementando todo, ya que desde C# estás leyendo la pantalla de la consola, y en Arduino no vas a poder realizar lo mismo, asi que mejor dinos exactamente que es lo que quieres hacer, y por qué estas programando en C# y no desde el entorno Arduino IDE o en su defecto desde AVR Studio (o MPLAB, creo que ya trae soporte AVR)
 
Leer una matrix o array creado.

Cuando acabe con C#, me paso al C Win32, también de PC.

No es igual C# de C de Arduino, es muy parecido, solo tengo que tener los dos manuales como son. No te preocupes.

Saludos.
 
Perfecto. Yo creo que primero tendrias que hacer la conversion a Arduino, y luego si te surgen problemas vuelves aqui, ya que por el momento solo hablas de C#, y ésta seccion es para Arduino y Raspberry Pi.

Por otro lado, no esta muy distante del codigo que subiste, aunque quizas necesites usar for o while para recorrer y comparar la matriz.
No estoy en la compu, pero no es muy dificil.
 
No olvides, que con C€, se puede hacer los comandos como Arduino, hablando un ejemplo de los comandos del LCD.

Código:
// Situamos el cursor en la columna 0 fila 1
  lcd.setCursor(0,1);
 
  // Escribimos Probando el LCD.
  lcd.print("Probando el LCD.");
 
  // Esperamos 2 segundos igual a 2000 milisegundos
  delay(2000);

Se puede hacer casi idéntico, ejjejeje. PEro tengo que preparar una buen librería. Reuqiere tiempo. Poder se puede, para eso me pongo con C directamente y ya está.

 
Pero estas hablando de un LCD alfanumero contra una pantalla grafica, son dos cosas diferentes a controlar. Ademas desde la PC la gran mayoria de programadores tienen toda la capacidad y potencia del microprocesador para poder realizar cualquier tarea, en cambio en los microcontroladores estas limitado, por eso se usan punteros, arreglos o variables, para saber qué hay ahi, en ese lugar, o sabiendo de antemano qué es lo que hay, y con qué reemplazar, un ejemplo seria mostrar la temperatura sin limpiar (lcd.clear(); ) el LCD...
 
Última edición:
Lo tengo en cuenta lo que dices.

La consola, trabajar con la consola, como si fuera el CMD de Windows, se comporta como los LCD, muy igual. No igual pero se puede hacer, lo tengo comprobado.

No te preocupes por estas cosas, lo tengo muy encuenta, por eso lo trabajo, porque es similar, mucho. Hasta con la calculadora de CASIO que a parte de usar el Q Basic de antes, añadieron ya hace tiempo el C. En todos lados está el C, si no tienes C, no eres el mismo. (Es un decir, ;)).

Un ejemplo de un LD de 16x2.

LCD de 20x4.

Cosas como estas se puede hacer en la consola de Windows sin problemas. A partir de los vídeos de abajo, no son mios.

La pantalla de arriba, lo hice con C# y muestro el código de abajo. Hacerlo en C/C++ es muy similar.
C#:
using System;
using System.Timers;

namespace Desplazmiento_de_texto_consola_01
{
    class Program
    {
        private static Timer timer;
        private static readonly string TEXTO_DE_PRUEBA = "Texto de Prueba";
        private static string textoMostrado = "";
        private static int posicion = 19;
        private static readonly int sentido = -1;

        static void Main(string[] args)
        {
            Console.SetWindowSize(20, 5);
            Console.CursorVisible = false;

            timer = new Timer
            {
                Interval = 250,
                AutoReset = true
            };
            timer.Elapsed += new ElapsedEventHandler(Timer_Elapsed);
            timer.Enabled = true;

            Console.ReadKey();
        }

        private static void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (posicion + TEXTO_DE_PRUEBA.Length - 1 < 20)
            {
                Console.SetCursorPosition(posicion + TEXTO_DE_PRUEBA.Length - 1, 1);
                Console.Write(" ");
            }

            posicion += sentido;

            if (posicion == 20)
            {
                posicion = -TEXTO_DE_PRUEBA.Length + 1;
            }
            else if (posicion == -TEXTO_DE_PRUEBA.Length)
            {
                posicion = 20;
            }

            if (posicion == 0)
            {
                timer.Enabled = false;
            }

            if (posicion < 0)
            {
                textoMostrado = TEXTO_DE_PRUEBA.Substring(-posicion);
            }
            else if (posicion + TEXTO_DE_PRUEBA.Length >= 20)
            {
                textoMostrado = TEXTO_DE_PRUEBA.Substring(0, 20 - posicion);
            }
            else
            {
                textoMostrado = TEXTO_DE_PRUEBA;
            }

            Console.SetCursorPosition(posicion < 0 ? 0 : posicion, 1);

            Console.Write(textoMostrado);
        }
    }
}

¿Aqué no se parece nada en Arduino?

Dejo claro que solo mueve el texto de derecha a izquierda.

En Arduino.
C:
void loop() {
  // scroll 13 positions (string length) to the left
  // to move it offscreen left:
  for (int positionCounter = 0; positionCounter < 13; positionCounter++) {
    // scroll one position left:
    lcd.scrollDisplayLeft();  // o su variante lcd.scrollDisplayRight();
    // wait a bit:
    delay(150);
  }

Todo lo que viste en C# arriba sobre el scroll, está metido en una libería, lo puedes meter en una función o método y llamarlo de esta manera exactamente igual que Arduino.
C:
lcd.scrollDisplayLeft();

A la hora de programarlo, se programa muy similar al C. Si uso el C/C++ de Windows, es casi idéntico, ya que el C de Arduino, como sabrás, viene de C/C++.

El C está por todas partes. El más usado es el Java, en estos temás de electrónica, es el C de toda la vida. Eso ya lo sabrás.

Cuando veas más resultados, hablamos. Ahora estoy aprendiendo a diseñar el control de menús y submenús de manera más eficiente posible, usando por ahora el C#, luego me paso a C de Windows y por supuesto con la finalidad de pulirlo hasta las cejas el C de Arduino.

Aquí dejo para que descargues el simulador 20x4. Me comentas tu impresión sobre ello.
Descargar

Saludos compañero. ;)
 
Siempre te tuve como muy buen programador, por eso me extraña la mezcla de lenguajes.
Ahora estoy trabajando, pero apenas pueda lo descargo y pruebo.

Si quieres sacarle el mayor provecho al microcontrolador, usa el AVR Studio o MPLAB, ya que con el Arduino IDE tienes limitado algunos aspectos importantes, si quieres optimizar la libreria del LCD (LiquidCrystal.h, o algo asi), puedes considerar tambien reducir los pines que controlan al LCD, usan I2C o SPI, por ejemplo
 
Lo de reducción de pines, es algo que lo aprendí en los PIC en su día. También I2C en asm.

Lo de mezclar lenguajes, más bien, usar muchos lenguajes, es solo para que la gente toque el más que entienda. Solo imito al LCD. Como dices, está limitado, claro que si, por eso solo en lenguajes de PC, toco y me comporto como si estuviera con un LCD.

Cuando me vez algo conen relación del LCD con C#, F#, VB .net, , C/C++, Java, PowerShell, etc.... Es para que la gente en sus casas sepan de que va y nunca han tocado Arduino. No todo el mundo controla Arduino en C.

Luego, cuando acabe todo lo demás, por ejemplo en C# o C/C++, lo primero que hago es adaptar el C de Arduino al 100 % para que funcione el LCD. Es decir, que la gente sepa, como hacer un menú. Por eso la técnica de hacer primero un esquema a mano, aunque aquí al final también lo hice a ordenador.

Cuando acabe todo al 100 %, es decir, que entienda bien muchas cosas, que aún no domino, estoy en proceso, hago un pedazo de tutorial, sobre el manejo del LCD en general, solo LCD del caracterés, mucho más adelante me meteré en los GLCD, ahora estoy solo con LDC convencional.

Que la gente tenga de forma muy clara, en qué posición puedo mostrar información en el LDC, esos detalles al principio para un novato está muy bien.

Luego, la parte más complicada para mi, es hacer menú y submenús. Hay que dominarlo muy bien, la gente de ahora no está acostumbrada a crear menú y submenús como se hacía en la época del MD-DOS, exceptuando que toquen Linux, que si hoy en día se hacen menús, de esta manera. Includo en la RaspBerry Pi, gracias a ella los electrónicos se apuntan a la fiesta.

La finalidad del futuro tutorial, que la gente aprenda hacer menús y submenús con el LCD, tanto del 16x2 y el 20x4. Y hacer un simulador con C# o otros lenguaje, es solo para aquellas personas que aún no tengan Arduino, Raspberry Pi, PIC, ARM o cualquier dispositivo, es decir, que se descarguen el programa simulando un LCD y lo pruebe en su PC en casa para que vea como funciona, solo con el ejecutable, si quiere ver el código fuente, sea de C#, VB .net, C/C++ el que sea, es para que la gente entienda y se haga una idea del como se hace, simplemente es eso. Por supuesto, el C de Arduino entrá sus ejemplo del menú y submenú.


Espero haberlo dejado claro. No se tu preocupación en el fondo.

A cuidarse campeón. Y no, soy noy bueno en nada, da igual los años que esté trabajando en algún campo..........................siempre............................seré un novato.
 
Última edición:
Buenas, aparte de la discusión entre los lenguajes de programacion jejej si que se puede sin problema alguno, creo que hace la conversion implicita ademas me explico si haces, char x = 12; pues x valdra el caracter 12 de la tabla ascii y si lo haces al contrario int x = 'a' pues x valdra su valor en en tabla ascii. Te referias a eso? Por cierto, existen simuladores de arduino donde sin necesidad de placa puedes probar cosas, a mi no me gustan, pero existen jeje
 

Dr. Zoidberg

Well-known-Papá Pitufo
cuando acabe todo lo demás, por ejemplo en C# o C/C++, lo primero que hago es adaptar el C de Arduino al 100 % para que funcione el LCD. Es decir, que la gente sepa, como hacer un menú. Por eso la técnica de hacer primero un esquema a mano, aunque aquí al final también lo hice a ordenador
La idea de poder diseñar un menú en la computadora para luego migrarlo a Arduino es muy buena....pero lo que es muy malo es que uses C# por que el lenguaje no es parecido al C del Arduino (que en realidad es C++) y la forma correcta de declarar cosas en C# no se parece a lo que se usa en Arduino. Por otra parte, el uso del C++ en Arduino es bastante pobre por la naturaleza del hardware subyacente y toda la API de Arduino utiliza sistemáticamente el patrón de diseño Singleton para la implementación de la gestión de hardware, que si bien no es descabellado ni mucho menos, es lo único de C++ (de POO en realidad) que se utiliza. El código así luce mas claro y limpio que usando C puro y eso es MUY BUENO.

Se puede hacer casi idéntico, ejjejeje. PEro tengo que preparar una buen librería. Reuqiere tiempo.
Y resulta que esa biblioteca que deberías preparar es la que simplificaría el mecanismo de ensayo+migración y es la clave de lo que debés desarrollar para que tu idea de convierta en un verdadero aporte.
 
Eso de buena idea o no, lo de C# y C de Arduino, simplemente es buena idea para los que entiendan C#, para los que no lo entiendan, no es buena idea, por eso haré adaptación de más lenguajes. Mi idea principal es mostrar la aplicación.exe para ejecutarlo en Windows, no mostrar el código fuente de C#, solo como demo de lo que podría hacer LCD para Arduino, si no lo tienen comprado aún o si están indecisos, luego me di´por mostrar el código.

Ejemplo de mostrar un texto en pantalla o LCD.

Lenguaje C#:
C#:
Console.Wirte("¡Hola Mundo!");

Lenguaje C de PC:
C:
printf("¡Hola Mundo!");

Lenguaje C++ de PC y Arduino para hacer librerías o programar directamente Atmel:
C++:
cout << "¡Hola Mundo!";

Lenguaje C/C++ CLR .net de PC:
Código:
Console::Write("¡Hola Mundo!");

Lenguaje C Arduino IDE:
C:
lcd.print("¡Hola Mundo!");

Ejemplo C# con comando de Arduino C para mostar texto LCD:
C#:
using System;

namespace Funciones_Arduino_consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            // Comando de Arduino C para mostrar texto LCD.
            lcd.printf("Hola mundo.");
        }
    }
}

Mi idea al principio como dije algo arriba, solo mostrar el ejecutable simulador de LCD para pantallas LCD 20x4, 16x2 sin mostrar el código fuente, luego muestro el código fuente solo de Arduino C. Simplemente descargar la demo en PC, progar el ejecutable en tu escritorio de Windows como funciona los menú y submenús, más tener la idea como será en el LCD de Arduino.

Hay más ideas, imitar con C#, los comandos del lcd del Arduino C. Así se parecerá en C#, para que les resulte familiar, por ejemplo, que C# tenga las mismas instrucciones que en C de Arduino, es decir, que en C# si quieres imprimir un texto en LCD, que se llame igual en C.

En C#, o otro lenguaje, en vez de poner este comando Console.Wirte("¡Hola Mundo!") para imprimir texto, se pone uno igual al de Arduino C que es este lcd.print("¡Hola Mundo!"); Así la mayoría se familiariza rápido.

Esto ya es otra historia.

En resumen de mi objetivo:
1. Crear un ejecutable en el que se pueda simular un LCD de Arduino para probar esta demo y mostrar la idea de como tener una idea de crear menús y submenús para sus proyectos.

2. Tendrá su código de C de Arduino completo. No le queda más remedio que usar Proteus para simular un LCD y ver como funciona los menú y submenús. Esto para los que aún no tienen Arduino y están curioseando este mundo. Si no tiene Proteus o no quiere tenerlo, sino de forma sencilla probar el funcionamiento de un menú y submenú, como dije arriba, descargar la demo en PC y probar de forma rápida y cómoda. Algunos solo les basta con mostrale un vídeo de que va y ya está.

3. Se hará con varios lenguajes de programación. Porque hay gente que pide su lenguaje preferido para PC, hay gente y gente, incluido hasta para PowerShell.

4. Conversión desde C# simulando códigos de Arduino. Muy básico y centrado en menús y submenús, no funciones operativas, si no, me pego media vida. Ahora estoy en cuarentena y aprovecho.

5. Hacer un tutorial sobre el Arduino con LCD, características y funcionamiento interno, a parte de ello, los comandos de ejemplos sobre el control del LCD. Se incluye ejemplos de hacer menú y submenús con Arduino IDE, ejemplos reales, en el cual mostraré fotos y vídeos sobre Arduino y LCD en funcionamiento en todo el menú más configuraciones. Aquí usar EEPROM para alacenamiento de datos, tipo configuración o indicar el nombre de un relé que quieres guardar en pantalla. Cositas.

6. El tutorial se entregará en pdf con todos los ejemplos para que prueben sus proyectos. Un ejemplo para que se hagan una idea de como será de explicativo.

;)
 
Última edición:
Claro, lo que quieres es un interprete de lenguaje C++ de Arduino, para crear un simulador. Si hubieses empezado por ahi... 😅

Esta muy buena la idea. Lo unico que recuerda que cada uno hace diferente formas los menu, asi que tienes que tener un interprete muy potente, a menos que sea de solo lectura el codigo, y ahi tienes que crear lo mas optimo el codigo para los mas avanzados, y para los novatos codigo facil y entendible, con posibilidad de agregar comentarios a cada paso asi se va entendiendo.
Otra cosa seria las declaraciones de variables, la inclusion de librerias, codigo en la secciones "setup" y en "loop", aparte de las funciones para el menu propiamente.
Para la parte avanzada, seria usar maquina de estado con timers o similar para evitar meter todo en "loop".

Con respecto a la consulta original, en las funciones propias de la libreria del LCD hacen la lectura char a char del texto, si conoces las librerias de PICC conoces como funciona entonces.
Te recomiendo ir al github de Arduino para que veas como funciona cada libreria...
 
Todo lo que cuenta lo estoy aprendiendo. En temas de poner comentarios en cada línea de código, no te preocupes, precisamente es lo que suelo hacer, no solo para mi mismo, si no, para los demás, como dices, para que se entienda.

El tema de llamar las variables de C# y Arduino que no son iguales, si casi iguales, por ahora no comento nada porque no me he metido, voy por partes. Si me preocupa el setup" y en "loop" para que los demás lo entiendan.

Dentro de C# o otro lenguaje, aunque aquí ponga un ejemplo dentro de la misma estructura, puedo hacerlo desde un archivo externo llamado clase.cs, en C++ se llama archivo.cpp con el cabecera.h.

C#:
using System;

namespace Prueba
{
    class Program
    {
        static void Main(string[] args)
        {
            setup();
            while (true)
            {
                loop();
            }
        }

        private static void setup()
        {
          // put your setup code here, to run once:
        }

        private static void loop()
        {
          // put your main code here, to run repeatedly:
        }
    }
}

;)
 
Arriba