2014年陕西省TI杯B题【金属探测仪】源代码

2014年陕西省TI杯B题【金属探测仪】MSP430F2553源代码

/*2014年陕西省TI杯B题【金属探测仪】MSP430F2553源代码
 * main.c
 *
 *  Created on: 2014-11-26
 *      Author: FangHC
 */


/*
 * MOTOR
 *motor1dir P2.0
 *motor1pul P2.1
 *motor2pul P2.4
 *motor2dir P2.5
 *
 *声光  P2.2
 *
 * LDC1000
 * P1.3--->CSB
 * P1.4--->LDCLK
 * P1.5--->SCLK
 * P1.6--->SDO
 * P1.7--->SDI
 * P1.2--->INT
 */

#include <msp430g2553.h>
#include "LDC1000_cmd.h"
//#include <motorctl.h>


char spi_readByte( char addr, char * data);
char spi_readWord(char addr, unsigned int * data);  // Big Endian
char spi_readBytes( char addr, char * buffer, unsigned char len);
char spi_writeByte(char addr, char data);
char spi_writeWord(char addr, unsigned int data);  // Big Endian
char spi_writeBytes( char addr, char * buffer, unsigned char len);



void motorInit();
void setSpeed_motor1(long int speed);
void setSpeed_motor2(long int speed);
void setDir_motor1(char dir);
void setDir_motor2(char dir);
void powerOff_motor(char motor);

void setTimer(int time);
void timer_init();
void stopTimer();




static unsigned char txlen;
static unsigned char rxlen;
static char *txbuf;
static char *rxbuf;
static char txaddr;
static char wordbuf[2];

char proximtyData[2];
char frequencyData[3];


int proximtyDataMIN;
int frequencyDataMIN;

int proximtyDataMAX;
int frequencyDataMAX;

int proximtyDataTEMP;
int frequencyDataTEMP;

int data1,data2,data3;

char intcout;
char test;
char tim        =  0;
char indelay    =  100;

char process    =  0;
char sign       =  0;

char m2Dir,m1Dir;
char m2DirValue,m1DirValue;

int ta1cout,ta1couttmp,ta1tmp,ta1data,ta2tmp,ta2data;
int dir1tmp,dir2tmp,dir2,dir1;

int delay=10;

#define RPMIN            0x3A
#define RPMAX            0x13

#define Motor2_HighSpeed 30
#define Motor2_LowSpeed  400
#define Motor1_HighSpeed 250
#define Motor1_LowSpeed  750
#define Motor_goFrount   0
#define Motor_goBack     1
#define motor1           1
#define motor2           2
#define all              3

#define time_motor1      2000
#define time_motor2      14400   //14400

#define time_location    32000

#define detected         11150   //11150

#define test             0
#define detection        1
#define location         2

#define stage1              1
#define stage2              2
#define stage3              3
#define stage4              4
#define stage5              5

int main()
{
    WDTCTL = WDTPW | WDTHOLD;
    P1SEL2 = BIT5 | BIT6 | BIT7;    /* Port 1 Port Select 2 Register */
    P1OUT = 0;    /* Port 1 Output Register */
    P1SEL = BIT4 | BIT5 | BIT6 | BIT7;    /* Port 1 Port Select Register */
    P1DIR = BIT2 | BIT3 | BIT4;    /* Port 1 Direction Register */
    P1IES = 0;    /* Port 1 Interrupt Edge Select Register */
    P1IFG = 0;    /* Port 1 Interrupt Flag Register */
    P2OUT = 0;    /* Port 2 Output Register */
    P2SEL = BIT1 | BIT4 | BIT6 | BIT7;    /* Port 2 Port Select Register */
    P2DIR = BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | BIT5;    /* Port 2 Direction Register */
    P2IES = 0;    /* Port 2 Interrupt Edge Select Register */
    P2IFG = 0;    /* Port 2 Interrupt Flag Register */

    /*system clock init*/
    BCSCTL2 = SELM_0 | DIVM_0 | DIVS_1;  //mclk=dco=16MHz，smclk=dco/2=8MHz，aclk=refo=12kHz
    if (CALBC1_16MHZ != 0xFF)
    {
    /* Adjust this accordingly to your VCC rise time */
    __delay_cycles(100000);
    /* Follow recommended flow. First, clear all DCOx and MODx bits. Then
     * apply new RSELx values. Finally, apply new DCOx and MODx bit values.
     */
    DCOCTL = 0x00;
    BCSCTL1 = CALBC1_16MHZ;     /* Set DCO to 16MHz */
    DCOCTL = CALDCO_16MHZ;
    }

    BCSCTL1 |= XT2OFF | DIVA_0; //turn off xt2, aclk 不分频
    BCSCTL3 = XT2S_0 | LFXT1S_0 | XCAP_0;

    UCB0CTL1 |= UCSWRST;
    /* ~UCCKPH -- Data is changed on the first UCLK edge and captured on the following edge
     * UCCKPL -- Inactive state is high
     * UCMSB -- MSB first
     * ~UC7BIT -- 8-bit
     * UCMST -- Master mode
     * UCMODE_0 -- 3-Pin SPI
     * UCSYNC -- Synchronous Mode*/
    UCB0CTL0 |= UCCKPL | UCMSB | UCMST |  UCSYNC;
    /* UCSSEL_2 -- SMCLK
     * UCSWRST -- Enabled. USCI logic held in reset state*/
    UCB0CTL1 |= UCSSEL_2;
    /* Bit Rate Control Register 0 */
    UCB0BR0 = 0x45;
    UCB0BR1 = 0;
    /* Enable USCI */
    UCB0CTL1 &= ~UCSWRST;


    /* ~SCG1 -- Disable System clock generator 1
     * ~SCG0 -- Disable System clock generator 0
     * ~OSCOFF -- Oscillator On
     * ~CPUOFF -- CPU On
     * GIE -- General interrupt enable*/


    int i;
    P2OUT |= BIT5;
    for(i=1000;i>=0;i--);
    P2OUT &= ~BIT5;

    motorInit();
    timer_init();
    intcout=2;
    for(i=10000;i>=0;i--);
    setSpeed_motor2(Motor2_HighSpeed);
    setTimer(time_motor2);
    process=detection;
    sign=stage1;

     //read all REG value using default setting
     char orgVal[20];

     //write to register
     spi_writeByte(LDC1000_CMD_RPMAX,       RPMAX);
     spi_writeByte(LDC1000_CMD_RPMIN,       RPMIN);
     spi_writeByte(LDC1000_CMD_SENSORFREQ,  0x94);
     spi_writeByte(LDC1000_CMD_LDCCONFIG,   0x17);
     spi_writeByte(LDC1000_CMD_CLKCONFIG,   0x02);
     spi_writeByte(LDC1000_CMD_INTCONFIG,   0x02);

     spi_writeByte(LDC1000_CMD_THRESHILSB,  0x50);
     spi_writeByte(LDC1000_CMD_THRESHIMSB,  0x14);
     spi_writeByte(LDC1000_CMD_THRESLOLSB,  0xC0);
     spi_writeByte(LDC1000_CMD_THRESLOMSB,  0x12);

     spi_writeByte(LDC1000_CMD_PWRCONFIG,   0x01);

     //read all registers

     spi_readBytes(LDC1000_CMD_REVID, &orgVal[0],12);


     //read all registers using extended SPI
     while (1)
     {
         spi_readBytes(LDC1000_CMD_PROXLSB,&proximtyData[0],2);

         proximtyDataMAX = ((unsigned char) proximtyData[1]<<8) + proximtyData [0];
/*         frequencyDataMAX = ((unsigned char)frequencyData[1]<<8) + frequencyData[0];*/

         proximtyDataMIN = proximtyDataMAX;


         for (i=0;i<30;i++)
         {
             spi_readBytes(LDC1000_CMD_PROXLSB,&proximtyData[0],2);
/*             spi_readBytes(LDC1000_CMD_FREQCTRLSB,&frequencyData[0],3);*/

             proximtyDataTEMP = ((unsigned char)proximtyData[1]<<8) + proximtyData [0];
/*             frequencyDataTEMP = ((unsigned char)frequencyData[1]<<8) + frequencyData[0];*/

             if (proximtyDataTEMP < proximtyDataMIN)
                 proximtyDataMIN = proximtyDataTEMP;
/*             if (frequencyDataTEMP < frequencyDataMIN)
                 frequencyDataMIN = frequencyDataTEMP;*/

             if (proximtyDataTEMP > proximtyDataMAX)
                 proximtyDataMAX = proximtyDataTEMP;
/*             if (frequencyDataTEMP > frequencyDataMAX)
                 frequencyDataMAX = frequencyDataTEMP;*/

         }
         proximtyDataTEMP=(proximtyDataMAX+proximtyDataMIN)/2;
         proximtyDataMAX=0;
         proximtyDataMIN=0;

         if(process==detection)
         {
             if(proximtyDataTEMP>detected)
                 {
                      process=location;
                 }
         }
         if(process==location)
         {
             if(proximtyDataTEMP>detected && sign==stage1)
             {
                 powerOff_motor(motor2);
                 stopTimer();
                 ta2tmp=TAR;
                 ta1tmp=TA1R;
                 TA0CTL |= TACLR;
                 delay=20000;
                 while(delay--);
                 setSpeed_motor2(Motor2_LowSpeed);
                 setTimer(time_location);
                 m1DirValue=m1Dir;
                 m2DirValue=m2Dir;
                 sign=stage2;
             }
             if(proximtyDataTEMP<=detected && sign==stage2)
             {
                 ta2data=TAR;
                 powerOff_motor(motor2);
                 stopTimer();
                 TA0CTL |= TACLR;
                 P2OUT ^= BIT5;
                 delay=20000;
                 while(delay--);
                 setSpeed_motor2(Motor2_LowSpeed);
                 while(delay--);
                 setTimer(ta2data / 2 + 7);
                 delay=10;
             }
             if(proximtyDataTEMP<=detected && sign==stage3)
             {
                 powerOff_motor(motor1);
                 stopTimer();
                 TA0CTL |= TACLR;
                 P2OUT ^= BIT0;
                 delay=20000;
                 while(delay--);
                 setSpeed_motor1(Motor1_LowSpeed);
                 setTimer(time_location);
                 delay=10;
                 sign=stage4;
             }
             if(proximtyDataTEMP>detected && sign==stage4)
             {
                 delay=20000;
                 while(delay--);
                 sign=stage5;
             }
             if(proximtyDataTEMP<=detected && sign==stage5)
             {
                 ta1data=TAR;
                 powerOff_motor(motor1);
                 stopTimer();
                 P2OUT ^= BIT0;
                 TA0CTL |= TACLR;
                 delay=30000;
                 while(delay--);
                 setSpeed_motor1(Motor1_LowSpeed);
                 while(delay--);
                 setTimer(ta1data / 2 +2);
                 delay=10;
             }
         }
     }
}


char spi_readByte( char addr, char * data)
{
    rxlen = 1;
    rxbuf = data;
    txaddr = addr | 0x80;

   P1OUT &= ~BIT3;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = txaddr;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = 0;
    while (UCB0STAT & UCBUSY);
    * rxbuf = UCB0RXBUF;

    while (UCB0STAT & UCBUSY);
    P1OUT |= BIT3;

    return 0;
}

char spi_readWord(char addr, unsigned int * data)
{
    rxlen = 2;
    rxbuf = &wordbuf[0];
    txaddr = addr | 0x80;

    P1OUT &= ~BIT3;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = txaddr;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = 0;
    while (UCB0STAT & UCBUSY);
    * rxbuf = UCB0RXBUF;
    rxbuf++;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = 0;
    while (UCB0STAT & UCBUSY);
    * rxbuf = UCB0RXBUF;

    while (UCB0STAT & UCBUSY);
    P1OUT |= BIT3;

    return 0;

}
char spi_readBytes( char addr, char * buffer, unsigned char len)
{
    rxlen = len;
    rxbuf = buffer;
    txaddr = addr | 0x80;

    P1OUT &= ~BIT3;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = txaddr;

    while (rxlen > 0)
    {
        while (!(IFG2&UCB0TXIFG));
        UCB0TXBUF = 0;
        while (UCB0STAT & UCBUSY);
        * rxbuf = UCB0RXBUF;
        rxbuf++;
        rxlen--;
    }

    while (UCB0STAT & UCBUSY);
    P1OUT |= BIT3;

    return 0;
}

char spi_writeByte(char addr, char data)
{
    wordbuf[0] = data;          // copy from stack to memory
    txlen = 1;
    txbuf = &wordbuf[0];
    txaddr = addr & ~0x80;

    P1OUT &= ~BIT3;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = txaddr;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = *txbuf;

    while (UCB0STAT & UCBUSY);
    P1OUT |= BIT3;

    return 0;
}

char spi_writeWord(char addr, unsigned int data)
{
    wordbuf[0] = data >> 8;    // Big Endian
    wordbuf[1] = data & 0xFF;
    txlen = 2;
    txbuf = &wordbuf[0];
    txaddr = addr & ~0x80;

    P1OUT &= ~BIT3;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = txaddr;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = *txbuf;
    txbuf++;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = *txbuf;

    while (UCB0STAT & UCBUSY);
    P1OUT |= BIT3;

    return 0;

}

char spi_writeBytes( char addr, char * buffer, unsigned char len)
{
    txlen = len;
    txbuf = buffer;
    txaddr = addr & ~0x80;

    P1OUT &= ~BIT3;
    while (!(IFG2&UCB0TXIFG));
    UCB0TXBUF = txaddr;

    while (txlen > 0) {
        while (!(IFG2&UCB0TXIFG));
        UCB0TXBUF = *txbuf;
        txbuf++;
        txlen--;
            }

    while (UCB0STAT & UCBUSY);
    P1OUT |= BIT3;

    return 0;
}


void motorInit()
{
   TA1CCTL0 = CM_2 | CCIS_0 | OUTMOD_0;
   TA1CCTL1 = CM_1 | CCIS_0 | OUTMOD_7;
   TA1CCTL2 = CM_1 | CCIS_0 | OUTMOD_7;
   TA1CCR0 = 1250;
   TA1CCR1 = 0;
   TA1CCR2 = 0;
   TA1CTL = TASSEL_2 | ID_3 | MC_1;

   TA0CCTL0 = CM_0 | CCIS_0 | OUTMOD_0 | CCIE;
   TA0CTL = TASSEL_1 | ID_2 | MC_1;
   setDir_motor1(Motor_goFrount);
   setDir_motor2(Motor_goFrount);
}


void setSpeed_motor1(long int speed)
{
  TA1CTL = TASSEL_0 | ID_3 | MC_1;
  TA1CCR0 = speed;
  TA1CCR1 = speed/2;
  TA1CTL = TASSEL_2 | ID_3 | MC_1;
}

void setSpeed_motor2(long int speed)
{
  TA1CTL = TASSEL_0 | ID_3 | MC_1;
  TA1CCR0 = speed;
  TA1CCR2 = speed/3;
  TA1CTL = TASSEL_2 | ID_3 | MC_1;
}


void setDir_motor1(char dir)
{
  if(dir)P2OUT |= BIT0;
  else P2OUT &= ~BIT0;
}


void setDir_motor2(char dir)
{
  if(dir)P2OUT |= BIT5;
  else P2OUT &= ~BIT5;
}


void powerOff_motor(char motor)
{
  if(motor==motor1)TA1CCR1=0;
  if(motor==motor2)TA1CCR2=0;
  if(motor==all){TA1CCR1=0;TA1CCR2=0;}
}


void timer_init()
{
  TA0CCTL0 = CM_0 | CCIS_0 | OUTMOD_0 | CCIE;
  TA0CCR0 = 100;
  TA0CTL = TASSEL_0 | ID_2 | MC_1;
}


void setTimer(int time)
{
  TA0CCR0 = time;
  TA0CTL = TASSEL_1 | ID_2 | MC_1;
  _BIS_SR(GIE);
}

void stopTimer()
{
  TA0CTL = TASSEL_0;
}


void reset()
{

}


#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR_HOOK(void)
{
    if(process==detection || process==test)
    {
        if(intcout==1)
        {
          stopTimer();
          powerOff_motor(1);
          if(m2Dir==1)m2Dir=0;
          else m2Dir=1;
          setDir_motor2(m2Dir);
          TA0CTL |= TACLR;
          setSpeed_motor2(Motor2_HighSpeed);
          setTimer(time_motor2);
          intcout=2;
        }
        else
        {
          stopTimer();
          powerOff_motor(2);
          TA0CTL |= TACLR;
          setSpeed_motor1(Motor1_HighSpeed);
          setTimer(time_motor1);
          intcout=1;
          ta1cout++;

        }
        if(ta1cout>=41)
        {
            if(m1Dir==1)m1Dir=0;
            else m1Dir=1;
            setDir_motor1(m1Dir);
            ta1cout=0;
        }
    }

    if(process==location && sign==stage2)
    {
        powerOff_motor(motor2);
        stopTimer();
        P2OUT ^= BIT0;
        sign=stage3;
        delay=10000;
        while(delay--);
        setSpeed_motor1(Motor1_LowSpeed);
        setTimer(time_location);
    }
    if(process==location && sign==stage5)
    {
        powerOff_motor(motor1);
        stopTimer();
        int a,b;
        while(1)
        {
            P2OUT |= BIT2;
            a=50;
            while(a--)
            {
                b=1000;
                while(b--)P2OUT |= BIT2;
                b=1000;
                while(b--)P2OUT &= ~BIT2;
            }
            P2OUT &= ~BIT2;
            a=100;
            while(a--)
            {
                b=20000;
                while(b--);
            }

        }
    }
}