c-programma voor het omgaan met het communicatie protocol.
  1. /*
  2.  * Madeleine_V7.c
  3.  *
  4.  * Created: 15-2-2016 16:08:02
  5.  * Author : Ben
  6. Dit is een testprogramma voor de communicatie tussen VIP
  7. en een programma lopend op Madeleine.
  8. De PC is de master en Madeleine is slave.
  9. Communicatieparameters: 115200 BAUD 1 startbit 8 databits 1 stopbit noparity
  10. Madeleine meldt zich met twee zinnen.
  11. Wacht dan op een ASCII-string eindigend op '\n'.
  12. Na ontvangst wordt de zin direct teruggezonden met een '\0' teken.
  13.  
  14. Gebruikte interrupts
  15. ISR(TIMER2_OVF_vect) // Real Time Clock
  16. ISR(INT0_vect) //Button
  17. ISR(USART_RXC_vect) //Usart interrupt routine
  18. */
  19.  
  20. #include <avr/io.h>
  21. #include <avr/interrupt.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include "Madeleine.c"
  25. #include "bool.h"
  26. #include "pwm.h"
  27. #include "pwm.c"
  28.  
  29. #define F_CPU  14745600L
  30. //#define F_CPU  8000000L
  31. //#define USART_BAUDRATE 9600
  32. //#define F_CPU 3686400L
  33. #define USART_BAUDRATE 115200
  34. //#define USART_BAUDRATE 19200
  35. #define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
  36. #include "util/delay.h"
  37. //#define FORWARD 46
  38.  
  39. int  uart_putc(unsigned char c);
  40. void uart_puts (char *s);
  41. void uart_putheader();
  42. void mot2registers();
  43. void timer1_registers();
  44.  
  45. int counter =0;
  46. int     bufcounter = 0;
  47. int     flag = 0;
  48. int textflag = 0;
  49.  
  50. int packetintro = 5;
  51. int soh = 0x01; //start of header
  52. int seqnr = 0;// sequencenumber
  53. int messize = 0; //messagesize
  54. int cmd = 0; // no commands
  55. int stx = 0x02; // start of text
  56. int etx = 0x03; //end_of_text character
  57. int eot = 0x04; //end_of_transmission
  58. int crcbyte = 0;
  59. char buffer[20];
  60. //char charbuffer[20];
  61. char charbuffer[20];//external definition. external declaration in stk500.h
  62.        
  63. int timer2sec = 0;
  64.  
  65. int main (void)
  66. {
  67.    UCSRB |= (1 << RXEN) | (1 << TXEN);   // Turn on the transmission and reception circuitry
  68.    UCSRC |= (1 << URSEL) | (1 << UCSZ0) | (1 << UCSZ1); // Use 8-bit character sizes
  69.  
  70.    UBRRL = BAUD_PRESCALE; // Load lower 8-bits of the baud rate value into the low byte of the UBRR register
  71.    UBRRH = (BAUD_PRESCALE >> 8); // Load upper 8-bits of the baud rate value into the high byte of the UBRR register
  72.  
  73.    UCSRB |= (1 << RXCIE); // Enable the USART Receive Complete interrupt (USART_RXC)
  74.    sei(); // Enable the Global Interrupt Enable flag so that interrupts can be processed
  75.         _delay_ms(4000); // Gives bluetooth time to make connection
  76.         uart_puts("Madeleine"); // Robot introduces itself
  77.         led_on(); // Meaning I am almost ready 
  78.  
  79.         MotorInit();
  80. //      setMotorPower(3,3);
  81.  
  82. //      mot1_init();
  83. //      mot2_init(); //Let op gebruikt timer2
  84.         int0_init(); //Voor button
  85. //      timer2_init(); //inschakelen real time clock. Zie interruptvector functie
  86.  
  87.    for (;;) // Loop forever
  88.    {
  89.          // Do nothing - echoing is handled by the ISR instead of in the main loop
  90. //      led(flag);
  91.         } //end for
  92. } //end main
  93.  
  94.  
  95. int procedure(int cmd) // Ontvangt commando's van RS232-Messages en stuurt antwoorden terug
  96.         {
  97.                 switch (cmd)
  98.                 {
  99.                 case 1 : //version
  100.                         {
  101.                                 uart_putheader();
  102.                                 uart_puts(version());
  103.                                 uart_putc(etx);
  104.                         }
  105.                 break;
  106. /*
  107.                 sscanf(buffer,"%s%d",t,&i);
  108.                 uart_puts(t);
  109.                 itoa(i,tekst,10);
  110.                 uart_puts(tekst);
  111. */
  112.                 case 2 : //leds opdracht: led Arg (Arg = 0...255)
  113.                         {
  114.                         int leds = 0;
  115.                         sscanf(buffer,"%d",&leds);
  116.                         led((uint8_t) leds); // casting en naar functie
  117.                         led(leds);
  118.                         uart_putc(etx);
  119.                         }
  120.                 break;
  121. /*
  122.         case 3 : //adc Arg (Arg = 0...7)
  123.                         {
  124.                         char *p;
  125.                         uint16_t i = 0;
  126.                         char adcbuffer[20];
  127.                         int adc = 0;
  128.                         sscanf(buffer,"%d",&adc);
  129.                         i = readADC( adc); // casting en naar functie
  130.                         p = itoa(i,adcbuffer,10);                      
  131.                         uart_putc(soh);
  132.                         uart_putc(seqnr);
  133.                         uart_putc(messize);
  134.                         uart_putc(cmd);
  135.                         uart_putc(stx);
  136.                        
  137.                         uart_puts(p);
  138.                        
  139.                         uart_putc(etx);
  140.                         uart_putc(crcbyte);
  141.                         }
  142.                 break;
  143. */             
  144.         case 4 : //mot1 opdracht: mot1 Arg (Arg = R | F| S | B)
  145.                         {
  146.                         uart_putheader();
  147.                         char blank;
  148.                         char motcmd;
  149.                
  150.                     uart_puts(itoa(DDRB,charbuffer,10));
  151.                         uart_puts(itoa(PORTB,charbuffer,10));
  152.        
  153.                         sscanf(buffer,"%c%c",&blank,&motcmd);
  154.                         mot1(motcmd);
  155.                         uart_putc(motcmd);
  156.                         uart_putc('\0');
  157.  
  158.                         uart_puts(itoa(PORTB,charbuffer,10));
  159.                         uart_putc(etx);
  160.                         }
  161.                 break;
  162.                 case 5 : //mot2 opdracht: mot2 Arg (Arg = R | F| S | B)
  163.                 {
  164.                         uart_putheader();
  165.                         char blank;
  166.                         char motcmd;
  167.         //                uart_puts(itoa(DDRB,charbuffer,10));
  168.         //                uart_puts(itoa(PORTB,charbuffer,10));
  169.                        
  170.                         sscanf(buffer,"%c%c",&blank,&motcmd);
  171.                         mot2(motcmd);
  172.                         uart_puts("MOT2 param");
  173.                         uart_putc(motcmd);
  174.                         uart_putc('\0');
  175.         //              uart_puts(itoa(PORTB,charbuffer,10));
  176.                         uart_putc(etx);
  177.                         }
  178.                 break;
  179.                 case 6 : //led_on
  180.                         {
  181.                         uart_putheader();
  182.                         led_on();
  183.                         uart_putc(etx);
  184.                         }
  185.                 break;
  186.                 case 7 : //led_off
  187.                 {
  188.                         uart_putheader();
  189.                         led_off();
  190.                         uart_putc(etx);
  191.                 }
  192.                 break;
  193.                 case 8 : //timer2_init
  194.                         {
  195.                         timer2sec = 0;
  196.                         uart_putheader();
  197.                 //      timer2_init();
  198.                         uart_puts(itoa(TIMSK,charbuffer,10));
  199.                         uart_putc(etx);
  200.                         }
  201.                         break;
  202.                 case 9 : //timer2_off
  203.                         {
  204.                         uart_putheader();
  205.                 //      timer2_off();
  206.                         uart_puts(itoa(TIMSK,charbuffer,10));
  207.                         uart_putc(etx);
  208.                         }
  209.                         break;
  210.  
  211.                 case 10 : //adc
  212.                         {
  213.                         unsigned int result = 0;
  214.                         uart_putheader();
  215.                         result = adc();
  216.                         uart_puts("adc lezen intern"); // herhaling van laatste. Gemiddelde beter??
  217.                         uart_puts(itoa(result,charbuffer,10));
  218.                         uart_putc(etx);
  219.                         }
  220.                         break;
  221.                 case 11 : //mot2registers()
  222.                 {
  223.                         uart_putheader();
  224.                         mot2registers();
  225.                         uart_putc('\0');
  226.                         uart_putc(etx);
  227.                 }
  228.                 break;
  229.  
  230.                 case 12 : //motoren opdracht: mleft (Arg = -9... 9) mright idem
  231.                         {
  232.                         int mleft = 0;
  233.                         int mright = 0;
  234.                         sscanf(buffer,"%d%d",&mleft,&mright);
  235.         //              setMotorPower((short) mleft,(short) mright);
  236.                         setMotorPower((short) mright,(short) mleft); //uitzoeken waarom dat nodig is.
  237.                         uart_putheader();
  238.                         uart_putc(etx);
  239.                         }
  240.                         break;
  241.                 case 13 : //registers timer1 opvragen
  242.                         {
  243.                         uart_putheader();
  244.                         timer1_registers();
  245.                         uart_putc(etx);
  246.                         }
  247.                         break;
  248.  
  249.                 case 14 : //adcr
  250.                         {
  251.                         unsigned int result = 0;
  252.                         uart_putheader();
  253.                         result = adcr();
  254.                         uart_puts("adc rechts"); // herhaling van laatste. Gemiddelde beter??
  255.                         uart_puts(itoa(result,charbuffer,10));
  256.                         uart_putc(etx);
  257.                         }
  258.                         break;         
  259.                 case 15 : //adcl
  260.                         {
  261.                         unsigned int result = 0;
  262.                         uart_putheader();
  263.                         result = adcl();
  264.                         uart_puts("adc links"); // herhaling van laatste. Gemiddelde beter??
  265.                         uart_puts(itoa(result,charbuffer,10));
  266.                         uart_putc(etx);
  267.                         }
  268.                 break;
  269.                         case 16 : //adcra
  270.                         {
  271.                                 unsigned int result = 0;
  272.                                 uart_putheader();
  273.                                 result = adcra();
  274.                                 uart_puts("adc rechtsachter"); // herhaling van laatste. Gemiddelde beter??
  275.                                 uart_puts(itoa(result,charbuffer,10));
  276.                                 uart_putc(etx);
  277.                         }
  278.                         break;
  279.                 case 255 : //respond
  280.                         {
  281.                         uart_putheader();
  282. //                      mot2registers();
  283.                         uart_putc('\0');
  284.                         uart_putc(etx);
  285.                         }
  286.                         break;                                                 
  287.                 } //end switch
  288.                
  289.                 cmd = 0;
  290.                 counter = 0;
  291. //              flag = 0;
  292.                 textflag = 0;
  293.                 bufcounter = 0;
  294.                 return 0;
  295.         }// end procedure
  296.  
  297. /*      Werkt.
  298. ISR(TIMER2_OVF_vect) // Real Time Clock
  299.         {
  300.         if (PINB & (1<<PINB0))//If set ( = off)
  301.                 {led_on();
  302.  
  303.                 }
  304.         else
  305.                 {led_off();
  306.  
  307.                 }
  308.         }
  309. */     
  310. /*
  311. ISR(TIMER2_OVF_vect) // Real Time Clock
  312.         {
  313.                
  314.                 if (timer2sec > 8)
  315.                         {
  316.         //              mot1('S');
  317.         //              mot2('S');
  318.                         setMotorPower(0,0);
  319.                         timer2_off();
  320.                         }
  321.                 if (timer2sec == 4)
  322.                         {
  323.         //              mot1('R');
  324.         //              mot2('R');
  325.                         setMotorPower(-3,-3);
  326.                         }
  327.                 if (timer2sec == 0)
  328.                         {
  329.         //                      mot1('F');
  330.         //                      mot2('F');
  331.                         setMotorPower(3,3);
  332.                         }      
  333.                 timer2sec++;     
  334.         }
  335. */
  336. /*
  337. timer2 bijbehorende VIP commands:
  338. adc
  339. motoren 4 4
  340. timer2_init
  341. */     
  342. /* Wordt in Madeleine niet gebruikt tot nog toe.
  343. Timer2 nader bestuderen in Atmel documentatie
  344. Het is gecompliceerd.
  345. ISR(TIMER2_OVF_vect) // Real Time Clock
  346. {
  347.         uart_putheader();
  348.         unsigned int result = 0;
  349.         result = adc();
  350.         uart_puts("sensor middenvoor"); // herhaling van laatste. Gemiddelde beter??
  351.         uart_puts(itoa(result,charbuffer,10));
  352.        
  353.         if (result >= 350)
  354.                 {
  355.                 setMotorPower(0,0);
  356.                 timer2_off();
  357. //              uart_puts("gestopt");
  358. //              uart_putc(etx);
  359. //              uart_putc(eot);
  360.                 }
  361.         uart_putc(etx);
  362. }
  363. */     
  364. /*
  365. ISR(INT0_vect) //Button
  366. {
  367.                 if (PINB & (1<<PINB0))//If set ( = off)
  368.                         {led_on();
  369.                         }
  370.                 else
  371.                         {led_off();}
  372. //      led_off();     
  373. }
  374. */
  375.  
  376. ISR(INT0_vect) //Button
  377. {
  378.         timer2sec = 0;
  379. //      timer2_init();
  380. }
  381.  
  382.  
  383. ISR(USART_RXC_vect) //Usart interrupt routine
  384. {
  385.         unsigned char ReceivedByte;
  386.         ReceivedByte = UDR; // Fetch the received byte value into the variable "ByteReceived"
  387. //   UDR = ReceivedByte; // Echo back the received byte back to the computer
  388. //      uart_putc(ReceivedByte);
  389.  
  390.         if (textflag == 0)
  391.         {
  392.        
  393.                 switch (counter )
  394.                 {
  395.        
  396.                 case 0 :
  397.                         {
  398.                         if (ReceivedByte == soh)
  399.                                 {
  400.                                 }
  401.                         }
  402.                         break;
  403.        
  404.                 case 1 :
  405.                         {
  406.                         seqnr = ReceivedByte;
  407.                         }
  408.                         break;
  409.                 case 2 :
  410.                         {
  411.                         messize = ReceivedByte;
  412.                         }
  413.                         break;
  414.                 case 3 :
  415.                         {
  416.                         cmd = ReceivedByte;
  417. //                      led(cmd);
  418.                         }
  419.                         break;
  420.                 case 4 :
  421.                         {
  422.                         if (ReceivedByte == stx)
  423.                                 {
  424.                                 textflag = 1;
  425.                                 }
  426.                         }
  427.                         break;
  428.                
  429.                 }
  430.                
  431.         ++counter;
  432.         }
  433.  
  434.         else
  435.  
  436.         {
  437.                 if (ReceivedByte != etx)
  438.                         {
  439.                         buffer[bufcounter] = ReceivedByte;
  440.                         ++bufcounter;
  441.         //              UDR = ReceivedByte;
  442.                         }
  443.                 else
  444.                         {
  445.                         buffer[bufcounter] = '\0';
  446.         //              uart_puts(buffer);
  447.                         procedure(cmd);
  448.                         counter = 0;
  449.                         textflag = 0;
  450.                         flag =1;
  451.                         bufcounter = 0;
  452.                 }
  453.                
  454.         }//end if
  455.  
  456.  
  457.  
  458. } //end isr
  459.  
  460. int uart_putc(unsigned char c)
  461. {
  462.     while (!(UCSRA & (1<<UDRE)))  /* wachten tot zenden mogelijk is */
  463.     {
  464.     }                            
  465.  
  466.     UDR = c;                      /* zend een character */
  467.     return 0;
  468. }
  469.  
  470.  
  471. /* puts is onafhankelijk van het controllertype */
  472. void uart_puts(char *s)
  473. {
  474.     while (*s)
  475.     {   /* so lange *s != '\0' dus ongelijk aan een "string-eindteken" */
  476.         uart_putc(*s);
  477.         s++;
  478.     }
  479.         uart_putc('\0');
  480. }
  481. void uart_putheader()
  482. {
  483.         uart_putc(soh);
  484.         uart_putc(seqnr);
  485.         uart_putc(messize);
  486.         uart_putc(cmd);
  487.         uart_putc(stx);
  488. }
  489. void timer1_registers()
  490. {
  491.         uart_puts("TCCR1A");
  492.         uart_puts(itoa(TCCR1A,charbuffer,10));
  493.         uart_puts("TCCR1B");
  494.         uart_puts(itoa(TCCR1B,charbuffer,10));
  495. }
  496. void mot2registers()
  497. //hulproutine voor registers mot2
  498. {       uart_puts("DDRB");
  499.         uart_puts(itoa(DDRB,charbuffer,10));
  500.         uart_puts("PORTB");
  501.         uart_puts(itoa(PORTB,charbuffer,10));
  502.         uart_puts("PORTD");
  503.         uart_puts(itoa(PORTD,charbuffer,10));
  504.         uart_puts("DDRD");
  505.         uart_puts(itoa(DDRD,charbuffer,10));
  506.         uart_puts("TCCR2");
  507.         uart_puts(itoa(TCCR2,charbuffer,10));
  508.         }