[MSP430]/MSP430F20132011. 10. 26. 17:27

[MSP430 PWM] MSP430F2013 PWM

[MSP430 PWM] MSP430F2013 PWM

MSP430의 PWM 출력은 TA0, TA1에서 가능한데 P1.1, P1.2 (P1.5, P1.6)에서 출력 가능하다.



PWM 초기화
void PwmInit2(void)
{
 Sbi(P1DIR, BIT2);                  // P1.2 output
 Bit(P1SEL, BIT2);                  // P1.2 TA1 options

 CCR0 = PWM_PERIOD;                 // PWM Period/2
 CCTL1 = OUTMOD_6;                  // CCR1 toggle/set
 CCR1 = PWM_PERIOD/2;               // CCR1 PWM duty cycle
 TACTL = TASSEL_2 + MC_3;           // SMCLK, up-down mode  
}


PWM출력
#define SetPWMp2(Percent)  CCR1 = (float)PWM_PERIOD/(100.0/(100.0-Percent))


Posted by nexp

댓글을 달아 주세요

[MSP430]/MSP430_EVM2010. 10. 6. 19:50

[MSP430] 풀업저항 설정 - 스위치 입력처리

[MSP430] 풀업저항 설정 - 스위치 입력처리

MSP430의 내부 풀업 저항 설정은 REN레지스터를  셋팅해 주면 된다.


내부 풀업을 사용할경우 저항이 고정되어 있어서 1.6uA정도가 소모된다.(MSP430자체는 nA단위로 소모한다.) 만약 저전류로 동작하기를 원한다면 외부에 더 큰저항으로 풀업 하는것이 좋다.


#define SW_BIT      (BIT0|BIT1|BIT2|BIT3)
#define SW_PORT         P1IN
#define SwInit()     Sbi(P1REN, SW_BIT);Cbi(P1DIR, SW_BIT);

#define GetSw()         ((~SW_PORT)&SW_BIT)


main()
{
    SwInit();     

    while(1)
    {
        sw_new = GetSw();
       
        if(sw_new != sw_old)
        {
         

        }
        sw_old = sw_new;
}










Posted by nexp

댓글을 달아 주세요

[MSP430]/MSP430F22xx2010. 3. 7. 23:00

[MSP430F2274 EVM] SPI테스트 - 가속도 센서 테스트

[MSP430F2274 EVM] SPI테스트 - 가속도 센서 테스트




MSP430F2274 SPI 블록도



[MSP430F2274 EVM] 보드에서 SPI는 P3.0~P3.3에 할당되어 있는 UCB0-SPI를 사용하고 있다.



spi.c 드라이이버 함수의 초기화 및 송수신 함수만 수정하면 기존 코드 그대로 사용할 수 있다.
#define SPI0_WRITE_BYTE(x)                 UCB0TXBUF = (x);
#define SPI0_READ_BYTE()     UCB0RXBUF
#define SPI0_WAIT_FOR_EN()     while (!(IFG2&UCB0TXIFG));
#define SPI0_WAIT_FOR_SEND()              while (UCB0STAT & UCBUSY);
#define SPI0_WAIT_FOR_RX()     while (!(IFG2&UCB0RXIFG))

//USCIB0 for 2271
#define TI_CC_SPI_USCIB0_PxSEL   P3SEL
#define TI_CC_SPI_USCIB0_PxDIR   P3DIR
#define TI_CC_SPI_USCIB0_PxIN    P3IN
#define TI_CC_SPI_USCIB0_SIMO    BIT1
#define TI_CC_SPI_USCIB0_SOMI    BIT2
#define TI_CC_SPI_USCIB0_UCLK    BIT3

void SPI0_Init(void)
{
 //MSP430 SPI초기화
 UCB0CTL1 |= UCSWRST;                      // **Disable USCI state machine**
 UCB0CTL0 |= UCMST+UCCKPH+UCMSB+UCSYNC;    // 3-pin, 8-bit SPI master
 UCB0CTL1 |= UCSSEL_2;                     // SMCLK
 UCB0BR0 = 0x02;                           // UCLK/2
 UCB0BR1 = 0;

 //SPI Port Init 
 TI_CC_SPI_USCIB0_PxSEL |= TI_CC_SPI_USCIB0_SIMO
         | TI_CC_SPI_USCIB0_SOMI
         | TI_CC_SPI_USCIB0_UCLK;
 // SPI option select
 TI_CC_SPI_USCIB0_PxDIR |= TI_CC_SPI_USCIB0_SIMO | TI_CC_SPI_USCIB0_UCLK;

  // Initialize USART state machine
 UCB0CTL1 &= ~UCSWRST;
}

unsigned char SPI0_WriteReadByte(unsigned char Data)
{
 SPI0_WAIT_FOR_EN();
 SPI0_WRITE_BYTE(Data);
 SPI0_WAIT_FOR_SEND();

 return SPI0_READ_BYTE();
}


SPI MODE설정시 주의 사항




SPI 가속도 센서를 테스트 하기위해 [NET-EVM] 보드를 이용하였는데 SPI CS는 CN7의 P8번에 연결되어 있고 이는 MSP430보드의 P3.7에 할당되어 있다. 드라이버 파일(config.h)에 아래와 같이 설정할 수 있다.
//AccelCS A8-P3.7
#define ACCEL_CS_BIT     BIT7
#define ACCEL_CS_PORT     P3OUT

#define ACCEL_CS_INIT()     Sbi(P3DIR, ACCEL_CS_BIT);


[MSP430F2274 EVM]보드를 이용한 SPI테스트 예제 - 가속도 센서 테스트
//-----------------------------------------------------------------------------
int main(void)
{
 int flag = 0;
 short data = 0;
 
    //System Init
 SystemInit();
 
    //LED Init
 Led1Init();
 Led1On();
 
 //Serial Init
 DebugInit(BAUD_115200);
 DebugPrint("MSP430F2274 SPI Test Program.\r\n");
 
//SPI및 가속도 센서초기화
 myAccel3lvInit();
 
 while (1)
 {
  if(u0_IsReceiveData())
  {
   switch(U0_GetByte())
   {
    case 'i':
     myAccel3lvWrite(CTRL_REG1, 0xC7);  //1000.0111 Power on, enable all axis, self test off
     DebugPrint("Accel Init\r\n");
     break;   
  
    case 'r':
     data = myAccel3lvRead(WHO_AM_I);
  
     DebugPrint("Who am I? 0x%x\r\n", data);  
     break; 
     
    case 'x':
     GetAccelValue(AXIS_X, &data);
  
     DebugPrint("%d\r\n", data);  
     break;    
   }
  }  
 }
}



Posted by nexp

댓글을 달아 주세요

[MSP430]/MSP430F22xx2009. 8. 14. 23:35

MSP430F2274 UART 테스트

MSP430F2274 UART 테스트
MSP430F2x의 레지스터명이 많이 바꼈다. 그대로 동작을 하지 않아 새로 작성하면서 정리해 보았다.



TI에서 제공하는 예제는 인터럽트 방식 밖에 없어서 폴링방식을 추가 해보았다.
 
데이터 전송
PutByte() 함수는 데이터 보내기전 UCAxSTAT레지스터의 BUSY비트를 체크하면 된다.
 
UCBUSY Bit 0 USCI busy. This bit indicates if a transmit or receive operation is in
progress.
0 USCI inactive
1 USCI transmitting or receiving
 
 
데이터 수신
GetByte()함수는 데이터를 받았는지 확인하기 위해 UC1IFG 레지스터의 UCA0RXIFG 를 확인하면 된다.
#define u0_WaitForReceive()     while((UC0IFG&UCA0RXIFG) == 0)
#define u0_RxData()        (UCA0RXBUF)

unsigned char U0_GetByte(void)
{
 u0_WaitForReceive();
 return u0_RxData();
}


 while (1)
 {
  if(u0_IsReceiveData())
  {
   switch(U0_GetByte())
   {
    case '0':
     Led1Off();
     DebugPrint("LED OFF\r\n");
     break;
  
    case '1':
     Led1On();
  
     DebugPrint("LED ON\r\n");   
     break;
     
    case 't':
     flag ^= 1;
     DebugPrint("flag=%d\r\n", flag);
     break;   
   }
  } 
Posted by nexp

댓글을 달아 주세요

[MSP430]/MSP430F20132009. 3. 6. 18:27

MSP430 I2C 테스트 - USCI(H/W SM) vs USI (MSP430F2013 S/W SM I2C)

Universal Serial Interface
MSP430F2013은 USI모듈로 SPI, I2C인터페이스를 제공한다. I2C는 USCI를 지원하는 상위 MSP430과 같은 풀 하드웨어로 동작하는것은 아니고 소프트웨어 State Machine를 구현해야 한다. 이때문에 약간 귀찮은 작업을 해 주어야 한다. 물론 속도도 느려지지만 그나마 소형 모듈에서 쉽게 구현할 수 있다는 장점이 있다.



소프트웨어 SM 구조


Slave 구현
1)Master에서 Start + (7bit+1bit)Address를 전송하고  NACK를 기다린다.
2)Slave에서 Address가 맞으면 NACK를 전송한다.
3)Slave에서 Data 전송한다.
4)Master에서 Data수신후 NACK를 송신
5)Slave에서 NACK수신
6)Slave에서 STOP수신(옵션)



MSP430F2013 I2C Slave SM소스코드
//******************************************************
// USI interrupt service routine
//******************************************************
#pragma vector = USI_VECTOR
__interrupt void USI_TXRX (void)
{
  if (USICTL1 & USISTTIFG)             // Start entry?
  {
    I2C_State = 2;                     // Enter 1st state on start
  }

  switch(I2C_State)
    {
      case 0: //Idle, should not get here
              break;

      case 2: //RX Address
              USICNT = (USICNT & 0xE0) + 0x08; // Bit counter = 8, RX Address
              USICTL1 &= ~USISTTIFG;   // Clear start flag
              I2C_State = 4;           // Go to next state: check address
              break;

      case 4: // Process Address and send (N)Ack
              if (USISRL & 0x01)       // If read...
                SLV_Addr++;            // Save R/W bit
              USICTL0 |= USIOE;        // SDA = output
              if (USISRL == SLV_Addr)  // Address match?
              {
                USISRL = 0x00;         // Send Ack
                I2C_State = 8;         // Go to next state: TX data
              }
              else
              {
                USISRL = 0xFF;         // Send NAck
                P1OUT |= 0x01;         // LED on: error
                I2C_State = 6;         // Go to next state: prep for next Start
              }
              USICNT |= 0x01;          // Bit counter = 1, send (N)Ack bit
              break;

      case 6: // Prep for Start condition
              USICTL0 &= ~USIOE;       // SDA = input
              SLV_Addr = 0x90;         // Reset slave address
              I2C_State = 0;           // Reset state machine
              break;

      case 8: // Send Data byte
              USICTL0 |= USIOE;        // SDA = output
              USISRL = SLV_Data;       // Send data byte
              USICNT |=  0x08;         // Bit counter = 8, TX data
              I2C_State = 10;          // Go to next state: receive (N)Ack
              break;

      case 10:// Receive Data (N)Ack
              USICTL0 &= ~USIOE;       // SDA = input
              USICNT |= 0x01;          // Bit counter = 1, receive (N)Ack
              I2C_State = 12;          // Go to next state: check (N)Ack
              break;

      case 12:// Process Data Ack/NAck
              if (USISRL & 0x01)       // If Nack received...
              {
              }
              else                     // Ack received
              {
                SLV_Data++;            // Increment Slave data
              }
              // Prep for Start condition
              USICTL0 &= ~USIOE;       // SDA = input
              SLV_Addr = 0x90;         // Reset slave address
              I2C_State = 0;           // Reset state machine
              break;
    }

  USICTL1 &= ~USIIFG;                  // Clear pending flags
}



참고로 USCI를 제공하는 MSP430F16x의 I2C구조이다. 외쪽 중앙에 하드웨어 I2C SM모듈이 들어가 있다.



실제 코드를 보면 I2C를 상당히 간단하게 제어할 수 있다.
// Common ISR for I2C Module
#pragma vector=USART0TX_VECTOR
__interrupt void I2C_ISR(void)
{
 switch(I2CIV)
 {
   case  0: break;                          // No interrupt
   case  2: break;                          // Arbitration lost
   case  4: break;                          // No Acknowledge
   case  6: break;                          // Own Address
   case  8: break;                          // Register Access Ready
   case 10:                                 // Receive Ready
     RXData = I2CDRB;                       // RX data
     _BIC_SR_IRQ(CPUOFF);                   // Clear LPM0
     break;
   case 12: break;                          // Transmit Ready
   case 14: break;                          // General Call
   case 16: break;                          // Start Condition
 }
}
Posted by nexp

댓글을 달아 주세요