MSP432 EVM - SPI테스트

[MSP430]/MSP432 | 2016.05.16 14:38
Posted by nexp

MSP432 EVM - SPI테스트



[MSP432 EVM] 보드의 SPI 포트는 UCB1 P6.2, P6.3, P6.4, P6.5에 할당되어 있다. SPI로 핀을 할당하기 위해 코드에서 아래와 같이 설정해 주면 된다.




void PinMuxConfig(void)

{

    //

    // Configure P6.3 for EUSCI_B1_SPI_I2C EUSCI_B1_SPI_I2C.CLK

    //

    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6, GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);

    //

    // Configure P6.4 for EUSCI_B1_SPI_I2C EUSCI_B1_SPI_I2C.SIMO

    //

    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6, GPIO_PIN4, GPIO_PRIMARY_MODULE_FUNCTION);

    //

    // Configure P6.5 for EUSCI_B1_SPI_I2C EUSCI_B1_SPI_I2C.SOMI

    //

    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6, GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION);

    //

    // Configure P6.2 for EUSCI_B1_SPI_I2C EUSCI_B1_SPI_I2C.STE

    //

    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6, GPIO_PIN2, GPIO_PRIMARY_MODULE_FUNCTION);

}





MSP432 SPI 초기화 함수

/* SPI Master Configuration Parameter */

const eUSCI_SPI_MasterConfig spiMasterConfig =

{

        EUSCI_B_SPI_CLOCKSOURCE_SMCLK,             // SMCLK Clock Source

        3000000,                                   // SMCLK = DCO = 3MHZ

        500000,                                    // SPICLK = 500khz

        EUSCI_B_SPI_MSB_FIRST,                     // MSB First

        EUSCI_B_SPI_PHASE_DATA_CHANGED_ONFIRST_CAPTURED_ON_NEXT,    // Phase

        EUSCI_B_SPI_CLOCKPOLARITY_INACTIVITY_HIGH, // High polarity

        EUSCI_B_SPI_3PIN                           // 3Wire SPI Mode

};



void SPI0_Init(void)

{

    /* Selecting  SPI mode */

    PinMuxConfig();


    /* Configuring SPI in 3wire master mode */

    SPI_initMaster(EUSCI_B0_BASE, &spiMasterConfig);


    /* Enable SPI module */

    SPI_enableModule(EUSCI_B0_BASE);


    /* Enabling interrupts */

    SPI_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_SPI_RECEIVE_INTERRUPT);

    Interrupt_enableInterrupt(INT_EUSCIB0);

    Interrupt_enableSleepOnIsrExit();

    TXData = 0x01;

}





MSP432 SPI 송수신 함수

unsigned char SPI0_WriteReadByte(unsigned char Data)

{

        while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT)));


        RXData = SPI_receiveData(EUSCI_B0_BASE);


        /* Send the next data packet */

        SPI_transmitData(EUSCI_B0_BASE, Data);

}





TM4C123 - SPI 테스트 (3축 가속도 센서)




TM4C123 의 SPI 기능을 테스트 해 보았다.

최대 SPI클럭이 25 MHz까지 동작 가능하고 FIFO를 내장하고 있다. 특이사항으로 4채널의 SPI블럭을 사용할 수 있어서 SPI블록이 많이 필요한 어플리케이션에 좋을것 같다. 


TM4C123 EVM 보드에서는 PA2, PA3, PA4, PA5 에 SPI를 할당해 두었다.



TM4C123 의 SPI블록도



TM4C123 의 SPI 핀맵

TM4C 는 최대 4채널의 SPI모듈을 제공한다. 

핀맵을 아래와같이 설정 가능하다.





TM4C123 의 SPI 초기화 함수

TI의 기존 Cortex-M3 코어와 코드를 호환하도록 제작되어 있기 때문에 코드 변경없이 그대로 사용가능하다. 물론 초기화 코드는 약간의 수정이 필요하다.

// SPI 통신 초기화 함수

void SPI0_Init(void) 

{

    // The SSI0 peripheral must be enabled for use.

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);


// Configure the pin muxing for SSI0 functions on port A2, A3, A4, and A5.

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    

    ROM_GPIOPinConfigure(GPIO_PA2_SSI0CLK);

    //ROM_GPIOPinConfigure(GPIO_PA3_SSI0FSS);

    ROM_GPIOPinConfigure(GPIO_PA4_SSI0RX);

    ROM_GPIOPinConfigure(GPIO_PA5_SSI0TX);

    

    ROM_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_2);


    ROM_SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), _ssi0_mode,

                       SSI_MODE_MASTER, _ssi0_baud, 8);


    // Enable the SSI0 module.

    ROM_SSIEnable(SSI0_BASE);    

}




TM4C123 의 SPI 송수신 함수

UINT SPI0_WriteReadByte(UINT Data)

{

unsigned long rx_data;

ROM_SSIDataPut(SSI0_BASE, Data);

ROM_SSIDataGet(SSI0_BASE, &rx_data);

return rx_data;    

}



Sellaless SPI 테스트 예제 를 참고 하면 되는데 속도를 필요로 한다면 아무래도 레지스터를 직접 제어 하는것이 좋을것 같다.


UINT SPI0_WriteReadByte(UINT Data)

{

    // Wait until there is space.

    while(!(HWREG(SSI0_BASE + SSI_O_SR) & SSI_SR_TNF))

    {

    }


    // Write the data to the SSI.

    HWREG(SSI0_BASE + SSI_O_DR) = Data;

    while(!(HWREG(SSI0_BASE + SSI_O_SR) & SSI_SR_RNE))

    {

    }


    // Read data from SSI.

    return (HWREG(SSI0_BASE + SSI_O_DR));

}







TM4C123 EVM - 3축 가속도 센서 드라이버 코드





//-----------------------------------------------------------------------------

// myAccel3LV02 HAL

#define MY_ACCEL3LV02_SPI_MODE 1

#define MY_ACCEL3LV02_I2C_MODE 0


#define ACCEL_CS_BIT BIT4

#define ACCEL_CS_PORT PORTB


#define ACCEL_CS_INIT() ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);\

                                        ROM_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, ACCEL_CS_BIT);

#define ACCEL_CS_ASSERT() PB4 = 0

#define ACCEL_CS_DEASSERT() PB4 = ACCEL_CS_BIT;


#define ACCEL_SPI_INIT()         SPI0_Init()

#define ACCEL_Read SPI0_WriteReadByte

#define ACCEL_Write SPI0_WriteReadByte

//-----------------------------------------------------------------------------




TM4C123 EVM - 3축 가속도 센서 예제 코드

int main(void)

{

    short data;

    

    SystemInit();

    Led1Init();

    Led1On();

    

    Led2Init();

    Led2On();

    

    DebugInit(BAUD_115200);

    DebugPrint("TM4C Uart Test\r\n");


myAccel3lvInit();

myAccel3lvWrite(CTRL_REG1, 0xC7); //1000.0111 Power on, enable all axis, self test off


    DebugPrint("WHO_AM_I: %x\r\n", myAccel3lvRead(WHO_AM_I));    


    while(1)

    {

if(DebugIsByte())

{

switch(U0_GetByte())

{

case '0':

Led1Off();

DebugPrint("LED OFF\r\n");

break;

case '1':

Led1On();

DebugPrint("LED ON\r\n");

break;

case 't':

DebugPrint("WHO_AM_I: %x\r\n", myAccel3lvRead(WHO_AM_I));

break;

case 'r':

GetAccelValue(AXIS_X, &data);

DebugPrint("%d\r\n", data);

break;

}

}       

    }


}


M052LBN EVM - SPI 테스트

Cortex-M/NUVOTON | 2014.07.09 12:52
Posted by nexp

M052LBN EVM - SPI 테스트




M052LBN는 저렴한 MCU임에도 2채널의 SPI를 제공한다. FIFO있고 SPI속도도 빠르다.




M052LBN SPI 블록도



M052LBN SPI 초기화 함수

void SPI0_Init(void)

{

SYS_UnlockReg();    

     CLK_EnableModuleClock(SPI0_MODULE);

         

    /* Set multi function pin for SPI1 */

    //SYS->P0_MFP = SYS_MFP_P04_SPISS1 | SYS_MFP_P05_MOSI_1 | SYS_MFP_P06_MISO_1 | SYS_MFP_P07_SPICLK1;

     SYS->P1_MFP = SYS_MFP_P15_MOSI_0 | SYS_MFP_P16_MISO_0 | SYS_MFP_P17_SPICLK0;

    

    

        /* Select HXT as the clock source of SPI1 */

    CLK_SetModuleClock(SPI0_MODULE, CLK_CLKSEL1_SPI0_S_HCLK, MODULE_NoMsk);


    /* Enable SPI1 peripheral clock */

    CLK_EnableModuleClock(SPI0_MODULE);

    

    /* Lock protected registers */

    SYS_LockReg();

    

    

    /* Configure SPI1 as a master, MSB first, 8-bit transaction, SPI Mode-0 timing, clock is 6MHz */

    SPI_Open(SPI0, SPI_MASTER, SPI_MODE_0, 8, 6000000);


    /* Enable the automatic hardware slave select function. Select the SS0 pin and configure as low-active. */

    SPI_EnableAutoSS(SPI0, SPI_SS, SPI_SS_ACTIVE_LOW);

}




SPI_CNTRL 레지스터





M052LBN SPI 송수신 함수

unsigned char SPI0_WriteReadByte(unsigned char Data)

{

    SPI_WRITE_TX0(SPI0, Data);

    /* Trigger SPI transfer */

    SPI_TRIGGER(SPI0);


    /* Check busy state */

    while(SPI_IS_BUSY(SPI0));


   return SPI_READ_RX0(SPI0);

}


LM3S101 SPI 테스트

[TI]/LM3S1xx | 2014.06.06 21:27
Posted by nexp

LM3S101 SPI 테스트



LM3S101 SPI 초기화 함수

//----------------------------------------------------------------

// SPI 통신 초기화 함수

void SPI0_Init(void) 

{

SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);

GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_4 | GPIO_PIN_5);

GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_4 | GPIO_PIN_5,

GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);

 

SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,

  SSI_MODE_MASTER, 1000000, 8);

SSIEnable(SSI0_BASE);

SPI0_SetSpeed(SPI_SPEED_1MHZ);

}

//----------------------------------------------------------------




LM3S101 SPI 송수신 함수

SUINT SPI0_WriteReadByte(SUINT Data)

{

    // Wait until there is space.

    while(!(HWREG(SSI0_BASE + SSI_O_SR) & SSI_SR_TNF))

    {

    }


    // Write the data to the SSI.

    HWREG(SSI0_BASE + SSI_O_DR) = Data;

    while(!(HWREG(SSI0_BASE + SSI_O_SR) & SSI_SR_RNE))

    {

    }


    // Read data from SSI.

    return (HWREG(SSI0_BASE + SSI_O_DR));

}


STM8S - SPI 테스트

[ST_MICRO]/STM8 | 2014.05.04 19:30
Posted by nexp

STM8S - SPI 테스트



STM8S의 SPI는 최대 클럭 스피드 10Mhz로 동작한다. 동급의 8bit MCU인 AVR과 비교하면 조금더 성능이 좋아 보인다.

S-Type EVM 보드를 이용하여 SPI인터페이스의 가속도센서를 테스트 해 보았다.



STM8S SPI블록도

8bit MCU의 전형적이 SPI구조 이고 AVR과 비교 했을때 큰 차이가 없어 보인다.





STM8S SPI초기화 함수

void SPI0_Init(void)

{

SPI_DeInit();

SPI_Init(SPI_FIRSTBIT_MSB, 

            SPI_BAUDRATEPRESCALER_32, 

            SPI_MODE_MASTER, 

            SPI_CLOCKPOLARITY_LOW, 

            SPI_CLOCKPHASE_2EDGE, 

            SPI_DATADIRECTION_2LINES_FULLDUPLEX, 

            SPI_NSS_HARD, 0x00);

SPI_Cmd(ENABLE);

}



STM8S SPI송수신 함수

레지스터의 SPI_FLAG_TXE 비트를 검사해서 1이면 SPI버퍼가 비어 있으므로 데이터를 쓰고, SPI_FLAG_RXNE비트가 1이되면 읽을 준비가 되었으므로 수신한 값을 리턴하면 된다.

unsigned char SPI0_WriteReadByte(unsigned char Data)

{

while (SPI_GetFlagStatus(SPI_FLAG_TXE) == RESET);

SPI->DR = Data;


while(SPI_GetFlagStatus(SPI_FLAG_RXNE) == RESET);


return SPI->DR;

}




LPC812 EVM - SPI 테스트

[NXP]/LPC800 | 2014.03.09 22:30
Posted by nexp

LPC812 EVM - SPI 테스트

LPC812는 2개의 SPI를 내장하고 있다. 저가격 소형 칩이라도 기능은 막강하다. 특히 SWITCH MATRIX 방식으로 SPI 핀맵을 원하는 형태로 할당 할 수 있기 때문에 상상히 유연성이 좋은것 같다.

SPI의 최대 클럭 속도는 메인클럭인 30Mhz까지 출력 가능하다. 


LPC812 SPI 블록도





LPC812 EVM 에서 SPI 핀맵할당

LPC812 EVM에서 SPI핀맵은 아래와같이 할당 했고 Switch Matrix Tool을 이용하여 코드 생성을 쉽게 할 수 있다.





LPC812 SPI 초기화 함수

void SPI0_Init(void)

{

    /* Enable SWM clock */

    LPC_SYSCON->SYSAHBCLKCTRL |= (1<<7);


    /* Pin Assign 8 bit Configuration */

    /* SPI0_SCK */

    LPC_SWM->PINASSIGN3 = 0x07ffffffUL; 

    /* SPI0_MOSI */

    /* SPI0_MISO */

    LPC_SWM->PINASSIGN4 = 0xffff0203UL; 


    

    /* Enable SPI clock */

    LPC_SYSCON->SYSAHBCLKCTRL |= (1<<11);


    /* Bring SPI out of reset */

    LPC_SYSCON->PRESETCTRL &= ~(0x1<<0);

    LPC_SYSCON->PRESETCTRL |= (0x1<<0);


    /* Set clock speed and mode */

    LPC_SPI0->DIV = 15-1;

    LPC_SPI0->DLY = 0;

    LPC_SPI0->CFG = (SPI_CFG_MASTER & ~SPI_CFG_ENABLE);

    LPC_SPI0->CFG |= SPI_CFG_ENABLE;    

}




LPC812 SPI 송수신 함수

unsigned char SPI0_WriteReadByte(unsigned char Data)

{

while ( (LPC_SPI0->STAT & SPI_STAT_TXRDY) == 0 );


    LPC_SPI0->TXDATCTL = SPI_TXDATCTL_FSIZE(8-1) | SPI_TXDATCTL_EOT | Data;

    while ( (LPC_SPI0->STAT & SPI_STAT_RXRDY) == 0 );

    

    return LPC_SPI0->RXDAT;   

}





LPC812 모드 설정







void SPI0_SetMode(int Mode)

{

switch(Mode)

{

case _SPI_MODE0:

            Cbi(LPC_SPI0->CFG, SPI_CFG_CPOL);

            Cbi(LPC_SPI0->CFG, SPI_CFG_CHPA);

break;

            

case _SPI_MODE1:

            Cbi(LPC_SPI0->CFG, SPI_CFG_CPOL);

            Sbi(LPC_SPI0->CFG, SPI_CFG_CHPA);

break;


case _SPI_MODE2:

            Sbi(LPC_SPI0->CFG, SPI_CFG_CPOL);

            Cbi(LPC_SPI0->CFG, SPI_CFG_CHPA);

break;


case _SPI_MODE3:

            Sbi(LPC_SPI0->CFG, SPI_CFG_CPOL);

            Sbi(LPC_SPI0->CFG, SPI_CFG_CHPA);

break;            

}

}




[XMC1300 EVM] - SPI 테스트 (Infineon Cortex-M0)


XMC 시리즈는 시리얼 통신( UART, SPI, I2S, I2C )을 동일한 블록으로 만들어 두고 모드로 선택해서 사용할수 있도록 되어 있다.

장단점이 있을것 같은데... 

장점으로 동일한 셋팅으로 사하기 때문에 소프트웨어 부담이 줄어든다. 반면 2채널 밖에 없기 때문에 여러 통신을 동시에 사용할때 어려움이 있다.



XMC1300 SPI 블록도




XMC1300 SPI 핀맵

XMC의 핀기능은 하나의 포트에 여러가지 기능을 사가능하도록 해 두었는데, 다만 기능들이 일관성이 없어 데이터시트 상에 핀의 기능을 확인할 때 주의가 필요한것 같다.


SPI 기능핀은 여러핀 리맵가능한것 처럼 되어 있지만 사실 상당히 제한적으로 설정 가능하다. 데이터시트를 자세히 보고 할당해야 한다. XMC1300 EVM 보드에서는 아래와 같이 할당 했다.

P1.0(MOSI) - USIC0_CH0.DOUT0(ALT7)


P1.1(MISO) - USIC0_CH0.DX0D


P0.8(SCLK) - USIC0_CH0.SCLKOUT(ALT6)


P1.4(SS) - USIC0_CH0.SELO0(ALT6)



SPI MISO 기능으로 사용할 수 있는 핀




XMC1300 SPI 관련 레지스터

CCR (Channel Control Register)

MODE [3:0] rw Operating Mode


0H - USIC channel is disabled

1H - SSC (SPI) 모드로 동작

2H - ASC (SCI, UART) 모드로 동작

3H - I2S 모드로 동작

4H - I2C 모드로 동작



XMC1300 SPI 초기화 함수

void SPI0_Init(void)

{

    PORT1_Set_Mode(1,INPUT_PU);

    PORT1_Set_Mode(0,OUTPUT_PP_AF7);

    PORT0_Set_Mode(8,OUTPUT_PP_AF6);

  

//Kernel State Configuration Register - Module Enable + Bit Protection for MODEN

USIC0_CH0->KSCFG |= (1 << USIC_CH_KSCFG_MODEN_Pos) | (1 << USIC_CH_KSCFG_BPMODEN_Pos);


//Normal divider mode selected

WR_REG(USIC0_CH0->FDR, USIC_CH_FDR_DM_Msk, USIC_CH_FDR_DM_Pos, 1);

//Configuration of baud rate

WR_REG(USIC0_CH0->FDR, USIC_CH_FDR_STEP_Msk, USIC_CH_FDR_STEP_Pos, FDR_STEP);

WR_REG(USIC0_CH0->BRG, USIC_CH_BRG_PDIV_Msk, USIC_CH_BRG_PDIV_Pos, BRG_PDIV);

    

    WR_REG(USIC0_CH0->BRG, USIC_CH_BRG_SCLKOSEL_Msk, USIC_CH_BRG_SCLKOSEL_Pos, 0);    

    WR_REG(USIC0_CH0->BRG, USIC_CH_BRG_SCLKCFG_Msk, USIC_CH_BRG_SCLKCFG_Pos, 1);


//Configuration of USIC Input Stage

        //Select P1.2

WR_REG(USIC0_CH0->DX0CR, USIC_CH_DX0CR_DSEL_Msk, USIC_CH_DX0CR_DSEL_Pos, 3);

WR_REG(USIC0_CH0->DX0CR, USIC_CH_DX0CR_INSW_Msk, USIC_CH_DX0CR_INSW_Pos, 1);


//Configuration of USIC Shift Control

//Transmit/Receive MSB first is selected, Transmission Mode (TRM) = 1, Passive Data Level (PDL) = 1

WR_REG(USIC0_CH0->SCTR, USIC_CH_SCTR_PDL_Msk, USIC_CH_SCTR_PDL_Pos, 1);

WR_REG(USIC0_CH0->SCTR, USIC_CH_SCTR_TRM_Msk, USIC_CH_SCTR_TRM_Pos, 1);

WR_REG(USIC0_CH0->SCTR, USIC_CH_SCTR_SDIR_Msk, USIC_CH_SCTR_SDIR_Pos, 1);

//Set Word Length (WLE) & Frame Length (FLE)

WR_REG(USIC0_CH0->SCTR, USIC_CH_SCTR_FLE_Msk, USIC_CH_SCTR_FLE_Pos, 7);

WR_REG(USIC0_CH0->SCTR, USIC_CH_SCTR_WLE_Msk, USIC_CH_SCTR_WLE_Pos, 7);


//Configuration of USIC Transmit Control/Status Register

//TBUF Data Enable (TDEN) = 1, TBUF Data Single Shot Mode (TDSSM) = 1

WR_REG(USIC0_CH0->TCSR, USIC_CH_TCSR_TDEN_Msk, USIC_CH_TCSR_TDEN_Pos, 1);

WR_REG(USIC0_CH0->TCSR, USIC_CH_TCSR_TDSSM_Msk, USIC_CH_TCSR_TDSSM_Pos, 1);


//Configuration of Protocol Control Register

WR_REG(USIC0_CH0->PCR_SSCMode, USIC_CH_PCR_SSCMode_MSLSEN_Msk,                                USIC_CH_PCR_SSCMode_MSLSEN_Pos, 1);


//Configuration of Channel Control Register

WR_REG(USIC0_CH0->CCR, USIC_CH_CCR_MODE_Msk, USIC_CH_CCR_MODE_Pos, 1);

WR_REG(USIC0_CH0->CCR, USIC_CH_CCR_AIEN_Msk, USIC_CH_CCR_AIEN_Pos, 0);


//Data Pointer & Buffer Size for Transmitter Buffer Control - DPTR = 0,  SIZE = 5

WR_REG(USIC0_CH0->TBCTR, USIC_CH_TBCTR_DPTRSIZE_Msk, USIC_CH_TBCTR_DPTRSIZE_Pos, 0x05000000);

//Data Pointer & Buffer Size for Receiver Buffer Control - DPTR = 32,  SIZE = 5

WR_REG(USIC0_CH0->RBCTR, USIC_CH_RBCTR_DPTRSIZE_Msk, USIC_CH_RBCTR_DPTRSIZE_Pos, 0x05000020);

}



XMC1300 SPI Read/Write 함수

unsigned char SPI0_WriteReadByte(unsigned char Data)

{

    //while(!(USIC0_CH0->TRBSR&BIT11));

    USIC0_CH0->IN[0] = Data;

    

    while(USIC0_CH0->TRBSR&BIT3);

    return USIC0_CH0->OUTR;  

}



K20 EVM - SPI 테스트 3축 가속도 센서값을 TFT LCD 그래프로 표시하기



SPI 를 쉽고 재미 있게 테스트하기 위해 가속도 센서를 활용할 수 있다. LIS3LV02 3축 가속도 센서를 SPI모드로 설정하고 확장 EVM보드에 연결하여 테스트 할 수 있다. 

SPI 방식으로 센서를 설정하거나 3축 가속도 센서값을 읽을 수 있다.



K20 SPI모드 가속도 센서 테스트 동영상




K20 가속도 센서 테스트 드라이버 코드
//-----------------------------------------------------------------------------
// myAccel3LV02 HAL
#define MY_ACCEL3LV02_SPI_MODE 1
#define MY_ACCEL3LV02_I2C_MODE 0

#define ACCEL_CS_BIT BIT2
#define ACCEL_CS_PORT GPIOC

#define ACCEL_CS_INIT() SIM_SCGC5 |= SIM_SCGC5_PORTC_MASK;\
PORTC_PCR2 = PORT_PCR_MUX(1);\
Sbi(GPIOC_PDDR, ACCEL_CS_BIT); 

#define ACCEL_CS_ASSERT() cbi(ACCEL_CS_PORT, ACCEL_CS_BIT)
#define ACCEL_CS_DEASSERT() sbi(ACCEL_CS_PORT, ACCEL_CS_BIT)
#define ACCEL_SPI_INIT() SPI0_Init()
#define ACCEL_Read SPI0_WriteReadByte
#define ACCEL_Write SPI0_WriteReadByte
//-----------------------------------------------------------------------------



MSP430FR5739 EVM - eUSCI SPI 통신 테스트

 

 

MSP430FR5739의 SPI역시 기존과 약간의 변화가 있는것 같다.

설계 할때 잘 해둘필요가 있는데... 아무튼 다시 한번 정리해 본다.

 

 

MSP430FR5739 SPI 블록도
 




MSP430FR5739 SPI 핀맵 설정

SEL 레지스터를 이용하여 SPI기능을 할당할 수 있다. 다른 MSP430시리즈와 달리 SEL0, SEL1으로 두개의 레지스터가 있다.

//USCIA1 for MSP430FR5739

#define _SPI1_PxSEL   P2SEL0

#define _SPI1_PxSEL1   P2SEL1

#define _SPI1_PxDIR   P2DIR

#define _SPI1_PxIN   P2IN


#define _SPI1_SIMO   BIT5

#define _SPI1_SOMI   BIT6

#define _SPI1_UCLK   BIT4



//SPI Port Init

Cbi(_SPI1_PxSEL, (_SPI1_UCLK|_SPI1_SOMI|_SPI1_SIMO));

Sbi(_SPI1_PxSEL1, (_SPI1_UCLK|_SPI1_SOMI|_SPI1_SIMO));


// SPI option select

Sbi(_SPI1_PxDIR, (_SPI1_UCLK|_SPI1_SOMI|_SPI1_SIMO));






MSP430FR5739 SPI 초기화 함수


void SPI1_Init(void) // SPI 통신 초기화 함수

{

    // Initialize USART state machine

UCB0CTL1 &= ~UCSWRST;

//SPI Port Init

Cbi(_SPI1_PxSEL, (_SPI1_UCLK|_SPI1_SOMI|_SPI1_SIMO));

Sbi(_SPI1_PxSEL1, (_SPI1_UCLK|_SPI1_SOMI|_SPI1_SIMO));


// SPI option select

Sbi(_SPI1_PxDIR, (_SPI1_UCLK|_SPI1_SOMI|_SPI1_SIMO));

UCA1CTLW0 |= UCSWRST;                     // **Put state machine in reset**

UCA1CTLW0 |= UCMST+UCSYNC+UCCKPL+UCMSB;   // 3-pin, 8-bit SPI master

// Clock polarity high, MSB

UCA1CTLW0 |= UCSSEL__SMCLK;                    // SMCLK


UCA1CTLW0 &= ~UCSWRST;                    // **Initialize USCI state machine**

//UCA1IE |= UCRXIE;                         // Enable USCI_A0 RX interrupt

}





MSP430FR5739 송수신 함수

#define SPI1_WRITE_BYTE(x)                 UCA1TXBUF = (x);

#define SPI1_READ_BYTE() UCA1RXBUF

#define SPI1_WAIT_FOR_SEND()             while (!(UCA1IFG&UCTXIFG))

#define SPI1_WAIT_FOR_RX() while (!(UCA1IFG&UCRXIFG))



unsigned char SPI1_WriteReadByte(unsigned char Data)

{

//SPI TXBUF 데이터 있는가 확인

SPI1_WAIT_FOR_SEND();

//데이터 전송

SPI1_WRITE_BYTE(Data);


//SPI 데이터가 수신되면

SPI1_WAIT_FOR_RX();

return SPI0_READ_BYTE();

}






인터럽트로 처리할 경우

extern RINGBUFFER gUartBuffer;


#pragma vector=USCI_A0_VECTOR

__interrupt void USCI_A0_ISR(void)

{    

    switch(__even_in_range(UCA0IV,0x08))

    {

      case 0: break; // Vector 0 - no interrupt

      case 2:  // Vector 2 - RXIFG


SetRingBuffer(&gUartBuffer, UCA0RXBUF);

        break;

      default:

        break;

    }

}



[adStar EVM] SPI 테스트

[MCU]/adStar | 2012.12.22 16:00
Posted by nexp

[adStar EVM] SPI 테스트

adStar는 2채널의 SPI가 있다. CANTUS에서는 HDSC와 핀이 겹쳐서 아쉬울 때가 있었는데... 2채널이 되어 상당히 편해 졌다.

핀맵은 아래와 같다.

 

P0.0/SPWM2L_P/SPI0_nCS/TWI_SCL
P0.1/SPWM2L_N/SPI0_MISO/TWI_SDA
P0.2/SPWM2R_P/SPI0_MOSI/nCS1
P0.3/SPWM2R_N/SPI0_SCK/nCS2

 

P5.1/IIS_LRCLK0/SPI_MOSI1/A1

P5.0/IIS_SCLK0/SPI_MISO1/A0

P4.7/IIS_SDI0/SPI_CS1/TMO3

P4.6/IIS_MCLK/SPI_SCK1/CAP3

 

 

CANTUS와 코어는 동일하지만 2개의 SPI가 존재 하므로 기존 코드어세 약간의 수정이 필요하다.

 

adStar SPI초기화 함수

void SPI1_Init(void) // SPI 통신 초기화 함수
{
  Cbi(*R_PAF5, 0x0F); // SPI_SCK, SPI_MISO, SPI_MOSI
 Cbi(*R_PAF4, 0xF000);

 Sbi(*R_PAF5, F_PAF5_0_SPI_MISO1 | F_PAF5_1_SPI_MOSI1); // SPI_SCK, SPI_MISO, SPI_MOSI
 Sbi(*R_PAF4, F_PAF4_7_SPI_CS1 | F_PAF4_6_SPI_SCK1);

 

 *R_SPI0CON(1) = SPICON_MSTR | SPICON_MSBF | SPICON_EN; 
 
    int baud = spi_set_freq(1, SPI_MASTER, W25Xxx_SPI_FREQ);
}

 

 

adStar SPI송수신 함수

unsigned char SPI1_WriteReadByte(unsigned char Data)
{
 //SPI포트로 데이터 출력 
 *R_SPI0DATA(1) = Data;
 
 // 전송대기
 while (!(*R_SPI0STAT(1) & SPISTAT_SPIF));
 
 //데이터 수신
 return *R_SPI0DATA(1);
}

 

 

기존 CANTUS로 작성된  3축 가속도 센서 구동시 잘 동작하는것을 확인할 수 있다.

 

TAG adstar, SPI

블로그 이미지

nexp

카테고리

분류 전체보기 (1560)
[MyProject] (48)
[TI] (75)
[NXP] (51)
[ST_MICRO] (129)
[FreeScale] (31)
[MSP430] (140)
[Microchip] (131)
Cortex-M (36)
[ATMEL] (29)
[AnalogDevice] (22)
[Embedded] (2)
ARM9 (24)
[AVR] (80)
[DSP] (111)
[8051] (21)
[MCU] (50)
[INTERFACE] (213)
[AppBoard] (23)
[ROBOT] (25)
[MODULE] (129)
[SENSOR] (41)
[DATA] (21)
[FPGA] (32)
[EVB] (1)
[Proramming] (38)
[MyLog] (6)
[IDEA] (0)
[Utility] (19)
[Book] (24)
취미생활 (4)
[Link] (2)