Duda . Como lo hago?

[pibe]

Hola gente-
Necesito una ayudita para hacer lo siguiente:

Variable A, B, C

Asignarle Tabla1 (cadena de datos constantes) a A.
Asignarle Tabla2 (cadena de datos constantes) a B.
Asignarle Tabla2 (cadena de datos constantes) a C.

Switch :

Ejecuto Variable A

Cuando pulso entonces
Ejecuto Variable B

Si pulso otra vez
Ejecuto Variable C

Si vuelvo a pulsar vuelvo al principio (ejecuto Variable A)

Bucle infinito del switch

Fin del programa y agradecimientos XD
Es que estuve trasteando, pero la voy liando cada vez peor y terminaré con el programa inestable y parcheado por doquier

[KILLERJC]

No entiendo a lo que queres llegar con "Ejecuto" tal ves acceder a esa variable? O es un programa ?

Por que a las variables A,B,C estas asignandole datos nomas.

Resuelto el dilema anterior pasamos a la solucion.

[pibe]

Como ves, no entiendo un pomo de C.
Las tablas contienen datos ... ah... ahora voy entendiendo! No puedo meter toda esa cadena en una variable.

Voy leyendo la tabla , lleno la variable con el dato y la ejecuto. (ejecutar es hacer algo con su contenido)

Bien, vamos a reintentarlo:

Tengo
Variable BUFFER


Tabla A (01, 02, 04, F9, Etc)
Tabla B ( 41, 5F, 30, 00, etc)
Tabla C ( mas de lo mismo, etc)

Main
Ir cargando valores de Tabla A en Buffer
ejecutar Buffer hasta el final de la tabla.

Si se pulsó Pulsador entonces
Ir cargando valores de Tabla B
ejecutarlos hasta el final de la tabla.

Si se pulsó Pulsador entonces
Ir cargando valores de Tabla C
ejecutarlos hasta el final de la tabla.

Si se pulsó Pulsador entonces
Volver a Main

ES un programa que ejecuta distintas frecuencias, cada constante indica la frecuencia de salida. Es señal de audio y encadenadas crean una melodia. En este caso 3 melodias distintas, seleccionable por medio de un pulsador.

[KILLERJC]

Entonces que tal esto?

Código: C

1. uint8_t Tablas[3][10] = {.....}, {.....}, {.....};

O si queres tenerlo separadas a las tablas usas:

Código: C

1. uint8_t TablaA[10] = {.....};
2. uint8_t TablaB[10] = {.....};
3. uint8_t TablaC[10] = {.....};
4.  
5. uint8_t * Tablas[3] = {TablaA,TablaB,TablaC};

En tu programa usas algo asi:

Código: C

1. uint8_t i=0;
2.  
3.  
4. while(1)
5. {
6.         if(BotonPresionado)
7.         {
8.                 while(BotonPresionado); //Espero que suelte
9.                 i++;
10.                 if(i>3) i=0;
11.         }
12.  
13.         //Aca uso los datos
14.  
15.         Envio(Tablas[i][numero_de_dato]);
16. }

Seguramente el codigo del boton no te sea el correcto ya que de tenerlo presionado se quedaria ahi encerrado, pero se podria modificar para que eso no ocurra.

[pibe]

Buenisimo, mañana lo pruebo que son las 2am y piro a dormir. Muchas gracias!

[pibe]

Ni ahi. No se como hacerlo.
Se que debo hacer 3 funciones distintas con las 3 tablas, ya que varian algunos datos aparte de la tabla en si.

Código: [Seleccionar]

#ifdef HappyBirthday
    /* HappyBirthday */
    const unsigned char static Melody[] = {"16g,16g,f,g,d6,eb,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6,8g.,16g,a,g,c6,2b,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6"};
    defaultoctave = 5;
    defaultduration = 4;
    beat_speed = 150;
#endif
O sea, tengo 3 defines y solo puedo elegir uno de ellos al compilar. Necesito que esta parte del codigo sea una subrutina y pueda llamarla desde el main con un switch.

[KILLERJC]

Ahh pero vos queres hacer otra cosa.

Si usas defines entonces haces el codigo pensando como si tenes 1 sola tabla. Ya que al compilar deja 1 sola, las demas no van al compilarse. No entiendo por que te la queres complicar tanto.

Pero si quisiera hacer algo como lo que pretendes haria algo asi:

Código: C

1. #ifdef  Tabla1
2. uint8_t TablaA[10] = {.....};
3. #endif
4.  
5. #ifdef  Tabla2
6. uint8_t TablaB[10] = {.....};
7. #endif
8.  
9. #ifdef  Tabla3
10. uint8_t TablaC[10] = {.....};
11. #endif
12.  
13.  
14. uint8_t * Tablas[3] = {0,0,0};
15.  
16.  
17.  
18.  
19. void main(void)
20. {
21.  
22. #ifdef  Tabla1
23.         Tablas[0] = TablasA;
24. #endif
25.  
26. #ifdef  Tabla2
27.         Tablas[1] = TablasB;
28. #endif
29.  
30. #ifdef  Tabla3
31.         Tablas[2] = TablasC;
32. #endif
33.  
34.  
35.         uint8_t i=0;
36.         while (Tablas[i]==0)
37.         {
38.                 i++;    // Busco el primer valor a entregar
39.                 if(i>3)
40.                 {
41.                         while(1);       //Error no se definio ninguna tabla
42.                 }
43.         }
44.  
45.  
46. while(1)
47. {
48.         if(BotonPresionado)
49.         {
50.                 while(BotonPresionado);         //Espero que suelte
51.  
52.                 do                              //Incremento, en caso de que siga siendo 0 que no se pase del indice que dimos, es decir 3
53.                 {
54.                         i++;
55.                         if(i>3) break;
56.                 }while(Tablas[i]==0)
57.  
58.                 if(i>3) i=0;                    // Si se paso se corrija
59.  
60.                 while (Tablas[i]==0) i++;       // Busco el primer valor nuevamente, ya que puede que TablaA y TablaB no esten
61.         }
62.  
63.         //Aca uso los datos
64.  
65.         Envio(Tablas[i][numero_de_dato]);
66. }

Rebuscado y no el uso comun que se les daria a los defines. Esto te permite que que cuando quieras definas Tabla2 y Tabla3 y el programa solo ciclaria entre esas 2 tablas.
Si solo pones un define como seria Tabla2, entonces solo usaria tabla2 por mas que presiones el boton.

[pibe]

Jajaja. Pero es que me quiero quitar los defines de encima porque quiero llamarlos desde el main como funciones

Lo mejor es te pase el programa, porque parecemos locos de manicomio

Código: C

1. #include <xc.h>
2.  
3. #define TONE    GPIObits.GP2
4.  
5. void InitTimer(void);
6. //void delayms(unsigned char cnt);
7. void PlayNote(unsigned short note, unsigned char octave, unsigned int duration);
8.  
9. unsigned char beep;
10. unsigned char preloadTMR1L;
11. unsigned char preloadTMR1H;
12. unsigned short TMR0Count;
13. unsigned char beat_speed;
14.  
15. #define MusicBoxDancer
16. //#define HomeSweetHome
17. //#define HappyBirthday
18. void main(void)
19. {
20.     /* Loop */
21.     while(1)
22.     {
23.     unsigned int pointer = 0;
24.     unsigned int octave = 0;
25.     unsigned int duration = 0;
26.     unsigned short note = 0;
27.     unsigned int defaultoctave = 0;
28.     unsigned int defaultduration = 0;
29.    
30. #ifdef MusicBoxDancer
31.     const unsigned char static Melody[] = {"2c,2g4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2f,2e,2c,2a,2g,g,2c,2c,2c,2b4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2b4,2c,2g4,2e,c.,p,p"};
32.     defaultoctave = 5;
33.     defaultduration = 1;
34.     beat_speed = 220;
35. #endif
36.  
37. #ifdef HomeSweetHome
38.     const unsigned char static Melody[] = {"2c,2d,e.,f,g.,e,g,f,2e,f,d,e.,2c,2d,e.,f,g.,e,g,f,2e,f,d,c.,g,c6,b,a,g,g.,e,g,f,e,f,d,e,g,c,b,a,g,g,e,g,f,e,f,d,e,g,c,b,a,g,g"};//
39.     defaultoctave = 5;
40.     defaultduration = 4;
41.     beat_speed = 200;
42. #endif
43.  
44. #ifdef HappyBirthday
45.     /* HappyBirthday */
46.     const unsigned char static Melody[] = {"16g,16g,f,g,d6,eb,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6,8g.,16g,a,g,c6,2b,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6"};
47.     defaultoctave = 5;
48.     defaultduration = 4;
49.     beat_speed = 150;
50. #endif
51.  
52.     TRISIO    = 0;
53.     GPIO   = 0;
54.     beep = 0;
55.  
56.     InitTimer();
57.     PEIE = 1;
58.     GIE = 1;      /* Enable General Purpose Interrupts */
59.  
60.     do {
61.  
62.         octave = defaultoctave;         /* Set Default Octave */
63.  
64.         if ((Melody[pointer] == '3') && (Melody[pointer+1] == '2')) {
65.             duration = 32;
66.             pointer += 2;
67.         }
68.         else if ((Melody[pointer] == '1') && (Melody[pointer+1] == '6')) {
69.             duration = 16;
70.             pointer += 2;
71.         }
72.         else if (Melody[pointer] == '8') {
73.             duration = 8;
74.             pointer++;
75.         }
76.         else if (Melody[pointer] == '4') {
77.             duration = 4;
78.             pointer++;
79.         }
80.         else if (Melody[pointer] == '2') {
81.             duration = 2;
82.             pointer++;
83.         }
84.         else if (Melody[pointer] == '1') {
85.             duration = 1;
86.             pointer++;
87.         } else duration = defaultduration;
88.  
89.         if (Melody[pointer + 1] == '#') {
90.  
91.             /* Process Sharps */
92.  
93.             switch (Melody[pointer]) {
94.                 case 'c' : note = 3608;//2146;
95.                            break;
96.                 case 'd' : note = 3214;//1805;
97.                            break;
98.                 case 'f' : note = 2725;//1608;
99.                            break;
100.                 case 'g' : note = 2408;//1351;
101.                            break;
102.                 case 'a' : note = 2145;//1205;
103.                            break;
104.             }
105.             pointer +=2;
106.  
107.         } else {
108.  
109.             switch (Melody[pointer]) {
110.                 case 'c' : note = 3822;//2273;
111.                            break;
112.                 case 'd' : note = 3405;//2024;
113.                            break;
114.                 case 'e' : note = 3034;//1912;
115.                            break;
116.                 case 'f' : note = 2863;//1704;
117.                            break;
118.                 case 'g' : note = 2551;//1517;    
119.                            break;
120.                 case 'a' : note = 2273;//1433;
121.                            break;
122.                 case 'b' : note = 2025;//1275;
123.                            break;
124.                 case 'p' : note = 0;
125.                            break;
126.             }
127.             pointer++;
128.         }
129.  
130.         if (Melody[pointer] == '.') {
131.             /* Duration 1.5x */
132.             duration = duration + 128;
133.             pointer++;
134.         }
135.  
136.         if (Melody[pointer] == '4') {
137.             octave = 4;
138.             pointer++;
139.         } else if (Melody[pointer] == '5') {
140.             octave = 5;
141.             pointer++;
142.         } else     if (Melody[pointer] == '6') {
143.             octave = 6;
144.             pointer++;
145.         } else     if (Melody[pointer] == '7') {
146.             octave = 7;
147.             pointer++;
148.         }
149.  
150.         if (Melody[pointer] == '.') {
151.             /* Duration 1.5x */
152.             duration = duration + 128;
153.             pointer++;
154.         }
155.  
156.         PlayNote(note, octave, duration);
157.    
158.        
159.  
160.      } while (Melody[pointer++] == ',');
161.    
162.     /* Wait until last note has played */
163.     while(TMR0Count) { };
164.     beep = 0;
165.  
166.  
167. }
168. }
169. void PlayNote(unsigned short note, unsigned char octave, unsigned int duration)
170. {
171.  
172.     /* Process octave */
173.     switch (octave) {
174.         case 4 : /* Do noting */
175.              break;
176.         case 5 : /* %2 */
177.              note = note >> 1;
178.              break;
179.         case 6 : /* %4 */
180.              note = note >> 2;
181.              break;
182.         case 7 : /* %8 */
183.              note = note >> 4;
184.              break;
185.     }
186.  
187.     /* Wait until last note has played */
188.     while(TMR0Count) { };
189.     beep = 0;
190.  
191.     /* Process New Note Frequency */
192.     if (note) {
193.         note = ~note;
194.         preloadTMR1L = (note & 0xFF);
195.         preloadTMR1H = ((note & 0xFF00) >> 8);
196.     }
197.    
198.     /* Process Note Duration */    
199.     TMR0Count = 255/(duration & 0x7F);
200.  
201.     /* If duration is 1.5x add .5 to duration */
202.     if (duration & 0x80) TMR0Count = (TMR0Count + (TMR0Count >> 1));    
203.  
204.     if (note) beep = 1;

Falta el final, donde se inicializan los timers, pero eso no influye

[KILLERJC]

Lo que vos queres es lo que puse yo en el primer codigo, lo que si vas a tener que quitar todos los define.

Personalmente lo haria de esta forma:

Código: C

1. // Formato de la estructura
2. struct Melody
3. {
4.         const unsigned char *   MelodyArray;
5.         unsigned char           beat_speed;
6.         unsigned int            defaultduration;
7.         unsigned int            defaultoctave;
8. }
9.  
10. // Valores de los tonos
11. const unsigned char Melody1[] = {"2c,2g4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2f,2e,2c,2a,2g,g,2c,2c,2c,2b4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2b4,2c,2g4,2e,c.,p,p"};
12. const unsigned char Melody2[] = {"2c,2d,e.,f,g.,e,g,f,2e,f,d,e.,2c,2d,e.,f,g.,e,g,f,2e,f,d,c.,g,c6,b,a,g,g.,e,g,f,e,f,d,e,g,c,b,a,g,g,e,g,f,e,f,d,e,g,c,b,a,g,g"};//
13. const unsigned char Melody3[] = {"16g,16g,f,g,d6,eb,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6,8g.,16g,a,g,c6,2b,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6"};
14.  
15.  
16. // Definicion de las estructuras, aca es donde estan los valores de beat,duration, y a que array apunta
17. struct Melody MelodyA = {Melody1,220,1,5};
18. struct Melody MelodyB = {Melody2,200,4,5};
19. struct Melody MelodyC = {Melody3,150,4,5};
20.  
21. struct Melody * Melody[3] = {MelodyA,MelodyB,MelodyC};

De esa forma me queda mas ordenado. Ejemplo...

Código: C

1. unsigned char i=0;
2. unsigned int resultado=0;
3.  
4. resultado = Melody[0].beat_speed;               // Aca vas atener el valor 220 en resultado
5. resultado = Melody[0].defaultduration;          // Aca vas atener el valor 1 en resultado
6. resultado = Melody[0].defaultoctave;            // Aca vas atener el valor 5 en resultado
7. resultado = Melody[0].MelodyArray[0];           // Aca vas atener el valor '2' en resultado
8.  
9.  
10. // Accediendo al segundo tono
11. resultado = Melody[1].beat_speed;               // Aca vas atener el valor 200 en resultado
12. resultado = Melody[1].defaultduration;          // Aca vas atener el valor 4 en resultado
13. resultado = Melody[1].defaultoctave;            // Aca vas atener el valor 5 en resultado
14. resultado = Melody[1].MelodyArray[2];           // Aca vas atener el valor ',' en resultado
15.  
16. // Accediendo al tercer tono
17. resultado = Melody[1].beat_speed;               // Aca vas atener el valor 150 en resultado
18. resultado = Melody[1].defaultduration;          // Aca vas atener el valor 4 en resultado
19. resultado = Melody[1].defaultoctave;            // Aca vas atener el valor 5 en resultado
20. resultado = Melody[1].MelodyArray[2];           // Aca vas atener el valor 'g' en resultado

Si quisiera agregar un tono mas, solo me basta Escribir un Array nuevo, ejemplo Melody4, y luego definir una nueva estructura con los valores del mismo, ejemplo MelodyD = {Melody4,100,2,3}

Si no podrias crear lo mismo con arrays, obviamente vas a tener que hacer lo mismo una estructura.
Puede parecer complicado de escribir pero cuando le pongas el punto, solo el MPLAB te va a dar las opciones que podes elegir.

[pibe]

Eureca! Sos un genio.
Me pongo a modificarlo y cualquier cosa te vuelvo a molestar

PD : Que significa el * en "struct Melody * Melody[3] = {MelodyA,MelodyB,MelodyC};" ?

Y como hago para llamar una tabla desde el main? Un void MelodyA void ()?

[KILLERJC]

La tabla no es una funcion.. ahi te puse los ejemplos de como acceder a cada elemento.

Esa linea, solamente estoy declarando un array de 3 elementos los cuales apuntan a las estructuras del Melody de amtes

[pibe]

Lo he puesto asi:

Código: C

1. #pragma config FOSC = INTRCIO   // Oscillator Selection bits (INTOSC oscillator: I/O function on GP4/OSC2/CLKOUT pin, I/O function on GP5/OSC1/CLKIN)
2. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
3. #pragma config PWRTE = OFF      // Power-Up Timer Enable bit (PWRT disabled)
4. #pragma config MCLRE = OFF      // GP3/MCLR pin function select (GP3/MCLR pin function is digital I/O, MCLR internally tied to VDD)
5. #pragma config BOREN = OFF      // Brown-out Detect Enable bit (BOD disabled)
6. #pragma config CP = OFF         // Code Protection bit (Program Memory code protection is disabled)
7. #pragma config CPD = OFF        // Data Code Protection bit (Data memory code protection is disabled)
8. #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro
9.  
10. #include <xc.h>
11.  
12.  
13.  
14. // Formato de la estructura
15. struct Melody
16. {
17.         const unsigned char *   MelodyArray;
18.         unsigned char           beat_speed;
19.         unsigned int            defaultduration;
20.         unsigned int            defaultoctave;
21. }
22.  
23. // Valores de los tonos
24. const unsigned char Melody1[] = {"2c,2g4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2f,2e,2c,2a,2g,g,2c,2c,2c,2b4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2b4,2c,2g4,2e,c.,p,p"};
25. const unsigned char Melody2[] = {"2c,2d,e.,f,g.,e,g,f,2e,f,d,e.,2c,2d,e.,f,g.,e,g,f,2e,f,d,c.,g,c6,b,a,g,g.,e,g,f,e,f,d,e,g,c,b,a,g,g,e,g,f,e,f,d,e,g,c,b,a,g,g"};//
26. const unsigned char Melody3[] = {"16g,16g,f,g,d6,eb,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6,8g.,16g,a,g,c6,2b,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6"};
27.  
28.  
29. // Definicion de las estructuras, aca es donde estan los valores de beat,duration, y a que array apunta
30. struct Melody MelodyA = {Melody1,220,1,5};
31. struct Melody MelodyB = {Melody2,200,4,5};
32. struct Melody MelodyC = {Melody3,150,4,5};
33.  
34. struct Melody * Melody[3] = {MelodyA,MelodyB,MelodyC};
35.  
36.  
37.  
38.  
39.  
40. #define TONE    GPIObits.GP2
41.  
42. void InitTimer(void);
43. //void delayms(unsigned char cnt);
44. void PlayNote(unsigned short note, unsigned char octave, unsigned int duration);
45.  
46. unsigned char beep;
47. unsigned char preloadTMR1L;
48. unsigned char preloadTMR1H;
49. unsigned short TMR0Count;
50. unsigned char beat_speed;
51.  
52. //#define MusicBoxDancer
53. //#define HomeSweetHome
54. //#define HappyBirthday
55. void main(void)
56. {
57.     /* Loop */
58.     while(1)
59.     {
60.     unsigned int pointer = 0;
61.     unsigned int octave = 0;
62.     unsigned int duration = 0;
63.     unsigned short note = 0;
64.     unsigned int defaultoctave = 0;
65.     unsigned int defaultduration = 0;
66.  
67.  
68.     TRISIO    = 0;
69.     GPIO   = 0;
70.     beep = 0;
71.  
72.     InitTimer();
73.     PEIE = 1;
74.     GIE = 1;      /* Enable General Purpose Interrupts */
75.  
76.     do {
77.  
78.         octave = defaultoctave;         /* Set Default Octave */
79.  
80.         if ((Melody[pointer] == '3') && (Melody[pointer+1] == '2')) {
81.             duration = 32;
82.             pointer += 2;
83.         }
84.         else if ((Melody[pointer] == '1') && (Melody[pointer+1] == '6')) {
85.             duration = 16;
86.             pointer += 2;
87.         }
88.         else if (Melody[pointer] == '8') {
89.             duration = 8;
90.             pointer++;
91.         }
92.         else if (Melody[pointer] == '4') {
93.             duration = 4;
94.             pointer++;
95.         }
96.         else if (Melody[pointer] == '2') {
97.             duration = 2;
98.             pointer++;
99.         }
100.         else if (Melody[pointer] == '1') {
101.             duration = 1;
102.             pointer++;
103.         } else duration = defaultduration;
104.  
105.         if (Melody[pointer + 1] == '#') {
106.  
107.             /* Process Sharps */
108.  
109.             switch (Melody[pointer]) {
110.                 case 'c' : note = 3608;//2146;
111.                            break;
112.                 case 'd' : note = 3214;//1805;
113.                            break;
114.                 case 'f' : note = 2725;//1608;
115.                            break;
116.                 case 'g' : note = 2408;//1351;
117.                            break;
118.                 case 'a' : note = 2145;//1205;
119.                            break;
120.             }
121.             pointer +=2;
122.  
123.         } else {
124.  
125.             switch (Melody[pointer]) {
126.                 case 'c' : note = 3822;//2273;
127.                            break;
128.                 case 'd' : note = 3405;//2024;
129.                            break;
130.                 case 'e' : note = 3034;//1912;
131.                            break;
132.                 case 'f' : note = 2863;//1704;
133.                            break;
134.                 case 'g' : note = 2551;//1517;    
135.                            break;
136.                 case 'a' : note = 2273;//1433;
137.                            break;
138.                 case 'b' : note = 2025;//1275;
139.                            break;
140.                 case 'p' : note = 0;
141.                            break;
142.             }
143.             pointer++;
144.         }
145.  
146.         if (Melody[pointer] == '.') {
147.             /* Duration 1.5x */
148.             duration = duration + 128;
149.             pointer++;
150.         }
151.  
152.         if (Melody[pointer] == '4') {
153.             octave = 4;
154.             pointer++;
155.         } else if (Melody[pointer] == '5') {
156.             octave = 5;
157.             pointer++;
158.         } else     if (Melody[pointer] == '6') {
159.             octave = 6;
160.             pointer++;
161.         } else     if (Melody[pointer] == '7') {
162.             octave = 7;
163.             pointer++;
164.         }
165.  
166.         if (Melody[pointer] == '.') {
167.             /* Duration 1.5x */
168.             duration = duration + 128;
169.             pointer++;
170.         }
171.  
172.         PlayNote(note, octave, duration);
173.    
174.        
175.  
176.      } while (Melody[pointer++] == ',');
177.    
178.     /* Wait until last note has played */
179.     while(TMR0Count) { };
180.     beep = 0;
181.  
182.  
183. }
184. }
185. void PlayNote(unsigned short note, unsigned char octave, unsigned int duration)
186. {
187.  
188.     /* Process octave */
189.     switch (octave) {
190.         case 4 : /* Do noting */
191.              break;
192.         case 5 : /* %2 */
193.              note = note >> 1;
194.              break;
195.         case 6 : /* %4 */
196.              note = note >> 2;
197.              break;
198.         case 7 : /* %8 */
199.              note = note >> 4;
200.              break;
201.     }
202.  
203.     /* Wait until last note has played */
204.     while(TMR0Count) { };
205.     beep = 0;
206.  
207.     /* Process New Note Frequency */
208.     if (note) {
209.         note = ~note;
210.         preloadTMR1L = (note & 0xFF);
211.         preloadTMR1H = ((note & 0xFF00) >> 8);
212.     }
213.    
214.     /* Process Note Duration */    
215.     TMR0Count = 255/(duration & 0x7F);
216.  
217.     /* If duration is 1.5x add .5 to duration */
218.     if (duration & 0x80) TMR0Count = (TMR0Count + (TMR0Count >> 1));    
219.  
220.     if (note) beep = 1;
221. }

Y me da 21 errores:

main.c:24: error: (269) inconsistent type
main.c:34: error: (188) constant expression required
main.c:34: error: (207) simple type required for "@"
NOT pointer to struct Melody
main.c:34: error: (182) illegal conversion between types
struct Melody -> pointer to struct Melody
main.c:34: error: (181) non-scalar types can't be converted to other types
main.c:34: error: (188) constant expression required
main.c:34: error: (207) simple type required for "@"
NOT pointer to struct Melody
main.c:34: error: (182) illegal conversion between types
struct Melody -> pointer to struct Melody
main.c:34: error: (181) non-scalar types can't be converted to other types
main.c:34: error: (188) constant expression required
main.c:34: error: (207) simple type required for "@"
NOT pointer to struct Melody
main.c:34: error: (182) illegal conversion between types
struct Melody -> pointer to struct Melody
main.c:34: error: (181) non-scalar types can't be converted to other types
main.c:80: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:80: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:84: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:84: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:88: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:92: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:96: error: (208) operands of "==" not same type
pointer to struct Melody / unsigned int
main.c:100: advisory: (1) too many errors (21)
NOT struct Melody
main.c:121: advisory: (1) too many errors (21)

Donde me he equivocado? He quitado los defines, no he tocado nada más.

[KILLERJC]

Eso me pasa por escribirlo en el bloc de notas xD, siempre me olvido de algo .

Código: C

1. struct Melody * Melody[3] = {&MelodyA,&MelodyB,&MelodyC};

Y los demas errores, lineas 80 etc

Código: C

1. if ((Melody[pointer] == '3') && (Melody[pointer+1] == '2')) {

si no mal me equivoco

Código: C

1. if ((Melody[0]->MelodyArray[pointer] == '3') && (Melody[0]->MelodyArray[pointer+1] == '2')) {

Seguro que en algo me sigo equivocando,, ya lo voy a probar y te digo claramente el error.

[pibe]

Igual te va a faltar una parte del programa, donde inicializa los timers. Te lo subo completo?

[KILLERJC]

Este es un ejemplo funcionando, probado en MPLAB X y simulado con XC8:

Código: C

1. #include <stdint.h>
2. #include <xc.h>
3.  
4. // Valores de los tonos
5. const uint8_t MusicBoxDancerA[] = "2c,2g4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2f,2e,2c,2a,2g,g,2c,2c,2c,2b4,2c,2e,2c,2e,2g,2c,2c6,2b,2a,2g,g,16p,2g,2f,2d,2b4,2g4,2b4,2d,2b4,2c,2g4,2e,c.,p,p";
6. const uint8_t HomeSweetHomeA[] = "2c,2d,e.,f,g.,e,g,f,2e,f,d,e.,2c,2d,e.,f,g.,e,g,f,2e,f,d,c.,g,c6,b,a,g,g.,e,g,f,e,f,d,e,g,c,b,a,g,g,e,g,f,e,f,d,e,g,c,b,a,g,g";
7. const uint8_t HappyBirthdayA[] = "16g,16g,f,g,d6,eb,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6,8g.,16g,a,g,c6,2b,8g.,16g,a,g,d6,2c6,8g.,16g,g6,e6,c6,b,a,8f6.,16f6,e6,c6,d6,2c6";
8.  
9. struct Melody
10. {
11.         const uint8_t *   MelodyArray;
12.         uint8_t           beat_speed;
13.         uint16_t          defaultduration;
14.         uint16_t            defaultoctave;
15. };
16.  
17. // Definicion de las estructuras, aca es donde estan los valores de beat,duration, y a que array apunta
18. struct Melody MusicBoxDancer = {MusicBoxDancerA,220,1,5};
19. struct Melody HomeSweetHome = {HomeSweetHomeA,200,4,5};
20. struct Melody HappyBirthday = {HappyBirthdayA,150,4,5};
21.  
22. // Punteros a estructuras
23. struct Melody * Melody[3] = {&MusicBoxDancer,&HomeSweetHome,&HappyBirthday};
24.  
25. uint16_t resultado;
26.  
27. void main(void)
28. {
29.        
30.     resultado = Melody[0]->MelodyArray[1];          // 2da letra de MusicBoxDancerA, es decir la 'c'
31.     resultado = Melody[0]->defaultduration;         // Valor defaultduration de MusicBoxDancer, es decir 1
32.     resultado = Melody[0]->defaultoctave;           // Valor defaultoctave de MusicBoxDancer, es decir 5
33.    
34.     resultado = Melody[1]->MelodyArray[3];          // 4ta letra de HomeSweetHomeA, 'd'
35.     resultado = Melody[2]->MelodyArray[0];          // 1era letra de HappyBirthdayA, '1'
36.    
37.     while(1);
38. }

Para que vos uses esto, deberias reemplazar en tu codigo lo siguiente:

Reemplazar esto:

Código: C

1. Melody[pointer]
2. defaultoctave
3. defaultduration
4. beat_speed

por esto:

Código: C

1. Melody[Tono]->MelodyArray[pointer]
2. Melody[Tono]->defaultoctave
3. Melody[Tono]->defaulduration
4. Melody[Tono]->beat_speed

Para que quede mas claro... Ahora tenes los 3 tonos en memoria:

MusicBoxDancer, HomeSweetHome y HappyBirthday

Los numeros corresponden a 0, 1 y 2 respectivamente.
Al realizar:

Código: C

1. Melody[0]->

Accedo a MusciBoxDancer, dentro de esa estructura, Tenes para elegir:

Código: C

1. Melody[0]->MelodyArray[Aca el numero de indice]
2. Melody[0]->beat_speed
3. Melody[0]->defaultduration
4. Melody[0]->defaultoctave

Todos pertenecientes a MusicBoxDancer. Si hago para Melody[1] tambien voy a tener lo mismo, pero esta ves voy a acceder a HomeSweetHome con sus propios beat_speed, default xxx.

En el ejemplo que te pase tenes en los comentarios, lo que devolveria.

Si quisieras cambiar el tono, simplemente lo unico que tenes que hacer es cambiar el primer numero, es decir si estas en el primero tono lo que usarias es

Melody[0]->defaultduration

Si quiero pasar al 2do tono, uso

Melody[1]->defaultduration

el 3er tono es el 2, luego de alli vas a tener que pasar a 0 de nuevo, como ves cambio el tono con un indice nomas. Por lo cual si le pongo la variable "Tono" y le asigno un 0, para pasar al otro Tono simplemente debo hacer:

Tono++;