PIC16F1938 SD WAV Player

Discussion in 'Embedded Systems and Microcontrollers' started by GOkussj5okazu, Jun 16, 2013.

  1. GOkussj5okazu

    Thread Starter New Member

    Jul 9, 2009
    3
    0
    Hello! I'm hoping someone could help me with this project I've been working on. I initially made and programmed a device using a PIC12F629 to simulate muzzle flash on a prop firearm. Now, I need to make a similar unit with sound playback. So far I've based my program on this project, though I am using a PIC16F1938 for the extra I/O pins that I will be needing later for a numeric display. My goal is to have it flash an LED, and play a very small (less than 70KB) WAV file every time the trigger is pressed. Also, I'm using Source Boost C++.




    This is the original main.c designed for a PIC16F1825 in that project;


    Code ( (Unknown Language)):
    1. #include "common.h"  
    2.   #include "SD.h"  
    3.    
    4.   #define FLAG_TIMEOUT            0x80  
    5.   #define FLAG_PARAM_ERR            0x40  
    6.   #define FLAG_ADDR_ERR            0x20  
    7.   #define FLAG_ERZ_SEQ_ERR      0x10  
    8.   #define FLAG_CMD_CRC_ERR      0x08  
    9.   #define FLAG_ILLEGAL_CMD      0x04  
    10.   #define FLAG_ERZ_RST            0x02  
    11.   #define FLAG_IN_IDLE_MODE      0x01  
    12.    
    13.   #pragma CLOCK_FREQ 32000000  
    14.   #pragma DATA _CONFIG1, _FOSC_INTOSC & _WDTE_SWDTEN & _PWRTE_ON   & _MCLRE_OFF & _CP_ON & _CPD_ON & _BOREN_OFF &   _CLKOUTEN_OFF & _IESO_OFF & _FCMEN_OFF  
    15.   #pragma DATA _CONFIG2, _WRT_OFF & _PLLEN_OFF & _STVREN_ON & _LVP_OFF  
    16.    
    17.   void UARTInit(){  
    18.         //  
    19.         // UART  
    20.         //  
    21.         baudcon.4 = 0;      // SCKP       synchronous bit polarity  
    22.        baudcon.3 = 0;      // BRG16      enable 16 bit brg
    23.         baudcon.1 = 0;      // WUE       wake up enable off  
    24.         baudcon.0 = 0;      // ABDEN      auto baud detect  
    25.            
    26.         txsta.6 = 0;      // TX9       8 bit transmission  
    27.         txsta.5 = 1;      // TXEN       transmit enable  
    28.        txsta.4 = 0;      // SYNC      async mode
    29.         txsta.3 = 0;      // SEDNB      break character  
    30.        txsta.2 = 0;      // BRGH      high baudrate
    31.         txsta.0 = 0;      // TX9D       bit 9  
    32.    
    33.         rcsta.7 = 1;      // SPEN serial port enable  
    34.         rcsta.6 = 0;      // RX9 8 bit operation  
    35.         rcsta.5 = 1;      // SREN enable receiver  
    36.         rcsta.4 = 1;      // CREN continuous receive enable  
    37.            
    38.        spbrgh = 0;      // brg high byte
    39.        spbrg = 51;      // brg low byte ()
    40.          
    41.         apfcon0.2=1;      // tx onto RA.0              
    42.   }  
    43.    
    44.   void UARTSend(unsigned char c){  
    45.        txreg = c;
    46.         while(!txsta.1);  
    47.   }  
    48.    
    49.   void UARTPrint(char *s){  
    50.         while(*s) {  
    51.         UARTSend(*s);  
    52.         s++;  
    53.         }        
    54.   }  
    55.    
    56.   void UARTPrint(char c){UARTSend(c);}  
    57.    
    58.   void UARTPrintNumber(unsigned long n){  
    59.         unsigned long k=1000000000;  
    60.         while(k>0) {  
    61.               UARTSend('0'+n/k);  
    62.               n%=k;  
    63.               k/=10;  
    64.         }  
    65.   }  
    66.    
    67.   void UARTPrintLn(char *s){  
    68.         UARTPrint(s);  
    69.         UARTPrint("\r\n");  
    70.   }  
    71.    
    72.   void UARTByte(unsigned char b){    
    73.         const char *hex="0123456789abcdef";  
    74.         UARTPrint("0x");  
    75.         UARTSend(hex[b>>4]);  
    76.         UARTSend(hex[b & 0xf]);  
    77.   }  
    78.    
    79.   void UARTLog(char *s, unsigned short iv){  
    80.         UARTPrint(s);  
    81.         UARTPrint(" ");  
    82.         UARTPrintNumber(iv);  
    83.         UARTPrintLn(" ");  
    84.   }  
    85.    
    86.  void fatal(UInt8 val){            //fatal error: flash led then go to sleep
    87.         UInt8 i, j, k;  
    88.    
    89.         for(j = 0; j < 5; j++){        
    90.              for(k = 0; k < val; k++)
    91.               {  
    92.                     delay_ms(100);  
    93.                     P_LED = 1;  
    94.                     delay_ms(100);  
    95.                     P_LED = 0;  
    96.               }  
    97.                
    98.              UARTLog("Error",val);
    99.                
    100.               delay_ms(250);  
    101.               delay_ms(250);  
    102.         }  
    103.          
    104.         while(1){  
    105.              asm sleep
    106.         }  
    107.   }

    So far, this is what I have modified it to, and included my muzzle flash coding. I know there's definitely something I'm not catching here, so please let me know any errors you might see. Also, I need to figure out how exactly to activate sound playback after the LED flash.


    Code ( (Unknown Language)):
    1. #include "common.h"
    2.  #include "SD.h"
    3.  #include "PIC16F1938.h"
    4.  #include "BoostC.h"
    5.  
    6.  #define FLAG_TIMEOUT            0x80
    7.  #define FLAG_PARAM_ERR            0x40
    8.  #define FLAG_ADDR_ERR            0x20
    9.  #define FLAG_ERZ_SEQ_ERR        0x10
    10.  #define FLAG_CMD_CRC_ERR        0x08
    11.  #define FLAG_ILLEGAL_CMD        0x04
    12.  #define FLAG_ERZ_RST            0x02
    13.  #define FLAG_IN_IDLE_MODE        0x01
    14.  
    15.  #pragma CLOCK_FREQ 32000000
    16.  #pragma DATA _CONFIG1,
    17.          _FOSC_INTOSC &        // INTOSC oscillator: I/O Functions
    18.          _WDTE_OFF &            // WDT Disabled
    19.          _PWRTE_ON &            // PWRT Enabled
    20.          _MCLRE_OFF &        // MCLR/VPP pin function is Input
    21.          _CP_OFF &            // Program memory code protection is disabled
    22.          _CPD_OFF &            // Data memory code protection is disabled
    23.          _BOREN_NSLEEP &        // Brown-out Reset Disabled During Sleep
    24.          _CLKOUTEN_OFF &        // CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin
    25.          _IESO_OFF &            // Internal/External Switchover mode is disabled
    26.          _FCMEN_OFF            // Fail-Safe Clock Monitor is disabled
    27.  
    28.  #pragma DATA _CONFIG2,
    29.          _WRT_OFF &            // Write protection off
    30.          _VCAPEN_RA0 &        // VCAP on RA0
    31.          _PLLEN_OFF &        // 4x PLL disabled
    32.          _STVREN_ON &        // Stack Overflow or Underflow will cause a Reset
    33.          _BORV_25 &            // Brown-out Reset Voltage (VBOR) set to 2.5 V
    34.          _LVP_OFF            // High-voltage on MCLR/VPP must be used for programming
    35.        
    36.  
    37.  void MuzzleFlash(void)
    38.  {
    39.      ansela = 0b00000000;     // ANSELA all Digital
    40.      trisa = 0b00000111;        // Set Inputs
    41.      porta = 0b00000000;        // All Outputs are 0
    42.      
    43.      for(;;)                    // Forever
    44.      {
    45.      if(TRIG ==0)            // Debounce Check
    46.          {
    47.          delay_ms(50);
    48.              if(TRIG == 0)    // While TRIG switch held low
    49.              {  
    50.              MUZZ_LED = 0;    // MUZZ LED Off
    51.              delay_ms(10);        
    52.              MUZZ_LED = 1;    // MUZZ LED On
    53.              delay_ms(35);
    54.              MUZZ_LED = 0;    // MUZZ LED Off
    55.              delay_ms(122);
    56.              }
    57.          }
    58.      }
    59.  }
    60.  
    61.  void UARTInit()
    62.  {
    63.                              //
    64.                              // UART
    65.                              //
    66.        baudcon.4 = 0;        // SCKP            synchronous bit polarity
    67.        baudcon.3 = 0;        // BRG16        enable 16 bit brg
    68.        baudcon.1 = 0;        // WUE            wake up enable off
    69.        baudcon.0 = 0;        // ABDEN        auto baud detect
    70.        
    71.        txsta.6 = 0;            // TX9            bit transmission
    72.        txsta.5 = 1;            // TXEN            transmit enable
    73.        txsta.4 = 0;            // SYNC            async mode
    74.        txsta.3 = 0;            // SEDNB        break character
    75.        txsta.2 = 0;            // BRGH            high baudrate
    76.        txsta.0 = 0;            // TX9D            bit 9
    77.  
    78.        rcsta.7 = 1;            // SPEN            serial port enable
    79.        rcsta.6 = 0;            // RX9             8 bit operation
    80.        rcsta.5 = 1;            // SREN         enable receiver
    81.        rcsta.4 = 1;            // CREN         continuous receive enable
    82.        
    83.        spbrgh = 0;            // brg high byte
    84.        spbrg = 51;            // brg low byte ()
    85.        
    86.        apfcon.1 = 1;            // SSSEL        SS on RA0
    87.                  
    88.  }
    89.  
    90.  void UARTSend(unsigned char c)
    91.  {
    92.        txreg = c;
    93.        while(!txsta.1);
    94.  }
    95.  
    96.  void UARTPrint(char *s)
    97.  {
    98.        while(*s)  
    99.        {
    100.        UARTSend(*s);
    101.        s++;
    102.        }      
    103.  }
    104.  
    105.  void UARTPrint(char c)
    106.  {
    107.        UARTSend(c);
    108.  }
    109.  
    110.  void UARTPrintNumber(unsigned long n)
    111.  {
    112.        unsigned long k=1000000000;
    113.        while(k>0)  
    114.        {
    115.              UARTSend('0'+n/k);
    116.              n%=k;
    117.              k/=10;
    118.        }
    119.  }
    120.  
    121.  void UARTPrintLn(char *s)
    122.  {
    123.        UARTPrint(s);
    124.        UARTPrint("\r\n");
    125.  }
    126.  
    127.  void UARTByte(unsigned char b)
    128.  {
    129.        const char *hex="0123456789abcdef";
    130.        UARTPrint("0x");
    131.        UARTSend(hex[b>>4]);
    132.        UARTSend(hex[b & 0xf]);
    133.  }
    134.  
    135.  void UARTLog(char *s, unsigned short iv)
    136.  {
    137.        UARTPrint(s);
    138.        UARTPrint(" ");
    139.        UARTPrintNumber(iv);
    140.        UARTPrintLn(" ");
    141.  }
    142.  
    143.  void fatal(UInt8 val)                    //fatal error: flash led then go to sleep
    144.  {                                        
    145.        UInt8 i, j, k;
    146.  
    147.        for(j = 0; j < 5; j++)
    148.        {      
    149.              for(k = 0; k < val; k++)
    150.              {
    151.                    delay_ms(100);
    152.                    ERROR_LED = 1;
    153.                    delay_ms(100);
    154.                    ERROR_LED = 0;
    155.              }
    156.              
    157.              UARTLog("Error",val);
    158.              
    159.              delay_ms(250);
    160.              delay_ms(250);
    161.        }
    162.        
    163.        while(1)
    164.        {
    165.              asm sleep
    166.        }
    167.  }
    If you need to see my common.h or sd.h files, I can post them too. Thanks in advance!
     
  2. djsfantasi

    AAC Fanatic!

    Apr 11, 2010
    2,812
    834
    I am curious about your Muzzle flash/project. Could you PM me with more details and y a link to it. Thank you
     
Loading...