Duvida sobre Programação de Pic 16C745

[Nino Marques]

Estou programando um Pic para um projeto de gravação de voz......e ao compilar o codigo do Pic sempre dá erro....e não consigo identifica-lo!!!

Seria bom se alguém pudesse me ajudar......o codigo está abaixo....

O problema pelo q parece está no inicio no Include, Fuses e etc......a rotina para envio de dados não parece ter erros......

O PIC É O 16C745.

_________________________________________________________________________________

#include <16C745.H>

#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN

#use delay(clock=6000000)

#include <usb_cdc.H>

//#rom int 0xf00000={1,2,3,4}

void main() {

usb_cdc_init();

usb_init();

usb_task();

if (usb_enumerated()) {

do {

if (!input(PIN_A0)){

printf(usb_cdc_putc, "D");

}else{

printf(usb_cdc_putc, "L");

}

if (!input(PIN_A1)){

printf(usb_cdc_putc, "M");

}else{

printf(usb_cdc_putc, "N");

}

delay_ms(1000);

} while (TRUE);

}

}

___________________________________________________________

Me Ajudem por Favor!!!!

[Jhonas]

Estou programando um Pic para um projeto de gravação de voz

Veja a programação

1 /* Device used: PIC16C745 */

2  
3  
4 /* Version 1.1 

5  
6     * Generic digital input/output gates and analog inputs

7     * Serial communication: 9600bps 8N1

8     * Commands ended with a carrier return

9     * Async inputs enabled

10 */

11  
12 // Options: "16C745" or "16F873"

13  
14 #define VERSION     1

15 #define SUBVERSION    1

16  
17 #define 16C745

18 //#define 16F873

19  
20 #ifdef 16C745 

21     #include <16c745.h>

22     #define PORTA_PINS 6

23     #define PORTB_PINS 8

24     #define PORTC_PINS 3

25     #fuses H4,NOWDT,NOPROTECT,PUT

26 #endif

27  
28 #ifdef 16F873

29     #include <16f873.h>

30     #define PORTA_PINS 6

31     #define PORTB_PINS 8

32     #define PORTC_PINS 6

33     #fuses H4,NOWDT,NOPROTECT,PUT

34 #endif

35  
36 /* FUSES ********************************/

37 /* H4: 6 MHz Crystal                     */

38 /* NOWDT: Watchdog disabled             */

39 /* NOPROTECT: Don't protect PIC code     */

40 /* PUT: Power-up-Timer enabled             */

41  
42  
43 #device *=16

44  
45 #include <stdlib.h>

46 #include <string.h>

47  
48 /* Constants */

49  
50 #define ADC_REFERENCE 4.0

51  
52 /* Commands */

53  
54 #define GET_VERSION        0

55 #define GET_DIGITAL        1

56 #define GET_ANALOG        2

57 #define SET_DIGITAL        3

58 #define SET_ASYNC_INPUT    4

59 #define RESET            5

60  
61 #define COMMAND_UNKNOWN    10

62 #define COMMAND_ERROR    11

63  
64 /* RS232 9600bps 8N1. Tx: C6, Rx: C7 */

65  
66 #use delay(clock=24000000)

67 #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

68  
69 /* Timeout for RS232 RX in msec */

70 #define RS232_TIMEOUT        10

71  
72 #define RS232_MAX_BUFFER     32

73  
74 /* Pin Masks */

75  
76 #define PIN_INPUT            0

77 #define PIN_OUTPUT            1

78 #define PIN_ASYNC_INPUT        2

79  
80 /************************************

81  Input/Output map

82 /************************************/

83  
84 /* Sensor input. Analog-to-digital */

85  
86 #define ADC_READS 16

87  
88 /* Default gates */

89  
90 #define LED            PIN_C0

91 #define BUZZER        PIN_C1

92  
93 char led_state = 1;

94  
95 char timeout_error;

96 char rs232_buffer[RS232_MAX_BUFFER];

97 char out_data[32];

98  
99 /* Command strings */

100  
101 char get_version_str[]         = "version";

102 char get_digital_str[]         = "getd";

103 char get_analog_str[]          = "geta";

104 char set_digital_str[]         = "setd";

105 char set_async_input_str[]     = "setasync";

106 char reset_str[]                = "reset";

107  
108 /* PIC ports states (input values) */

109  
110 char portA_state[PORTA_PINS];

111 char portB_state[PORTB_PINS];

112 char portC_state[PORTC_PINS];

113  
114 /* PIC ports configuration (input/output/async_input values) */

115  
116 char portA_conf[PORTA_PINS];

117 char portB_conf[PORTB_PINS];

118 char portC_conf[PORTC_PINS];

119  
120 /* Arrays */

121  
122 char ports_pins[]          = {PORTA_PINS, PORTB_PINS, PORTC_PINS};

123 char ports_pins_chr[]      = {'a', 'b', 'c'};

124 char *ports_conf[]      = {portA_conf, portB_conf, portC_conf};

125 char *ports_state[]     = {portA_state, portB_state, portC_state};

126  
127 /*************************************************************************/

128 /* reset_pic: Resets PIC                                                 */

129 /*************************************************************************/

130  
131 void reset_pic(void)

132 {

133     #asm

134        bcf 03,6

135        bcf 03,7

136        movlw 020

137        movwf 04

138     next:

139        clrf 00

140        incf 04

141        btfss 04,7

142        goto next

143     #endasm

144      

145     reset_cpu();

146 }

147  
148 /*************************************************************************/

149 /* timed_getc: Waits for incoming RS232 data byte, with timeout (msecs)  */

150 /*************************************************************************/

151  
152 char timed_getc(int timeout) {

153  
154     long elapsed = 0;

155  
156     timeout_error = FALSE;

157     while( !kbhit() && (++elapsed < timeout) )

158         delay_us(1000);

159     if( kbhit() )

160         return(getc());

161     else

162         timeout_error = TRUE;

163     return 0;

164 }

165  
166  
167 /*************************************************************************/

168 /* rs232_send: Sends string to RS232                                              */

169 /*************************************************************************/

170  
171 void rs232_send(char *buffer, int length)

172 {

173     int i;

174  
175     for(i=0; i<length; i++)

176         putc(buffer[i]);

177 }

178  
179 /*************************************************************************/

180 /* rs232_recv: Waits for incoming RS232 data string, with timeout (msecs)*/

181 /*************************************************************************/

182  
183 int rs232_recv(char *buffer, int max_length, int timeout) {

184  
185     int length = 0;

186     char c;

187  
188     while (length < max_length) {

189         c = timed_getc(timeout);

190         if (timeout_error)

191             break;

192         buffer[length++] = c;

193     }

194  
195     return length;

196  
197 }

198  
199 /*************************************************************************/

200 /* adc_read: Read ADC channel                                              */

201 /*************************************************************************/

202  
203 int16 adc_read(unsigned char channel)

204 {

205     int i;

206     int16 sum = 0;

207  
208     if (channel == 3 || channel > 4)

209         return 0xFFFF;

210  
211     set_adc_channel( channel );

212     for(i=0; i<ADC_READS; i++) {

213         delay_us(10);

214         sum += (int16)read_adc();

215     }

216     sum /= ADC_READS;

217     return sum;

218 }

219  
220 /*************************************************************************/

221 /* flash_led: Flash the led (on/off) with a given delay                     */

222 /*************************************************************************/

223  
224 void flash_led(int times, int delay)

225 {

226     int i;

227  
228     for (i=0; i<times*2; i++) {

229         output_low(LED);

230         delay_ms(delay);

231         output_high(LED);

232         delay_ms(delay);

233     }

234     output_bit(LED, led_state);

235 }

236  
237 /*************************************************************************/

238 /* buzzer_speaker: Activates/deactivates a speaker buzzer (square wave)  */

239 /*************************************************************************/

240  
241 void buzzer_speaker(char state)

242 {

243     if (state) {

244         setup_ccp2(CCP_PWM);                      // clk=6MHz, => F=2KHz

245         setup_timer_2(T2_DIV_BY_16, 186, 1);      // (1/6000000)*16*187*1= 498.67 us or 2 khz

246         set_pwm2_duty(375);                     // 50%, 6000000(1/2)*(1/2000)*(1/4)=375

247     }

248     else {

249         setup_ccp2(CCP_OFF);

250         output_low(BUZZER);

251     }

252 }

253  
254 /*************************************************************************/

255 /* board_init: Initialize EHAS board. Outputs and LED flashing           */

256 /*************************************************************************/

257  
258 void board_init(void)

259 {

260     int n;

261  
262     /* Initialize global variables */

263  
264     flash_led(2, 200);

265  
266     /* Initialize digital outputs */

267  
268     for(n=0; n<sizeof(portA_conf); n++)

269         portA_state[n] = portA_conf[n] = PIN_INPUT; 

270  
271     for(n=0; n<sizeof(portB_conf); n++)    

272         portB_state[n] = portB_conf[n] = PIN_INPUT; 

273  
274     for(n=0; n<sizeof(portC_conf); n++)    

275         portC_state[n] = portC_conf[n] = PIN_INPUT; 

276  
277     /* C0 and C1 are default defined output gates */

278  
279     output_high(LED);

280     output_low(BUZZER);

281  
282     portC_conf[0] = portC_conf[1] = PIN_OUTPUT;

283  
284     /* Initialize ADC */

285  
286     setup_adc(ADC_CLOCK_INTERNAL);

287     setup_adc_ports(ANALOG_RA3_REF);

288  
289     sprintf(rs232_buffer, "EHAS Serial Board v%d.%d\n\r", VERSION, SUBVERSION);

290     rs232_send(rs232_buffer, strlen(rs232_buffer));

291  
292 }

293  
294 /*************************************************************************/

295 /* set_bit: Set an output                                                 */

296 /*************************************************************************/

297  
298 char set_bit(char port, unsigned char pin, char value)

299 {

300     switch(port) {

301     case 'a':

302         switch(pin) {

303         case 0:    output_bit(PIN_A0, value); break;

304         case 1:    output_bit(PIN_A1, value); break;

305         case 2:    output_bit(PIN_A2, value); break;

306         case 3:    output_bit(PIN_A3, value); break;

307         case 4:    output_bit(PIN_A4, value); break;

308         case 5:    output_bit(PIN_A5, value); break;

309         }

310         if (pin < PORTA_PINS) {

311             portA_state[pin] = value;

312             portA_conf[pin] = PIN_OUTPUT; 

313             return 0;

314         }

315         break;

316     case 'b':

317         switch(pin) {

318         case 0:    output_bit(PIN_B0, value); break;

319         case 1:    output_bit(PIN_B1, value); break;

320         case 2:    output_bit(PIN_B2, value); break;

321         case 3:    output_bit(PIN_B3, value); break;

322         case 4:    output_bit(PIN_B4, value); break;

323         case 5:    output_bit(PIN_B5, value); break;

324         case 6:    output_bit(PIN_B6, value); break;

325         case 7:    output_bit(PIN_B7, value); break;

326         }

327         if (pin < PORTB_PINS) {

328             portB_state[pin] = value; 

329             portB_conf[pin] = PIN_OUTPUT; 

330             return 0;

331         }

332         break;

333     case 'c':

334         switch(pin) {

335         case 0:    output_bit(PIN_C0, value); break;

336         case 1:    output_bit(PIN_C1, value); break;

337         case 2:    output_bit(PIN_C2, value); break;

338         case 3:    output_bit(PIN_C3, value); break;

339         }

340         if (pin < PORTC_PINS) {

341             portC_state[pin] = value; 

342             portC_conf[pin] = PIN_OUTPUT; 

343             return 0;

344         }

345         break;

346     }

347     return 0xFF;

348 }

349  
350  
351 /*************************************************************************/

352 /* get_bit: Get an input bit value                                          */

353 /*************************************************************************/

354  
355 char get_bit(char port, unsigned char pin)

356 {

357     char data;

358  
359     switch(port) {

360     case 'a':

361         if (pin >= PORTA_PINS) 

362             return 0xFF;

363         if ( portA_conf[pin] == PIN_OUTPUT )

364             data = portA_state[pin];

365         else

366             data = (input_a() >> pin) & 1;

367         portA_state[pin] = data;

368         return data;

369     case 'b':

370         if (pin >= PORTB_PINS) 

371             return 0xFF;

372         if ( portB_conf[pin] == PIN_OUTPUT )    

373             data = portB_state[pin];

374         else

375             data = (input_b() >> pin) & 1;

376         portB_state[pin] = data;

377         return data;

378     case 'c':

379         if (pin >= PORTC_PINS) 

380             return 0xFF;

381         if ( portC_conf[pin] == PIN_OUTPUT )    

382             data = portC_state[pin];

383         else

384             data = (input_c() >> pin) & 1;

385         portC_state[pin] = data;

386         return data;

387     }

388  
389     return 0xFF;

390 }

391  
392  
393 /*************************************************************************/

394 /* set_gate_conf: Set a gate configuration (input, output, async input)  */

395 /*************************************************************************/

396  
397 char set_gate_conf(char port, unsigned char pin, char conf)

398 {

399     switch(port) {

400     case 'a':

401         if (pin >= PORTA_PINS) 

402             return 0xFF;

403         portA_conf[pin] = conf;

404         return 0;

405     case 'b':

406         if (pin >= PORTB_PINS) 

407             return 0xFF;

408         portB_conf[pin] = conf;

409         return 0;

410     case 'c':

411         if (pin >= PORTC_PINS) 

412             return 0xFF;

413         portC_conf[pin] = conf;

414         return 0;

415     }

416     return 0xFF;

417 }

418  
419 /*************************************************************************/

420 /* get_command: Gets numeric command from string                            */

421 /*************************************************************************/

422  
423 char get_command(char *buffer)

424 {    

425     if (strcmp(get_version_str, buffer) == 0) 

426         return GET_VERSION;

427     else if (strcmp(get_digital_str, buffer) == 0) 

428         return GET_DIGITAL;

429     else if (strcmp(get_analog_str, buffer) == 0) 

430         return GET_ANALOG;

431     else if (strcmp(set_digital_str, buffer) == 0) 

432         return SET_DIGITAL;

433     else if (strcmp(set_async_input_str, buffer) == 0) 

434         return SET_ASYNC_INPUT;

435     else if (strcmp(reset_str, buffer) == 0) 

436         return RESET;

437     else

438         return COMMAND_UNKNOWN;

439 }

440  
441 /*************************************************************************/

442 /* process_command: Process a Serial command and prepares the answer     */

443 /*************************************************************************/

444  
445 void process_command(char *in_data, char *ret_string)

446 {

447     int16 adc_value;

448     unsigned char retval, flash;

449  
450     flash = 0;

451  
452     switch(in_data[0]) {

453  
454     case GET_VERSION:

455         flash = 1;

456         sprintf(ret_string, "EHAS Serial Board v%d.%d\n\r", VERSION, SUBVERSION);

457         break;

458  
459     case GET_DIGITAL:

460         retval = get_bit( in_data[1], in_data[2] );

461         if (retval != 0xFF)

462             sprintf(ret_string, "getd %c%d %d\n\r", in_data[1], in_data[2], retval);

463         else

464             sprintf(ret_string, "error getd\n\r");

465         break;

466  
467     case SET_ASYNC_INPUT:

468         get_bit( in_data[1], in_data[2] );

469         retval = set_gate_conf( in_data[1], in_data[2], PIN_ASYNC_INPUT);

470         if (retval != 0xFF)

471             sprintf(ret_string, "setasync %c%d ok\n\r", in_data[1], in_data[2], retval);

472         else

473             sprintf(ret_string, "error setasync\n\r");

474         break;

475  
476     case GET_ANALOG:

477         adc_value = adc_read( in_data[1] );

478         retval = adc_value & 0xFF;

479  
480         if (adc_value != 0xFFFF)

481             sprintf(ret_string, "geta %u %u\n\r", in_data[1], retval);

482         else        

483             sprintf(ret_string, "error geta\n\r");

484         break;

485  
486     case SET_DIGITAL:

487         retval = set_bit( in_data[1], in_data[2], in_data[3] );

488         if (retval != 0xFF)

489             sprintf(ret_string, "setd %c%d %d ok\n\r", in_data[1], in_data[2], in_data[3]);

490         else

491             sprintf(ret_string, "error setd\n\r");

492         break;

493  
494     case RESET:

495         flash = 1;

496         reset_pic();

497  
498     case COMMAND_ERROR:

499         sprintf(ret_string, "error command syntax\n\r");

500         break;

501  
502     case COMMAND_UNKNOWN:

503         sprintf(ret_string, "error command unknown\n\r");

504         break;

505  
506     default:

507         sprintf(ret_string, "error\n\r");

508         break;

509  
510     }

511  
512     /* Flash LED to indicate command received */

513     if (flash)

514         flash_led(2, 20);

515 }

516  
517  
518 /*************************************************************************/

519 /* translate_command: Translate a ASCII command                         */

520 /*************************************************************************/

521  
522 int translate_command(char *buffer, int length, char *output)

523 {

524     int p1, p2, i, end_command = 0;

525     char command;

526  
527     if (length <= 0)

528         return 0;

529  
530     buffer[length] = '00';

531     if (strchr(buffer, ';')) {

532         p1 = 0;

533         p2 = 0;

534         for(i=0; i<length; i++) {

535             if (buffer[i] == ' ' || buffer[i] == ';') {

536                 if (buffer[i] == ';')

537                     end_command = 1;

538                 buffer[i] = '00';

539  
540                 if (p2 >= 4) 

541                     p2 = 0;

542  
543                 switch (p2) {

544                 case 0:

545                     command = get_command(buffer + p1);

546                     output[p2++] = command;

547                     break;

548                 case 1:

549                     if (command == GET_DIGITAL || command == SET_DIGITAL || command == SET_ASYNC_INPUT) {

550                         output[p2++] = buffer[p1];

551                         output[p2++] = atoi(buffer + p1 + 1);

552                         break;

553                     }

554                 case 2:

555                 case 3:

556                     output[p2++] = atoi(buffer + p1);

557                     break;                            

558                 }        

559                 p1 = i + 1;

560             }

561             if (end_command)

562                 break;

563         }

564         if (command == GET_DIGITAL && p2 < 3)

565             output[0] = COMMAND_ERROR;

566         if (command == SET_DIGITAL && p2 < 4)

567             output[0] = COMMAND_ERROR;

568         if (command == GET_ANALOG && p2 < 2)

569             output[0] = COMMAND_ERROR;

570         if (command == SET_ASYNC_INPUT && p2 < 3)

571             output[0] = COMMAND_ERROR;

572         return p1;    

573     }

574     return 0;

575 }

576  
577 /*******************************************************************************************/

578 /* process_async_inputs: Check all inputs marked as async and notify if value has changed  */

579 /*******************************************************************************************/

580  
581 void process_async_inputs()

582 {

583     char port, pin, conf, state, old_state, new_state;

584  
585     for(port=0; port<sizeof(ports_pins_chr); port++) {

586         for(pin=0; pin<ports_pins[port]; pin++) {

587             conf = ports_conf[port];

588             if ( conf[pin] == PIN_ASYNC_INPUT ) {

589                 state = ports_state[port];

590                 old_state = state[pin];

591                 new_state = get_bit(ports_pins_chr[port], pin);

592                 if (old_state != new_state) {

593                     sprintf(out_data, "async %c%d %d\n\r", ports_pins_chr[port], pin, new_state);

594                     rs232_send(out_data, strlen(out_data));

595                 }

596             }    

597         }

598     }

599 }

600  
601 /*******************************************************************************************/

602 /* asjust_command: Removes "\n" and "\r" and put ";" to indicate end of command               */

603 /*******************************************************************************************/

604  
605 int adjust_command(char *buffer, int length)

606 {

607     int n = 0, n2 = 0, command_started = 0;

608     char new_buffer[32];

609  
610     while(n < length) {

611         if ( buffer[n] == '\n' || buffer[n] == '\r') {

612             if (n2 > 0 && new_buffer[n2-1] != ';' && command_started) 

613                 new_buffer[n2++] = ';';

614         }

615         else {

616             command_started = 1;

617             new_buffer[n2++] = buffer[n];

618         }

619         n++;

620     }

621     memmove(buffer, new_buffer, n2);

622     return n2;

623 }

624  
625  
626 /****************************************************

627 *********** MAIN ************************************

628 *****************************************************/

629  
630 void main() {

631  
632     /* Serial buffer */

633     char in_data[4];

634     int n, pbuffer;

635  
636     board_init();

637  
638     /* Main loop */

639  
640     memchr(rs232_buffer, 0, sizeof(rs232_buffer));

641     pbuffer = 0;

642  
643     for(;;) {

644         n = rs232_recv(rs232_buffer + pbuffer, RS232_MAX_BUFFER - pbuffer, RS232_TIMEOUT);

645         if (n > 0) {    

646             pbuffer = adjust_command(rs232_buffer, pbuffer + n);

647             n = translate_command(rs232_buffer, pbuffer, in_data);

648             while (n > 0) {

649                 memmove(rs232_buffer, rs232_buffer + n, pbuffer - n);

650                 pbuffer -= n;

651                 process_command(in_data, out_data);

652                 rs232_send(out_data, strlen(out_data));

653                 n = translate_command(rs232_buffer, pbuffer, in_data);

654             }

655         }

656         if (pbuffer >= RS232_MAX_BUFFER)

657             pbuffer = 0;

658  
659         process_async_inputs();

660     }

661  
662 }

http://www.novaeletronica.net/q/n4/ne100_n/ne100_01.htm

http://www.mecatronica.org.br/disciplinas/...coproblemas.htm

abraço

[Nino Marques]

Dei uma lida no Codigo....parece que é bem parecido com oque eu estou fazendo, porque meu projeto tambem é para gravação de voz!!

Só q eu não entendo tão bem a linguagem Assembly....

Assim......A idea no meu projeto é o Pic mandar para o Software q desenvolvi....uma letra se o não ouver entrada de som, e outra se ouver....assim, acionando ou não o programa de gravação....

Será q seu codigo fonte pode ser usado para isso?! apenas alterando algumas coisa??

E pela leitura q você fez do meu codigo.....encontrou algum erro?!

Na vdd ainda nem sei se funciona, porque não estou consegundo gravar o Pic......tem dado erro na hora da gravação, algo com o endereço 0000h do Pic.....

Bom...espero resposta! Obrigado...

[Jhonas]

O programa que te passei codifica Portas de input/output digitais genéricos e entradas analógicas

Aprender a programar microcontroladores, e realizar integrações entre alto nível (PC) e baixo nível (controladores eletrônicos) não é muito fácil, exige muita paciencia e muita leitura .. além de um bom conhecimento em eletrônica

Bom seria se a codificação fosse tão simples como o código que voce fez, mas é muito mais complicado do que isso

Voce pode tentar adaptar, ou melhor, estudar com calma o código e ver se consegue entender o que foi feito

Explicar algo como isso em sala de aula leva um bom tempo, no forum fica impossivel ... voce terá que depender de voce mesmo .... boa sorte e bons estudos

OBS: Tente pesquisar sobre o assunto na Net

abraço