Pregunta:
Mi código parece ser un accidente de tren
pvGuy
2019-11-29 13:18:12 UTC
view on stackexchange narkive permalink

Soy nuevo en programación y pensé que un proyecto simple sería crear un contador de munición. He estado solucionando este código durante varias horas y no puedo entender por qué mi código está plagado de errores. A continuación se muestra mi programa. Por favor, échele un vistazo y dígame qué error he cometido. Publicaré el informe de error debajo de mi programa. Me disculpo por mi mala programación de antemano y espero que todavía haya esperanza para mí con la tutela adecuada. El programa funcionó bien cuando ejecuté una prueba usando solo una función guardada, "twentyBullets ()". Después de agregar 30 funciones adicionales y crear una cadena de condiciones if-else-if, el programa comenzó a informar todo tipo de errores. 

  / * ¡CÓDIGO DE MANEJO DE PANTALLA DE 7 SEGMENTOS! El siguiente código maneja la pantalla de 7 segmentos para el contador de munición digital. A ___ F | | B G --- G E | ___ | C D Arriba está la asignación de letras del alfabeto para los diferentes segmentos de la pantalla B07BMPPNQY. El proyecto de contador de munición digital utilizará pines comunes, L3 y L4. * / // Mostrar declaración de pin. // P_: Donde P indica la salida del pin para el segmento de la pantalla a iluminar seguido de una letra minúscula // que indica qué led específico en el segmento iluminar. // diez: donde diez indica el lugar de la decena en la pantalla de 7 segmentos. // uno: donde uno indica el lugar de uno en la pantalla de 7 segmentos, int Pa = 0; int Pb = 1; int Pc = 2; int Pd = 3; int Pe = 4; int Pf = 5; int Pg = 6 ; int diez = 7; int uno = 8; int ammo = 10; void setup () {// ponga su código de configuración aquí, para que se ejecute una vez: pinMode (Pa, OUTPUT); pinMode (Pb, OUTPUT); pinMode (Pc , OUTPUT); pinMode (Pd, OUTPUT); pinMode (Pe, OUTPUT); pinMode (Pf, OUTPUT); pinMode (Pg, OUTPUT); pinMode (diez, OUTPUT); pinMode (uno, OUTPUT);} bucle vacío ( ) {// ponga su código principal aquí, para que se ejecute repetidamente: if (ammo == 1) {oneBullet (); } más si (munición == 2) {dos balas (); } más si (munición == 3) {tres balas (); } else if (munición == 4) {fourBullets (); }
si no (munición == 5) {cinco balas (); } else if (munición == 6) {sixBullets (); } else if (munición == 7) {sevenBullets (); } más si (munición == 8) {ocho balas (); } else if (munición == 9) {nineBullets (); } else if (munición == 10) {tenBullets (); } else if (munición == 11) {onceBullets (); } más si (munición == 12) {doce balas (); } else if (munición == 13) {treceBullets (); } más si (munición == 14) {catorce balas (); } else if (munición == 15) {quinceBullets (); } else if (munición == 16) {dieciséisBullets (); } más si (munición == 17) {diecisieteBullets (); } más si (munición == 18) {dieciocho proyectiles (); } más si (munición == 19) {diecinueve balas (); } más si (munición == 20) {veinte balas (); } más si (munición == 21) {veintiunoBullets (); } más si (munición == 22) {veintidós balas (); } más si (munición == 23) {veintitrés balas (); } más si (munición == 24) {veinticuatro balas (); } más si (munición == 25) {veinticinco balas (); } más si (munición == 26) {twentysixBullets (); } más si (munición == 27) {veintisiete balas (); } más si (munición == 28) {veintiochoBullets (); } más si (munición == 29) {veinticinco balas (); } más si (munición == 30) {treinta balas (); } else {zeroBullets (); }} void zeroBullets () // 0 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void oneBullet () // 1 {digitalWrite (one, LOW); digitalWrite (diez, ALTO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA);
escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void twoBullets () // 2 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void threeBullets () // 6 {digitalWrite (one, LOW); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void fourBullets () // 4 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void fiveBullets () // 5 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); escritura digital (Pb, ALTA); digitalWrite (Pc, BAJO);
digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void sixBullets () // 6 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, ALTA); escritura digital (Pb, ALTA); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void sevenBullets () // 7 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void eightBullets () // 8 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void nineBullets () // 9 {digitalWrite (one, LOW); digitalWrite (diez, ALTO);
escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); retraso (10); // 0 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); delay (10);} void tenBullets () // 0 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void onceBullets () // 1 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void doceBullets () // 2 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10);}
void treceBullets () // 3 {digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} anular catorceBullets () // 4 {digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void quinceBullets () // 5 {digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); escritura digital (Pb, ALTA); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void sixteenBullets () // 6 {digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); escritura digital (Pb, ALTA); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA);
escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void diecisieteBullets () // 7 {digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void dieighteenBullets () // 8 {digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void nineteenBullets () // 9 {digitalWrite (one, HIGH); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 1 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); delay (10);} void twentyBullets () // 0 {digitalWrite (one, LOW); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA);
digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentyoneBullets () // 1 {digitalWrite (one, LOW); digitalWrite (diez, ALTO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentytwoBullets () // 2 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void veintitrésBullets () // 3 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentyfourBullets () // 4 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, ALTA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 2
digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentyfiveBullets () // 5 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); escritura digital (Pb, ALTA); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentysixBullets () // 6 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); escritura digital (Pb, ALTA); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentysevenBullets () // 7 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, ALTA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentyeightBullets () // 8 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA);
digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void twentynineBullets () // 9 {digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); escritura digital (Pd, ALTA); escritura digital (Pe, ALTA); digitalWrite (Pf, BAJO); escritura digital (Pg, BAJA); retraso (10); // 2 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, ALTA); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);} void treintaBullets () // 0 digitalWrite (uno, BAJO); digitalWrite (diez, ALTO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, BAJA); digitalWrite (Pf, BAJO); escritura digital (Pg, ALTA); retraso (10); // 3 digitalWrite (uno, ALTO); digitalWrite (diez, BAJO); escritura digital (Pa, BAJA); digitalWrite (Pb, BAJO); digitalWrite (Pc, BAJO); digitalWrite (Pd, BAJO); escritura digital (Pe, ALTA); escritura digital (Pf, ALTA); escritura digital (Pg, BAJA); delay (10);}

EL INFORME DE ERRORES: 

  Arduino: 1.8.10 (Windows 10), Placa: "Arduino / Genuino Uno" Digital_Ammo_Counter .ino: En la función 'void loop ()': sketch_Digital_Ammo_Counter: 138: 4: error: 'treintaBullets' no se declaró en este ámbito treintaBullets (); ^ ~~~~~~~~~~~~ sketch_Digital_Ammo_Counter.ino: 138: 4: nota: alternativa sugerida: 'twentyBullets' treintaBullets (); ^ ~~~~~~~~~~~~ twentyBulletssketch_Digital_Ammo_Counter.ino: En el ámbito global: sketch_Digital_Ammo_Counter: 898: 3: error: inicializador esperado antes de 'digitalWrite' digitalWrite (uno, LOW); ^ ~~~~~~~~~~~
sketch_Digital_Ammo_Counter: 899: 15: error: se esperaba la conversión de constructor, destructor o tipo antes de '(' token digitalWrite (diez, HIGH); ^ sketch_Digital_Ammo_Counter: 900: 15: error: constructor, destructor o conversión de tipo esperado antes de '(' token digitalWrite (Pa, LOW); ^ sketch_Digital_Ammo_Counter: 901: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pb, LOW); ^ sketch_Digital_Ammo_Counter: 902: 15: error: constructor esperado, destructor, o conversión de tipo antes de '(' token digitalWrite (Pc, LOW); ^ sketch_Digital_Ammo_Counter: 903: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pd, LOW); ^ sketch_Digital_Ammo_Counter: 904: 15 : error: constructor, destructor o conversión de tipo esperado antes de '(' token digitalWrite (Pe, LOW); ^ sketch_Digital_Ammo_Counter: 905: 15: error: constructor, destructor o conversión de tipo antes de '(' token digitalWrite (Pf, LOW); ^ sketch_Digital_Ammo_Counter: 906: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pg, HIGH); ^ sketch_Digital_Ammo_Counter: 907: 8: error: constructor esperado, destructor o conversión de tipo antes de '(' token delay (10); ^ sketch_Digital_Ammo_Counter: 910: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (one, HIGH); ^ sketch_Digital_Ammo_Counter: 911: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (diez, LOW); ^ sketch_Digital_Ammo_Counter: 912: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pa, LOW); ^ sketch_Digital_Ammo_Counter: 913: 15: error: se esperaba conversión de constructor, destructor o tipo antes de '(' token digitalWrite (Pb, LOW); ^
sketch_Digital_Ammo_Counter: 914: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pc, LOW); ^ sketch_Digital_Ammo_Counter: 915: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pd, LOW); ^ sketch_Digital_Ammo_Counter: 916: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pe, HIGH); ^ sketch_Digital_Ammo_Counter: 917: 15: error: constructor esperado, destructor, o conversión de tipo antes de '(' token digitalWrite (Pf, HIGH); ^ sketch_Digital_Ammo_Counter: 918: 15: error: constructor esperado, destructor o conversión de tipo antes de '(' token digitalWrite (Pg, LOW); ^ sketch_Digital_Ammo_Counter: 919: 8 : error: se esperaba conversión de constructor, destructor o tipo antes de '(' token delay (10); ^ sketch_Digital_Ammo_Counter: 920: 1: error: declaración esperada antes de '}' token} ^ estado de salida 1'thi rtyBullets 'no se declaró en este ámbito. Este informe tendría más información con la opción "Mostrar salida detallada durante la compilación" habilitada en Archivo -Preferencias de >.
La forma en que se formateó esto arruinó absolutamente la copia / pegado de mi programa y mi informe de errores. Si desea ayudarme y necesita ver algo que se parezca más a mi programa real y / o informe de errores, puedo hacer arreglos para enviar por correo electrónico cualquiera de los documentos.
upvote por verificar el formato de su código publicado ... tantas personas simplemente no se preocupan si el código es legible ... ponga tres comillas invertidas `` en una línea sobre su código y tres comillas invertidas en una línea después tu codigo
también puede seleccionar todo el código y hacer clic en el botón `{}`
He formateado el código para ti. +1 por cuidar
¡Muchas gracias a todos! Tendré en cuenta las correcciones de formato de ahora en adelante y gracias, amable persona, por tomarse la libertad de formatear mi código por mí.
No se sienta mal por la falta de un tirante. Eso hace que la mayoría de los compiladores "pierdan la cabeza", generando un montón de mensajes de error muy confusos y puede ser muy difícil de localizar. He estado programando en lenguajes C y similares a C durante más de 30 años, y este problema exacto todavía me ataca de vez en cuando.
¡Jaja gracias! Sí, supongo que todos somos víctimas de un simple descuido de vez en cuando. Con más experiencia, estoy seguro de que podré reconocer errores como este más rápidamente. ¡Me alegra que la comunidad sea tan buena! ¡Debo decir que no esperaba todo el apoyo que he recibido! Es fantástico y espero que yo también pueda ser de alguna ayuda para la próxima generación de entusiastas principiantes de la electrónica.
Es útil que haya proporcionado una descripción completa de su problema. Muchos carteles para principiantes publican mensajes vagos de "Intenté ... pero no funciona", y luego se necesita un juego agotador de 20 preguntas para descubrir qué significa realmente "no funciona"
Si bien soy consciente de que una revisión de código no es lo que se solicita, le recomiendo encarecidamente que reconsidere su enfoque aquí. Copiar / pegar código debería ser una señal de alerta inmediata para sugerir que necesita abordar esto de manera más inteligente. Una sugerencia básica que puede abordar como principiante sería un método que imprima un dígito dado (y luego su lógica numérica se convierte en lógica dígito + dígito). Si trabaja con el código inflado y aumentado que tiene ahora, cualquier cambio o error tomará mucho más tiempo del que debería. ¿Qué pasa si puedes tener hasta 99 balas mañana?
Aquí hay algunos consejos que les doy a todos mis estudiantes: Los compiladores compilan programas sintácticamente correctos y detectan e informan errores básicos, pero * son inútiles para permitir los errores que ya han visto. * Un error simple, como la llave faltante , a menudo puede causar toda una cascada de mensajes de error que parecen no estar relacionados con el error original. Corrija el primer error (o 2, si nota que el 2d es real) y vuelva a compilar. Encontrará ese error con "toneladas de mensajes de error" bastante rápido y ahorrará mucho tiempo al intentar analizar los siguientes fragmentos de código correctos.
El mejor consejo que puedo dar es que, una vez que el código se compile (y yo personalmente no tolero ninguna advertencia, nunca), es aprender a usar el depurador. Es tu mejor amigo en todo el mundo. Establezca "puntos de interrupción", ejecute su código y se detendrá cuando encuentre puntos de interrupción, momento en el que puede examinar la pila de llamadas, leer e incluso cambiar el valor de las variables y más. Es, con mucho, la mejor manera de obtener información sobre lo que está haciendo su código.
Cuatro respuestas:
chrisl
2019-11-29 14:33:44 UTC
view on stackexchange narkive permalink

La cascada de errores se debe a la falta de un corchete de apertura { al comienzo de la función treintaBullets () . Esto hace que el nombre de la función no se declare y también fallan las siguientes llamadas de función a digitalWrite () . Poner este corchete de apertura faltante debería corregir todos los errores (aunque no puedo probarlo ya que actualmente no tengo un compilador a mano).

Además de eso, su código se puede acortar mucho con un truco. Actualmente utiliza una función para cada número, donde escribe los pines digitales correspondientes. Entonces, la situación es que siempre necesita escribir en los mismos pines, solo valores diferentes dependiendo de un número entero simple sin signo. Entonces sugiero que defina los patrones de pines para los dígitos en una matriz bidimensional. Entonces puede usar solo 1 función para generar cualquiera de ellos. Te daré un ejemplo: 

  uint8_t led_pattern [10] [7] = {{0, 0, 0, 0, 0, 0, 1}, // patrón para el dígito 0 {1, 0, 0, 1, 1, 1, 1}, // patrón para el dígito 1 {0, 0, 1, 0, 0, 1, 0}, // patrón para el dígito 2 ... { 0, 0, 0, 0, 1, 0, 0}}; // patrón para el dígito 9void display_digit (uint8_t posición, uint8_t dígito) {digitalWrite (uno, posición); // Escribe bajo (también conocido como cero) en el pin uno, cuando la posición es cero, si no es alto digitalWrite (diez,! Posición); // Escribe bajo en el pin diez, cuando la posición es mayor que cero, si no alto para (uint8_t i = 0; i<7; i ++) {digitalWrite (i, led_pattern [digit] [i]); } retraso (10);} void display_number (uint8_t número) {display_digit (0, número% 10); display_digit (1, number / 10);} void loop () {display_number (munición);}

Entonces, ¿qué está pasando aquí?

Primero definimos los patrones de LED en una matriz bidimensional. Su primer índice es el dígito que queremos mostrar; su segundo índice es el número del LED que se enciende. El valor entonces es el estado del LED correspondiente. Escribí 1 y 0 , porque es corto. También puede escribir HIGH y LOW (ya que estos también se definen solo para 1 y 0 ). Entonces, el patrón {1, 0, 0, 1, 1, 1, 1} significa que solo los segmentos byc tienen una salida baja, por lo que están activados.

Luego definimos una función para mostrar un dígito. Toma la posición del dígito y el dígito real (0 a 9) como parámetros. Escribimos las dos salidas para nuestra posición directamente con la variable. Esta es una forma muy corta de hacerlo y no funciona cuando tienes más de 2 dígitos. Si desea extender su contador un día, puede reemplazar estas 2 líneas por una construcción diferente (por ejemplo, una declaración de caso de cambio). Luego hacemos un bucle for de 0 a 6, de modo que recorremos todos los dígitos. En su caso, usa los números de PIN del 0 al 6, por lo que podemos usar directamente i como número de PIN. (Si desea utilizar otros pines, puede guardar esos pines en una matriz y hacer referencia a los valores en la matriz con i ). En cada iteración del bucle for, escribimos el valor del dígito y el LED correspondientes en el pin de salida correspondiente. Después de eso, solo demoramos un poco y salimos de la función.

Para hacerlo más fácil, también definí la función display_number () , que mostrará el número completo, mostrando sus dígitos sucesivamente en las posiciones correspondientes. Si eres un principiante, es posible que no reconozcas los cálculos que hice allí. El operador de módulo % devuelve el resto de una división entera. Entonces, si tomo 23% 10 , esto devolvería 3 (la división de enteros 23/10 es 2 y el resto es 3). Esto nos da el primer dígito (menos significativo). Entonces podemos obtener el segundo dígito simplemente haciendo una división entera con 10, ya que cortará la parte después del punto decimal. Si desea mostrar números superiores a 99 un día, debe cambiar ambas funciones para adaptarse a eso.

Tenga en cuenta que utilicé uint8_t como tipo en todas partes. Este es solo el tipo de número sin signo más pequeño (8 bits de ancho). Usé el más pequeño, ya que aquí no necesitas números mayores y ahorra un poco de memoria. Cuando desee ampliar su pantalla para mostrar valores superiores a 255, debe cambiar el tipo del parámetro número en la función display_number () a un tipo mayor, por ejemplo unsigned int (que tiene 16 bits de ancho).

También tenga en cuenta que no he probado este código, ya que actualmente no tengo un compilador o Arduino a mano.

Entonces, ahora puede mostrar un número en su dígito con solo una llamada de función y no necesita cerca de 1000 líneas de código para ello.

Al extender su código para hacer más cosas, además de mostrar números, puede llegar fácilmente al punto en el que usar delay () es algo malo, ya que Arduino no puede hacer nada más durante ese tiempo. Luego, necesita reescribir su código para evitar delay () y usar la función millis () en su lugar para desbloquearlo. Hay toneladas de tutoriales para esto y solo quería mencionarlo.

¡Buen señor! ¡Me estoy pateando el trasero con fuerza por olvidar algo tan humilde como un "{"! Me ha causado un gran sufrimiento. Me inclino ante su conocimiento de Arduino y gracias no solo por encontrar el error en mi código, sino también por mostrarme una forma mucho mejor de realizar todo el proceso. ¡Tienes mi más sincero agradecimiento! ¡Vaya, definitivamente profundizaré en los tutoriales sobre Arduino! ¡Con suerte, estaré tan bien informado como tú sobre el tema en algún momento!
Gracias, pero basta de elogios. Todos comenzamos en ese punto. Se trata de la experiencia de aprendizaje. Puede aceptar mi respuesta como correcta, si cree que es correcta. Y tal vez quieras volver algún día y también responder a tu pregunta. Siempre estamos felices de encontrar nuevos colaboradores: D
Enhorabuena, proporcionando tanto la respuesta con un enfoque limitado como una guía sobre el uso de matrices para resolver el problema de manera más elegante. (votado.) Supongo que no vamos a intentar guiar a un principiante a través de la decodificación binaria usando enmascaramiento y desplazamiento de bits ...
* ya que actualmente no tengo un compilador a mano) * Sugiero https://godbolt.org/, el explorador de compiladores de Matt Godbolt. Tiene instalados GCC, Clang, MSVC e ICC, incluido GCC para ARM y AVR. Con resaltado de color para hacer coincidir las líneas de origen con las líneas de salida del conjunto. (E idiomas que incluyen C, C ++, Rust, Go, Haskell, ...) Su código compilado como C para ARM cortex M3: https://godbolt.org/z/-K_muB
gnasher729
2019-12-02 05:30:18 UTC
view on stackexchange narkive permalink

Encontraste el error, pero ¿cómo pudiste encontrarlo más fácil?

El paso más importante mentalmente es aceptar que usted hizo algo mal. Aún no sabemos qué, pero es muy poco probable que el compilador se queje del código correcto. Entonces la pregunta es: ¿Qué hiciste mal?

El compilador se quejó de una función "treintaBullets". No se quejó de "twentynineBullets". No se da cuenta de que hay una función "treinta balas". Lo primero es revisar la ortografía. Si nombró la función "thirrtyBullets" por error, eso explicaría las cosas. Pero el nombre es correcto.

Entonces verá que el compilador se queja de la línea inmediatamente después del inicio de la función. Es difícil averiguar de qué se queja el compilador, por lo que algo que hizo justo antes lo confundió. Así que ahora marca la línea "void treintaBullets ()", está bien, la siguiente línea "digitalWrite (one, LOW);" se ve bien, pero algo DEBE estar mal aquí, y ahí es donde, con suerte, descubrirás el "{" que falta.

Artelius
2019-12-02 16:47:29 UTC
view on stackexchange narkive permalink

Solo para agregar a la idea de usar una matriz, ya que a C no le importan los espacios en blanco, puede formatear sus datos fácilmente de esta manera: 

  uint8_t led_pattern [10] [7] = {{0, // patrón para el dígito 0 0, 0, 0, 0, 0, 0}, {0, // patrón para el dígito 1 0, 1, 0, 0, 1, 0}, {1, // patrón para el dígito 2 0, 1, 1, 1, 0, 1}, ...};

Este es un ejemplo del "buen hábito" de hacer su código sobre su intención en lugar de sobre instruir a la máquina. Puede dedicar un 50% más de tiempo a aclarar su código o dedicar un 500% más de tiempo a depurarlo. Como dice el refrán,

Hay dos formas de desarrollar software: Hágalo tan simple que obviamente no haya errores, o tan complejo que no haya errores obvios.

Nota: El código anterior le dará sus valores de digitalOut en un orden diferente al de sus pines (por lo que el ciclo for de Chrisl no funcionará). simplemente haga manualmente 7 escrituras digitales en los pines correctos al mostrar el digit.

  digitalWrite (<pin number>, led_pattern [digit] [<led position>]);
RDragonrydr
2020-06-18 21:07:41 UTC
view on stackexchange narkive permalink

Su código en realidad no es malo. No hay muchas buenas formas de hacer este tipo de mapeo de pines, y las pocas que tienen también tienen sus propias desventajas. El problema principal fue el corchete que faltaba, que encontré al verificar la función drawThirty, ya que se mencionó específicamente y tenía errores en cascada que implican un punto y coma o un corchete omitidos.

Un ajuste más es que su código solo funcionará en Arduino (entonces estás bien, pero un IDE diferente puede enojarse contigo). C no busca nombres de funciones en todo el archivo, por lo que si declara / define la función después de usarla, se producirá un error. Arduino usa un pre-analizador especial para arreglar esto por usted.

La forma correcta es declarar hacia adelante la función de la siguiente manera: 

  int returnAPieceOfData (byte x, char c, int i); // Ahora C sabe que existe en algún lugar y no cometerá errores.void foo () {// en algún lugar de aquí necesitas returnAPieceOfData} int returnAPieceOfData (byte x, char c, int i) {// Tú ahora defina la función después de que se use, ¡pero no tenga errores!}

Esto generalmente da como resultado un archivo C donde todas las funciones se declaran en la parte superior, y luego las definiciones de función a continuación pueden usarse ellos en cualquier orden sin problemas. También facilita saber si el archivo tiene una función, y si los agrega en el mismo orden, dónde está.

Mencionaré un método potencialmente útil para implementar alternativamente la tabla de búsqueda de matrices para escribir los pines. Las anteriores son muy buenas sugerencias, especialmente el espacio en blanco con forma, pero ese enfoque usará mucha memoria adicional porque usa bytes completos por píxel.

Si está dispuesto a aceptar un formato que sea algo más difícil de visualice, podría codificar todo el espacio en un solo byte, que mostraré a continuación. También puede poner los números de pin en una matriz para que pueda usar un bucle FOR.

Básicamente, tiene dos opciones al escribir este tipo de sistema. Puede optar por la complejidad del código, que es lo que hizo su ejemplo, o puede optar por la complejidad de la memoria / datos, que estoy mostrando aquí. Las desventajas de ESTA técnica son que los datos son algo misteriosos y difíciles de modificar (ya que están codificados y hay muchos), y que usa memoria adicional para almacenar esos datos. 

  vacío drawAllSegments (byte ammo_ct) {byte hi = ammo_ct / 10; byte lo = ammo_ct% 10; drawLowSegments (lo); drawHighSegments (hi);} byte lpinNums [] = {apin, bpin, cpin, dpin, epin, fpin, gpin}; // pins para 0s displaybyte hpinNums [] = {apin, bpin, cpin, dpin, epin, fpin, gpin}; // pines para 10s displaybyte numbers [] = {0b00111111,0b01111001, ...}; // Formatea los "números" como 0bXGFEDCBA, donde X es un indiferente // (su valor nunca se usa y puede ser 0 o 1) // Mi ejemplo puede ser incorrecto. Creo que es lógica negativa, pero también podría haber cometido un error además de eso.void drawLowSegments (byte ammo_ct) {digitalWrite (one, HIGH); // configura la pantalla select digitalWrite (diez, LOW); for (byte i = 0; i<7; i ++) {// ¡luego dibuja! byte state = (numbers [ammo_ct] >>i) &0x01; // descomprime el estado de ese segmento digitalWrite (lpinNums [i], state); }} void drawHighSegments (byte ammo_ct) {digitalWrite (uno, HIGH); // configura la pantalla select digitalWrite (diez, LOW); for (byte i = 0; i<7; i ++) {// ¡luego dibuja! byte state = (numbers [ammo_ct] >>i) &0x01; // descomprime el estado de ese segmento digitalWrite (hpinNums [i], state); }}

Las ventajas de este enfoque es que el código es tan compacto como el sistema de matriz, pero utiliza 1/8 de la RAM para esa matriz. No imagino que estés haciendo algo que use mucha RAM, pero es una buena idea minimizarlo siempre que sea posible. En este caso, también es mucho más ampliable, ya que puede incluir más números antes de quedarse sin RAM.

También puede cambiar a PROGMEM, pero leer eso es un poco extraño de alguna manera y es fácil olvidarse de leerlo en primer lugar (lo que da como resultado lecturas de RAM aleatoria). En este caso, debería ser lo suficientemente pequeño como para que no se requiera una mayor optimización.

Una última nota es que, si alguna vez hace algo para el que un byte es demasiado pequeño, puede usar números más grandes hasta el uint32_t, que tiene 32 bits de píxeles útiles, o potencialmente el uint64_t, que es de 64 bits, pero puede que no sea compatible con Arduino (nunca probé este último).



ⓘ
Esta pregunta y respuesta fue traducida automáticamente del idioma inglés.El contenido original está disponible en stackexchange, a quien agradecemos la licencia cc by-sa 4.0 bajo la que se distribuye.
Loading...