main1.c

基于MSP430平台位置速度系统的设计 MSP430 驱动

/*
**  Copyright (c) 2008, Shanshan.
**
**  Project: Graduation Design
**  File:    main.c
**  Author:  Shanshan
**  Date:    19/05/2008
**
**  Purpose:
**    Main function entry file.
**
*/



/* Include files. */

#include <msp430x14x.h> // Standard Equations
#include "in430.h"
#include "stdlib.h"
#include "stdio.h"
#include "main.h"


/* Macro constant definitions. */


/* Type definitions. */


/* Local function declarations. */


/* Macro API definitions. */


/* Global variable definitions. */


unsigned long ulCount = 0,TBCounter = 0;
unsigned char ucCountFlg = 0,ucLEDFlg = GAS ,ucPowerFlg = 0;
unsigned char buffer[num];
unsigned int step_num;
unsigned char  flag=0;
INT8U	BridgeBuf[15],rcfrpcbuf[6],sentopcbuf[15];
INT8U   string[10];
unsigned int   stepall,circleall,flag1,flagall;
unsigned int stepcount,stepf,stepcountever;
INT8U resettopcbuf[]="A99999P0D00000E";
INT8U   distance[5];
INT8U   huiche[]="12345";
unsigned int dis;
//INT8U   step=0;
INT8U   NoSend=1;


ISRRUNNINGFLAG	ISRRunningFlag0,ISRRunningFlag1;
INT8U	RecvRingBufForUsart0[RINGBUFLEN+1];
INT8U	SendRingBufForUsart0[RINGSENDBUFLEN+1];
INT8U	RecvRingBufForUsart1[RINGBUFLEN1+1];
INT8U	SendRingBufForUsart1[RINGSENDBUFLEN1+1];
USATRBUFFPTR	SendQueuePtr0, RecvQueuePtr0,SendQueuePtr1, RecvQueuePtr1;


void
Delay(INT32 n)
{

    INT8 i;


    while(n--)
    {
        for(i=0;i<80;i++);	
    }

} /* End of Delay() */


static void
ManagePtr0Init()
{

    SendQueuePtr0.headPtr = 0;
    SendQueuePtr0.endPtr = 0;
    SendQueuePtr0.count = 0;

    RecvQueuePtr0.headPtr = 0;
    RecvQueuePtr0.endPtr = 0;
    RecvQueuePtr0.count = 0;

    ISRRunningFlag0.usartTxISR = 0;
    ISRRunningFlag0.recPacketTimerOut = 0;
    ISRRunningFlag0.noUsed = 0;

} /* End of ManagePtr0Init() */


static void
ManagePtr1Init()
{

    SendQueuePtr1.headPtr = 0;
    SendQueuePtr1.endPtr = 0;
    SendQueuePtr1.count = 0;

    RecvQueuePtr1.headPtr = 0;
    RecvQueuePtr1.endPtr = 0;
    RecvQueuePtr1.count = 0;

    ISRRunningFlag1.usartTxISR = 0;
    ISRRunningFlag1.recPacketTimerOut = 0;
    ISRRunningFlag1.noUsed = 0;

} /* End of ManagePtr1Init () */


static void
Uart0Init(void)
{

    //UCTL0 = SWRST;
    UCTL0 = CHAR;
    UTCTL0 = SSEL1;             /* USART0选择smclk */
    UBR00 = 0x41;               /* 8MHz 9600 */
    UBR10 = 0x03;               /* 8MHz 9600 */
    UMCTL0 = 0x81;              /* 8MHz 9600 modulation */
    ME1 |= UTXE0 + URXE0;       /* Enable USART0 TXD/RXD */
    IE1 |= URXIE0;
    // IE1 |= URXIE0;           /* Enable USART0 RX interrupt */
    //UCTL0 &= ~SWRST;
    P3SEL |= 0x30;              /* P3.4,5 = USART0 TXD/RXD */
    P3DIR |= 0x10;              /* P3.4 output direction */
    //_EINT();                  /* Enable interrupts */


    ISRRunningFlag0.usartTxISR = 0;
    ManagePtr0Init();

}/* End of Uart0Init() */


static void
Uart1Init(void)
{

    UCTL1 = SWRST;
    UCTL1 = CHAR;
    UTCTL1 = SSEL1;             /* USART0选择smclk */
    UBR01 = 0x41;               /* 8MHz 115200 */
    UBR11 = 0x03;               /* 8MHz 115200 */
    UMCTL0 = 0x81;              /* 8MHz 115200 modulation */
    ME2 |= UTXE1 + URXE1;       /* Enable USART1 TXD/RXD */
    IE2 |= URXIE1;              /* Enable USART1 RX interrupt */
    UCTL1 &= ~SWRST;
    P3SEL |= 0xC0;              /* P3.6,7 = USART1 option select */
    P3DIR |= 0x20;              /* P3.6 = output direction */


    ISRRunningFlag1.usartTxISR = 0;
    ManagePtr1Init();

}/* End of Uart1Init() */


static INT8
Usart0SendQueueNoFull(void)
{

    if(SendQueuePtr0.count < RINGSENDBUFLEN)
    {
        return 1;
    }

    return 0;

} /* End of Usart0SendQueueNoFull() */


static INT8
Usart1SendQueueNoFull(void)
{

    if(SendQueuePtr1.count < RINGSENDBUFLEN1)
    {
        return 1;
    }

    return 0;

} /* End of Usart1SendQueueNoFull() */


static INT8
Usart0RecvQueueNoEmpty(void)
{

    if(RecvQueuePtr0.count)
    {
        return 1;
    }

    return 0;

} /* End of Usart0RecvQueueNoEmpty() */


static INT8
Usart1RecvQueueNoEmpty(void)
{

    if(RecvQueuePtr1.count)
    {
        return 1;
    }

    return 0;

} /* End of Usart1RecvQueueNoEmpty() */


static void
startupUSART0Send()
{

    IE1 |= UTXIE0;

} /* End of startupUSART0Send() */


static void
startupUSART1Send()
{

    IE2 |= UTXIE1;

} /* startupUSART1Send() */


static INT8U
USART0SendData(INT8U* buf, INT8U len)
{

    INT8U	count=0;


    if((buf == (void*)0) || (len == 0))
    {
        return count;
    }

    do
    {
        if(Usart0SendQueueNoFull() == 1)
        {
            SendRingBufForUsart0[SendQueuePtr0.headPtr] = buf[count];
            count++;
            _DINT();
            SendQueuePtr0.headPtr++;
            SendQueuePtr0.headPtr &= RINGSENDBUFLEN;
            SendQueuePtr0.count++;
            _EINT();
        }
        else
        {
            break;
        }

    }while(count != len);

    if(!ISRRunningFlag0.usartTxISR)
    {
        startupUSART0Send();
    }

    return count;

}/* End of USART0SendData() */


static INT8U
USART1SendData(INT8U* buf, INT8U len)
{

    INT8U	count=0;


    if((buf == (void*)0) || (len == 0))
    {
        return count;
    }

    do
    {
        if(Usart1SendQueueNoFull() == 1)
        {
            SendRingBufForUsart1[SendQueuePtr1.headPtr] = buf[count];
            count++;
            _DINT();
            SendQueuePtr1.headPtr++;
            SendQueuePtr1.headPtr &= RINGSENDBUFLEN1;
            SendQueuePtr1.count++;
            _EINT();
        }
        else
        {
            break;
        }

    }while(count != len);

    if(!ISRRunningFlag1.usartTxISR)
    {
        startupUSART1Send();
    }

    return count;

}/* End of USART1SendData() */


static INT8U
USART0RecvData(unsigned char* buf, unsigned char len)
{

    unsigned char	count=0;


    if((buf == (void*)0) || (len == 0))
    {
        return count;
    }

    while(Usart0RecvQueueNoEmpty() == 1)
    {

        buf[count] = RecvRingBufForUsart0[RecvQueuePtr0.endPtr];
        count++;
        _DINT();
        RecvQueuePtr0.endPtr++;
        RecvQueuePtr0.endPtr &= RINGBUFLEN;
        RecvQueuePtr0.count--;
        _EINT();

        if(count == len)
        {
            break;
        }

    }

    return count;

}/* End of USART0RecvData() */


static INT8U
USART1RecvData(unsigned char* buf, unsigned char len)
{

    unsigned char	count=0;

    if((buf == (void*)0) || (len == 0))
    {
        return count;
    }

    while(Usart1RecvQueueNoEmpty() == 1)
    {
        buf[count] = RecvRingBufForUsart1[RecvQueuePtr1.endPtr];
        count++;
        _DINT();
        RecvQueuePtr1.endPtr++;
        RecvQueuePtr1.endPtr &= RINGBUFLEN1;
        RecvQueuePtr1.count--;
        _EINT();

        if(count == len)
        {
            break;
        }
    }

    return count;

}/* End of USART1RecvData() */


#if 0
#pragma vector=USART0RX_VECTOR
__interrupt void Usart0RxISR(void)
{

    if(URCTL0&0x80)
        return;

    RecvRingBufForUsart0[RecvQueuePtr0.headPtr] = RXBUF0;
    /* SendDataTo595(RecvRingBufForUsart0[RecvQueuePtr0.headPtr]); */
    if(RecvQueuePtr0.count < RINGBUFLEN)
    {
        RecvRingBufForUsart0[RecvQueuePtr0.headPtr] = RXBUF0;
        RecvQueuePtr0.headPtr++;
        RecvQueuePtr0.headPtr &= RINGBUFLEN;
        RecvQueuePtr0.count++;
    }

}
#endif


#pragma vector=USART0RX_VECTOR
__interrupt void
Usart0RxISR(void)
{

    //if(URXIFG1)
    if(RXBUF0=='R')
    {
        //  BridgeBuf[0]=='S'
        rcfrpcbuf[0]=RXBUF0;
        Delay(15);
        rcfrpcbuf[1]=RXBUF0;
        Delay(15);
        rcfrpcbuf[2]=RXBUF0;
        Delay(15);
        rcfrpcbuf[3]=RXBUF0;
        Delay(15);
        rcfrpcbuf[4]=RXBUF0;
        Delay(15);
        rcfrpcbuf[5]=RXBUF0;
        Delay(15);

        if(rcfrpcbuf[5]=='0')
        {
            CCR0=50000;
        }

        if(rcfrpcbuf[5]=='1')
        {
            CCR0=30000;
        }

        if(rcfrpcbuf[5]=='2')
        {
            CCR0=20000;
        }

        if(rcfrpcbuf[5]=='3')
        {
            CCR0=10000;
        }

        if(rcfrpcbuf[5]=='4')
        {
            CCR0=5000;
        }

        if(rcfrpcbuf[5]=='5')
        {
            CCR0=4000;
        }

        if(rcfrpcbuf[5]=='6')
        {
            CCR0=1000;
        }

        if(rcfrpcbuf[5]=='7')
        {
            CCR0=700;
        }

        if(rcfrpcbuf[5]=='8')
        {
            CCR0=400;
        }

        if(rcfrpcbuf[5]=='9')
        {
            CCR0=200;
        }

        /*
        BridgeBuf[11]=RXBUF1;
        Delay(15);
        BridgeBuf[12]=RXBUF1;
        Delay(15);
        BridgeBuf[13]=RXBUF1;
        Delay(15);
        */

    }

}/* End of Usart0RxISR() */


#pragma vector=USART1RX_VECTOR
__interrupt void
Usart1RxISR(void)
{

    if(URXIFG1)
    {
        if(RXBUF1=='A')
        {
            //  BridgeBuf[0]=='S'
            BridgeBuf[0]=RXBUF1;
            Delay(15);
            BridgeBuf[1]=RXBUF1;
            Delay(15);
            BridgeBuf[2]=RXBUF1;
            Delay(15);
            BridgeBuf[3]=RXBUF1;
            Delay(15);
            BridgeBuf[4]=RXBUF1;
            Delay(15);
            BridgeBuf[5]=RXBUF1;
            Delay(15);
            BridgeBuf[6]=RXBUF1;
            Delay(15);
            BridgeBuf[7]=RXBUF1;
            Delay(15);
            BridgeBuf[8]=RXBUF1;
            Delay(15);

        }

    }

}/* End of Usart1RxISR() */


#if 0
#pragma vector=USART1RX_VECTOR
__interrupt void Usart1RxISR(void)
{
    if(URCTL1&0x80)
        return;

    RecvRingBufForUsart1[RecvQueuePtr1.headPtr] = RXBUF1;
    if(RecvQueuePtr1.count < RINGBUFLEN1)
    {
        RecvRingBufForUsart1[RecvQueuePtr1.headPtr] = RXBUF1;
        RecvQueuePtr1.headPtr++;
        RecvQueuePtr1.headPtr &= RINGBUFLEN1;
        RecvQueuePtr1.count++;
    }

}
#endif


#pragma vector=USART0TX_VECTOR
__interrupt void
Usart0TxISR(void)
{

    ISRRunningFlag0.usartTxISR = 1;

    if(SendQueuePtr0.headPtr != SendQueuePtr0.endPtr)
    {
        TXBUF0 = SendRingBufForUsart0[SendQueuePtr0.endPtr];
        SendQueuePtr0.endPtr++;
        SendQueuePtr0.endPtr &= RINGSENDBUFLEN;
        SendQueuePtr0.count--;
    }

    if(SendQueuePtr0.headPtr == SendQueuePtr0.endPtr)
    {
        ISRRunningFlag0.usartTxISR = 0;
        IE1 &= ~UTXIE0;
    }

} /* End of Usart0TxISR() */


#pragma vector=USART1TX_VECTOR
__interrupt void
Usart1TxISR(void)
{

    ISRRunningFlag1.usartTxISR = 1;

    if(SendQueuePtr1.headPtr != SendQueuePtr1.endPtr)
    {
        TXBUF1 = SendRingBufForUsart1[SendQueuePtr1.endPtr];
        SendQueuePtr1.endPtr++;
        SendQueuePtr1.endPtr &= RINGSENDBUFLEN1;
        SendQueuePtr1.count--;
    }

    if(SendQueuePtr1.headPtr == SendQueuePtr1.endPtr)
    {
        ISRRunningFlag1.usartTxISR = 0;
        IE2 &= ~UTXIE1;
    }

} /* End of Usart1TxISR() */


INT8U *
itoa(INT16U value, INT8U * buf, INT8U radix)
{

    INT16U i;
    INT8U * ptr, * temphold;


    temphold = buf;
    ptr = buf + 12;
    *--ptr = 0;		// Insert NULL char
    do
    {
        // First create string in reverse order
        i = (value % radix) + 0x30;
        if(i > 0x39) i += 7;
        *--ptr = i;
        value = value / radix;
    } while(value != 0);

    // Next, move the string 6 places to the left Include NULL character
    for( ; (*buf++ = *ptr++); );

    return(temphold);

} /* End of itoa() */
//itoa(air_temperature/1000, text, 10);
//ad

ADCPROCESSPARAM	ADCProcessParm;


void
StartADC12(void)
{

    P6SEL = 0x07;
    P6DIR = 0x00;
    ADC12CTL0 &= ~ENC;
    ADC12MCTL0 = SREF_0 + INCH_0;/*供电测量*/
    ADC12CTL1 = CSTARTADD_0 + SHS_0 + SHP + ADC12DIV_0 + ADC12SSEL_0 + CONSEQ_0;
    ADC12CTL0 |= SHT0_8 + SHT0_2 + SHT0_1 + ADC12ON;
    ADC12IE = 1;
    ADC12CTL0 |= ENC + ADC12SC;

} /* End of StartADC12() */


#pragma vector=ADC_VECTOR
__interrupt void
AdcISR(void)
{
    unsigned int	IntVector=0;
    _DINT();
    IntVector = ADC12IV;
    switch(IntVector)
    {
        case 6:
            *((unsigned int*)ADCProcessParm.Power) = ADC12MEM0;
            //ADC12CTL0 = 0x0000;
            //ADC12CTL1 = 0x0000;
            break;

        default:
            break;
    }

} /* End of AdcISR() */


void
sentopc(void)
{

    unsigned int i,j,lenth;


    if(((BridgeBuf[0]=='A')&&(BridgeBuf[8]=='E'))&&(BridgeBuf[6]=='P'))
    {
        for(i=0;i<8;i++)
            sentopcbuf[i]=BridgeBuf[i];
        Distance(circleall,stepall);
        itoa(dis,distance,10);

        lenth=1;
        if(dis>9999)
            lenth=5;
        else if(dis>999)
            lenth=4;
        else if(dis>99)