mainloop.c

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

/*************************************************************************
描述: 	PDIUSBD12 firware for MSP430F149
文件名:	mainloop.c
修改: 	Miracle G. Eicont.
日期: 	2006-06-08
*************************************************************************/

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

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

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

//*************************************************************************
// USB protocol function pointer arrays
//*************************************************************************



//USB标准请求
void (*StandardDeviceRequest[])(void) =
{
	get_status,
	clear_feature,
	reserved,
	set_feature,
	reserved,
	set_address,
	get_descriptor,
	reserved,
	get_configuration,
	set_configuration,
	get_interface,
	set_interface,
	reserved,
	reserved,
	reserved,
	reserved
};

//用户厂商请求
void (*VendorDeviceRequest[])(void) =
{
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	read_write_register,
	reserved,
	reserved,
	reserved
};


//*************************************************************************
//  Public static data
//*************************************************************************

//*************************************
//这几个变量用于调试,跟踪请求包
//DEVICE_REQUEST DeviceRequest[30];	
//unsigned char LastState_0[30];
//unsigned char LastState_1[30];
//unsigned char InterruptState[30];
//unsigned int CNT = 0;
//unsigned int CNT_1 = 0;
//unsigned int CNT_int=0;
//*************************************
CONTROL_XFER ControlData;
EPPFLAGS bEPPflags;
extern unsigned long ClockTicks;
extern unsigned char GenEpBuf[];
extern IO_REQUEST ioRequest;

extern unsigned char ioSize, ioCount;
extern unsigned char EpBuf[];


BOOL bNoRAM;

const char * _NAME_USB_REQUEST_DIRECTION[] =
{
"Host_to_device",
"Device_to_host"
};

const char * _NAME_USB_REQUEST_RECIPIENT[] =
{
"Device",
"Interface",
"Endpoint(0)",
"Other"
};

const char * _NAME_USB_REQUEST_TYPE[] =
{
"Standard",
"Class",
"Vendor",
"Reserved"
};

const char * _NAME_USB_STANDARD_REQUEST[] =
{
"GET_STATUS",
"CLEAR_FEATURE",
"RESERVED",
"SET_FEATURE",
"RESERVED",
"SET_ADDRESS",
"GET_DESCRIPTOR",
"SET_DESCRIPTOR",
"GET_CONFIGURATION",
"SET_CONFIGURATION",
"GET_INTERFACE",
"SET_INTERFACE",
"SYNC_FRAME"
};


void help_devreq(unsigned char typ, unsigned char req)
{
	typ >>= 5;

	if(typ == USB_STANDARD_REQUEST) 
	{
	}
	else 
	{
		if(bEPPflags.bits.verbose)
			printf("Request Type = %s, bRequest = 0x%bx.\n", _NAME_USB_REQUEST_TYPE[typ],
				req);
	}
}


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;
}


void init_port(void)
{
		
	D12_ctl_sel = 0x0; 	//选择I/O功能
	D12_ctl_dir = (~D12_suspd ) & (~D12_int_flag) & (D12_A0 |D12_cs |D12_wr|D12_wr|D12_rd| D12_rst);			//1 for output
	//只有D12_int_flag是输入脚,其他均为输出脚
	//D12_ctl_IE	=	D12_int_flag; //设置D12中断源
	//D12_ctl_IES =	D12_int_flag; //选择中断沿

	//D12_SUSPD_0;		//不让D12挂起
}

/*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 = 6M 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?                
	
	init_AD(); 
	init_port();  
	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};
	unsigned short i; 
	unsigned char Buf[16];
	_DINT();              
	
	MCU_D12RST_0;	
	for(i=0;i<100;i++);
	MCU_D12RST_1;	
	
	i=D12_ReadChipID();
	init();			
	bEPPflags.value = 0;//EPPFLAGS bEPPflags;
	_EINT();
	reconnect_USB();
	
	while(1)
	{    
		unsigned char i;
		i=P2IN;
		if((i & 0x01)==0)
			fn_usb_isr();
		/*if (adflag)                             //A/D转换数据发送
		{                    
								
			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
				
		*/  
		//D12_WriteEndpoint(5,64,sendvalue);

		if (bEPPflags.bits.ep1_rxdone)              //端点1接收响应
		{
			bEPPflags.bits.ep1_rxdone = 0;            //flag set zero
			Buf[0]=0-GenEpBuf[0];
			Buf[1]=0-GenEpBuf[1];
			Buf[2]=0-GenEpBuf[2];
			Buf[3]=0-GenEpBuf[3];
			D12_WriteEndpoint(3,16,Buf);
			
			//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();
		//	D12_SUSPD_0;
			//D12_SetDMA(0xC3);
				
			
		} // if suspend change
		
		if (bEPPflags.bits.setup_packet)
		{                    //接收到设置包中断处理
			_DINT();
			bEPPflags.bits.setup_packet = 0;
			
			control_handler();
			_EINT();
			//P1OUT |=D12SUSPD;
		} // if setup_packet
	} // Main Loop
}
//返回stall应答
void stall_ep0(void)
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

//断开USB总线
void disconnect_USB(void)
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
}

//连接USB总线
void connect_USB(void)
{
	// reset event flags
	DISABLE;
	bEPPflags.value = 0;//清除所有状态
	ENABLE;

	// V2.1 enable normal+sof interrupt
	D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);

	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M);
}

//重新连接到USB总线
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) ;  
	
	TACTL = 0;
	TACCTL0 = 0; 
	P3OUT |= 0X40;
	
	connect_USB(); 
}

//恢复到未配置状态
void init_unconfig(void)
{
//	unsigned char i;

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

//设置配置状态
void init_config(void)
{
	D12_SetEndpointEnable(1);	/* Enable  generic/iso endpoints. */
}

//从端点号1发送数据
void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

//发送端点号1建立代码
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);//发送16字节数据
		ControlData.wCount += EP0_PACKET_SIZE;
		DISABLE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
		ENABLE;
	}
	else {
		D12_WriteEndpoint(1, ControlData.wLength, pRomData);//发送16字节内数据
		ControlData.wCount += ControlData.wLength;
		DISABLE;
		bEPPflags.bits.control_state = USB_IDLE;
		ENABLE;
	}
}

//DMA建立子程序
void setup_dma()
{
	ioSize = ioRequest.uSize;
	ioCount = 0;

	DISABLE;
	bEPPflags.bits.dma_state = DMA_RUNNING;
	ENABLE;

	single_transmit(0, 0);

	if(ioRequest.bCommand & 0x1) {
		if(ioSize > 64 || ioSize == 0) {
			//传输大于64字节数据
			D12_WriteEndpoint(5, 64, EpBuf);
			ioCount += 64;
		}
		else {
			//传输64字节数据
			D12_WriteEndpoint(5, ioSize, EpBuf);
			ioCount += ioSize;
		}
	}
}

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

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;

	help_devreq(type, req); //显示设备请求

	if (type == USB_STANDARD_REQUEST)
		(*StandardDeviceRequest[req])();//调用标准请求
	else if (type == USB_VENDOR_REQUEST)
		(*VendorDeviceRequest[req])();//调用厂商请求
	else
		stall_ep0();
}