usb430.c

msp430单片机与pdiusbd12接口的固件程序

#include <stdio.h>
#include <string.h>

#include <msp430x14x.h>   /* special function register declarations */

#include "epphal.h"
#include "d12ci.h"
#include "mainloop.h"
#include "usb100.h"
#include "chap_9.h"
#include "usb.h"


void init_TimerB(void)			//500kHz
{
	TBCTL = TBSSEL_2 + TBCLR;     //Timer B clock source select: 2 - SMCLK 
	TBCCR0 = 7;                   // PWM Period:500K Hz
	TBCCTL1 = OUTMOD_7;           // CCR1 toggle/set
	TBCCR1 = 4;                   // CCR1 PWM duty cycle
	TBCTL |= MC0;                 // Start Timer_B in up mode
}

void init_TimerA(void)
{
	TACTL = TASSEL1 + TACLR;      // SMCLK, clear TAR
	
	CCR0 = 10000;
}

// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
	ClockTicks++;  
}	

void init_special_interrupts(void)
{
	P1DIR &=~0X04;
	P1IFG = 0X0;
	P1IES &=~0X04;
}

void init_port(void)
{
//	P4DIR = 0XFF;
//	P2OUT = 0xFF;
//	P2DIR = 0XFF;
//	P4SEL |= 0X02;                        //TB PWM Output:500K Hz
	D12_dat_dir = 0xff;
	D12_ctl_out = 0xff;
	D12_ctl_dir = 0xbe;
	
	P3DIR |= 0X40;
	P3OUT |= 0X40;
}

/*A/D conversion setup*/
void init_AD(void)
{
	P6SEL = 0xFF;         // Pin P6 used by ADC module
	
	 ADC12CTL0 &=~ 0x02;   // Disable conversion before changing
						   // the ADC12 settings!!!
						   // selection of reference and input 
	 ADC12MCTL0  = 0x10;    // Ref = AVss, Vref+; Input = A0
	 ADC12MCTL1  = 0x11;    // Ref = AVss, AVcc; Input = A1
	 ADC12MCTL2  = 0x12;    // Ref = AVss, AVcc; Input = A2
	 ADC12MCTL3  = 0x93;    // Ref = AVss, AVcc; Input = A3          
	 ADC12MCTL4  = 0x84;    // Ref = AVss, AVcc; Input = A4
	 ADC12MCTL5  = 0x85;    // Ref = AVss, AVcc; Input = A5
	 ADC12MCTL6  = 0x86;    // Ref = AVss, AVcc; Input = A6
	 ADC12MCTL7  = 0x87;    // Ref = AVss, AVcc; Input = A7   //由通道A1至A8
	 ADC12MCTL8  = 0x88;    // Ref = AVss, AVcc; Input = A8   //进行序列转换，
	 ADC12MCTL9  = 0x89;    // Ref = AVss, AVcc; Input = A9
	 ADC12MCTL10 = 0x8A;    // Ref = AVss, AVcc; Input = A10
	 ADC12MCTL11 = 0x8B;    // Ref = AVss, AVcc; Input = A11  //A8-A15不进行转换。
	 ADC12MCTL12 = 0x8C;    // Ref = AVss, AVcc; Input = A12
	 ADC12MCTL13 = 0x8D;    // Ref = AVss, AVcc; Input = A13
	 ADC12MCTL14 = 0x8E;    // Ref = AVss, AVcc; Input = A14
	 ADC12MCTL15 = 0x8F;    // Ref = AVss, AVcc; Input = A15
							// ADC12MCTL7 定义了序列结束点；
							// (EOS bit is set!)
	
	 ADC12CTL1 = 0x0200;    //序列单次转换模式，第一个结果存在
							//ADC12MEM0中，采样信号由采样定时器控制；
	 ADC12CTL0 = 0x0070;    //采用2.5V内部参考电压，打开由部参考电压，
							//打开ADC12内核。
	 ADC12CTL0 |= SHT0_0;
	 ADC12CTL0 |= 0x02;     // enable conversion
	
}
void init(void)					//初始化
{
	unsigned char i;
	WDTCTL = WDTPW + WDTHOLD;           //Stop WDT
	BCSCTL1 &= ~XT2OFF;                 //Enable high frequency oscillator
	BCSCTL2 = 0X88;                     //MCLK = SMCLK = 4M Hz
	do 
	{
		IFG1 &= ~OFIFG;                   //Clear OSCFault flag
		for (i = 0xFF; i > 0; i--);       //Time for flag to set
	}
	while ((IFG1 & OFIFG) == OFIFG);    //OSCFault flag still set?                
	
	D12_ctl_dir = 0xbe;
	
	init_AD(); 
	init_port();  
	init_special_interrupts();
	init_TimerA();
	init_TimerB();
	
	D12_SetAddressEnable(0x0,1);
	init_config();
}

void main(void)
{  
	unsigned char adflag = 0;
	unsigned char channal;
	unsigned int aver,adcount = 0;
	unsigned int advalue[32];
	unsigned char sendvalue[64],adindex = 0;
	unsigned long adtotal[4] = {0};
	
		  
	_DINT();              
	init();
	MCU_D12RST_0;		//#define MCU_D12RST_0 P2OUT &= ~0X04	//in "epphal.h"
	_NOP();
	MCU_D12RST_1;		//#define MCU_D12RST_1 P2OUT |= 0X04	//reset usb chip
					  
	bEPPflags.value = 0;//EPPFLAGS bEPPflags;
	_EINT();
	reconnect_USB();
	P1IE = 0X04;
	
	while(1)
	{    
		if (adflag)                             //A/D转换数据发送
		{                    
					//D12_WriteEndpoint(5,64,test2);		//主端点发送测试
						
			for (adcount=0;adcount < aver;adcount++)
			{
				ADC12CTL0 |= 0x01;                      //开始转换。
				//ADC12CTL0 |= SHT0_15;
				//ADC12CTL0 &=~0x01;
				while (ADC12CTL1&0x01);               //转换完成了吗？
				switch (channal)
				{
					case 1:adtotal[0]+=ADC12MEM0;break;
					case 2:adtotal[1]+=ADC12MEM1;break;
					case 3:adtotal[2]+=ADC12MEM2;break;
					case 4:adtotal[3]+=ADC12MEM3;break;
				}
			}     
					  
			advalue[adindex]=adtotal[channal-1]/aver;adtotal[channal-1]=0;
			sendvalue[adindex*2]=advalue[adindex]/256;
			sendvalue[adindex*2+1]=advalue[adindex]%256;
			adindex++;   
			if (adindex>=32) 
			{
				adindex=0;D12_WriteEndpoint(5,64,sendvalue);
			}    
		}//if adflag
				
			   
		if (bEPPflags.bits.ep1_rxdone)              //端点1接收响应
		{
			bEPPflags.bits.ep1_rxdone = 0;            //flag set zero
			
			
			if(GenEpBuf[3] == 0xff)
				adflag = 1;                             //start A/D
			else if(GenEpBuf[3] == 0xfe)
				adflag = 0;                             //stop A/D
			else 
			{
				aver = GenEpBuf[0] * 256 + GenEpBuf[1]; //获得平均次数
				channal = GenEpBuf[3];                  //获得通道选择
				//adcount=0;
				adindex = 0;
				adtotal[channal-1] = 0;
				ADC12CTL0 &= ~0x02;        //ENC=0
				ADC12CTL1 &= ~0xf000;
				ADC12CTL1 |= ((channal-1)<<12);          //选择转换通道
				ADC12CTL0 |= 0x02;         //ENC=1 
			}
		}//if bEPPflags.bits.ep1_rxdone
		
		
		if (bEPPflags.bits.timer)
		{                               //计时器中断响应
			bEPPflags.bits.timer = 0;
		}
			  
		if (bEPPflags.bits.bus_reset) 
		{                        //总线重起中断响应
			_DINT();
			bEPPflags.bits.bus_reset = 0;
			_EINT();						
		} // if bus reset
		
		if (bEPPflags.bits.suspend) 
		{                          //挂起中断响应
			_DINT();
			bEPPflags.bits.suspend= 0;
			_EINT();
			if((P2OUT & D12_suspd) == D12_suspd) 
			{
				D12_SUSPD_0;
				P5DIR = 0XFF;
				P5OUT = 0xFF;
				P5DIR = 0X0;
				P2DIR = 0XFF;
				P2OUT = 0xFF;
				D12_SetDMA(0xC3);
				D12_SUSPD_1;
			}
		} // if suspend change
		
		if (bEPPflags.bits.setup_packet)
		{                    //接收到设置包中断处理
			_DINT();
			bEPPflags.bits.setup_packet = 0;
			
			control_handler();
			_EINT();
			//P1OUT |=D12SUSPD;
		} // if setup_packet
	} // Main Loop
}

void stall_ep0(void)
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

void disconnect_USB(void)
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
	 				//0x02			//0x40			//0x03   df in d12ci.c
}

void connect_USB(void)
{
	// reset event flags
	bEPPflags.value = 0;
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M);
}


void reconnect_USB(void)
{	  
	// Pull-down D12's SUSPEND pin  
	// Release D12's SUSPEND pin after receiving bus reset from host  
	
	D12_SUSPD_0;
	disconnect_USB();      //初始化D12
	
	ClockTicks = 0;
	TACCTL0 = CCIE;        // TACCR0 interrupt enabled
	TACTL |= MC0;
	
	while(ClockTicks < 400) P3OUT &= ~0X40;  
	
	TACTL = 0;
	TACCTL0 = 0; 
	P3OUT |= 0X40;
	
	connect_USB(); 
}

void init_unconfig(void)
{
	D12_SetEndpointEnable(0);	/* Disable all endpoints but EPP0. */
}

void init_config(void)
{
	D12_SetEndpointEnable(1);	/* Enable  generic/iso endpoints. */
}

void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

void code_transmit(unsigned char * pRomData, unsigned short len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.pData = pRomData;
	if( ControlData.wLength >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData);
		ControlData.wCount += EP0_PACKET_SIZE;
		_DINT();            
			bEPPflags.bits.control_state = USB_TRANSMIT;  //总线处于传输状态
			_EINT();
	}
	else {  
		D12_WriteEndpoint(1, ControlData.wLength, pRomData);
		ControlData.wCount += ControlData.wLength;
		_DINT();
		bEPPflags.bits.control_state = USB_IDLE;          //总线空闲
		_EINT();
	}
}


void control_handler(void)                                //usb请求处理程序
{
	unsigned char type, req;

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;   //请求类型：标准or厂商
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;              //具体请求代号	

	if (type == USB_STANDARD_REQUEST)                                         //标准请求处理
		(*StandardDeviceRequest[req])();
	else
		stall_ep0();
}