اطلاعیه

Collapse
No announcement yet.

SPi با LPC1768

Collapse
X
 
  • فیلتر
  • زمان
  • Show
Clear All
new posts

    SPi با LPC1768

    برای راه اندازی SPI1 درLPC1768 نیاز به یک مثال ساده دارم
    مشکل اینجاست که رجیسترهای SPDR و SPSR را چطور برای SPI1 استفاده کنم
    من به این ترتیب برنامه را شروع کرده ام :
    کد:
     LPC_SC->PCONP = (LPC_SC->PCONP & 0xEFEFF7DE) | (1UL<<10);  /* Enable peripheral clock for SSP1 (default is enabled) */
    
     LPC_SC->PCLKSEL0 &= ~(3<<20);
     LPC_SC->PCLKSEL0 |= (1<<20);
    
      LPC_SC->PCLKSEL0 |= (2<<12); // ssel1
      LPC_SC->PCLKSEL0 |= (2<<14); // sck1
      LPC_SC->PCLKSEL0 |= (2<<16); // miso11
      LPC_SC->PCLKSEL0 |= (2<<18); // mosi11
    
      //   LPC_SC->PCONP |= (1 << 10);	 //enable spi1
      LPC_SSP1->CR0 |= 3<<6; 	//clock phase
    	LPC_SSP1->CR0 |= 7<<0; 	// 8 bits
    	LPC_SSP1->CR1 |= 1<<1; 	//enable SSP
    
     // LPC_SSP1->CR0 = 0x0007;   /* binary: 00000000_00001111 */
      // LPC_SSP1->CR1 = 0x00;   /* binary: 00000000 */
      LPC_SSP1->CPSR = 0x22;   /* decimal 2 sck */
      LPC_SSP1->IMSC = 0x00;   /* binary: 00000000 intrupt*/
      LPC_SSP1->DMACR = 0x0000;   /* binary: 00000000_00000000 dma*/
    ولی برای SPDR که در SSP1 ,وجود ندارد و باید SPI->SPDR بنویسم . این چطور می فهمد که الان دیتای SPI0 یا SPI1 است ؟؟

    #2
    پاسخ : SPI1 با LPC1768

    اصولا فرق spi وssp چیه ؟ که ما 2 تا ssp داریم و همون پایه های miso, mosi , sck را رو داره ؟

    دیدگاه


      #3
      پاسخ : SPI1 با LPC1768

      دو تا مثال براتون پلود کردم کارتونو راه میندازه امیدوارم به کارتون بیاد
      http://uplod.ir/rdv5x4duubj6/SPI.rar.htm

      دیدگاه


        #4
        پاسخ : SPI1 با LPC1768

        مثالهای شما رو دانلود کردم
        اگه میشه قبلش در مورد ماهیت ssp و spi و تفاوت آندو برام توضیح بدبد .

        در مثال 2 شما
        کد:
        [left]LPC_SC->PCONP |= (1 << 8); /* Enable power to SSPI0 block */
        	
        LPC_GPIO0->FIODIR  |= (1<<16);      /* P0.16 is output       */
        LPC_PINCON->PINSEL0 |= (3UL<<30);      // select p0.15 -->  SCK 
        LPC_PINCON->PINSEL1 |= (3<<2) | (3<<4);  // select p0.17 , p0.18 --> MISO , MISI[/left]
        و لی در ادامه همون spi رو ادامه دادید و اگر مثلا بخواهیم ssp0 , spp1 و spi رو با هم استفاده کنیم چطوری میشه ؟

        دیدگاه


          #5
          پاسخ : SPI1 با LPC1768

          این مثال ها رو از برد آموزشی landtiger براتون فرستادم و خودم با این قسمتها کار نکردم و اطلاعاتی ندارم

          دیدگاه


            #6
            پاسخ : SPI1 با LPC1768

            این مثال ها رو از برد آموزشی landtiger براتون فرستادم و خودم با این قسمتها کار نکردم و اطلاعاتی ندارم
            به هر حال دست شما درد نکنه لطف کردید .
            من در مدار چاپیم اشتباها برای پایه های spi از پورت ssp1 استفاده کردم و الان برای ارتباط با بیرون مشکل دارم و نمی دونم اصلا این ssp1 چیه ؟ آیا همون spi هو از نظر نرم افزاری هم نمی تونم راش بندازم .
            اگه کسی می تونه کمکم کنه
            یا اینکه باید مدار چاپی را اصلاح کنم !!!

            دیدگاه


              #7
              پاسخ : SPI1 با LPC1768

              خواهش
              فک کنم باید برد رو اصلاح کنی چون فک کنم SPI با SSP فرق داره و کلا پایه هاش متفاوته

              دیدگاه


                #8
                پاسخ : SPI1 با LPC1768

                من اومدم پایه ها رو فعلا از روی pcb مونتاژ شده با بدبختی عوض کردم .
                ولی الان توی خط while( !(LPC_SPI->SPSR & 0x80));//wait for transfer to be completed
                می مونه و موقع نوشتن دیتا همون جا می مونه تا واچ داگ بشه

                علت چی می تونه باشه

                دیدگاه


                  #9
                  پاسخ : SPI1 با LPC1768

                  اشکال رو پیدا کردم :
                  پایه cs رو دستی درست کنترل نمی کردم که اصلاح شد و الان ظاهرا این مرحله رد شده
                  ولی در موقع خوندن هر چی می خونم ff خومده می شه آیا مثل نوشتن در موقع خوندن هم باید flag ی رو چک کرد ؟

                  دیدگاه


                    #10
                    پاسخ : SPI1 با LPC1768

                    سلام
                    ssp مخفف Synchronous Serial Port هست که در سه مد spi و ssi و microwire میتونه کار کنه.

                    تا حالا باهاش کار نکردم ولی برای راحتی کار میتونید از ARMWizard برای تنظیم رجیستر ها استفاده کنید.

                    این هم یه مثال که از ssp0 استفاده کرده البته با cmsis
                    امیدوارم مفید باشه
                    کد:
                    /**********************************************************************
                    * $Id$		ssp_master.c					2010-05-21
                    *//**
                    * @file		ssp_master.c
                    * @brief	This example describes how to use SPP in master mode
                    * @version	2.0
                    * @date		21. May. 2010
                    * @author	NXP MCU SW Application Team
                    *
                    * Copyright(C) 2010, NXP Semiconductor
                    * All rights reserved.
                    *
                    ***********************************************************************
                    * Software that is described herein is for illustrative purposes only
                    * which provides customers with programming information regarding the
                    * products. This software is supplied "AS IS" without any warranties.
                    * NXP Semiconductors assumes no responsibility or liability for the
                    * use of the software, conveys no license or title under any patent,
                    * copyright, or mask work right to the product. NXP Semiconductors
                    * reserves the right to make changes in the software without
                    * notification. NXP Semiconductors also make no representation or
                    * warranty that such application will be suitable for the specified
                    * use without further testing or modification.
                    **********************************************************************/
                    #include "lpc17xx_ssp.h"
                    #include "lpc17xx_libcfg.h"
                    #include "lpc17xx_pinsel.h"
                    #include "debug_frmwrk.h"
                    #include "lpc17xx_gpio.h"
                    
                    /* Example group ----------------------------------------------------------- */
                    /** @defgroup SSP_Master	Master
                     * @ingroup SSP_Examples
                     * @{
                     */
                    
                    /************************** PRIVATE DEFINTIONS ************************/
                    /** Max buffer length */
                    #define BUFFER_SIZE			0x40
                    
                    
                    /************************** PRIVATE VARIABLES *************************/
                    uint8_t menu1[] =
                    "********************************************************************************\n\r"
                    "Hello NXP Semiconductors \n\r"
                    "SSP demo \n\r"
                    "\t - MCU: LPC17xx \n\r"
                    "\t - Core: ARM Cortex-M3 \n\r"
                    "\t - Communicate via: UART0 - 115200bps \n\r"
                    "\t An example of SSP using polling mode to test the SSP driver \n\r"
                    " This example uses SSP in SPI mode as master to communicate with an SSP slave device \n\r"
                    " The master and slave transfer together a number of data byte \n\r"
                    "********************************************************************************\n\r";
                    uint8_t menu2[] = "Demo terminated! \n\r";
                    
                    // SSP Configuration structure variable
                    SSP_CFG_Type SSP_ConfigStruct;
                    
                    // Tx buffer
                    uint8_t Tx_Buf[BUFFER_SIZE];
                    
                    // Rx buffer
                    uint8_t Rx_Buf[BUFFER_SIZE];
                    
                    /************************** PRIVATE FUNCTIONS *************************/
                    void print_menu(void);
                    void Buffer_Init(void);
                    void Error_Loop(void);
                    void Buffer_Verify(void);
                    
                    /*-------------------------PRIVATE FUNCTIONS------------------------------*/
                    /*********************************************************************//**
                     * @brief		Initialize buffer
                     * @param[in]	None
                     * @return 		None
                     **********************************************************************/
                    void Buffer_Init(void)
                    {
                    	uint8_t i;
                    
                    	for (i = 0; i < BUFFER_SIZE; i++) {
                    		Tx_Buf[i] = i;
                    		Rx_Buf[i] = 0;
                    	}
                    }
                    
                    /*********************************************************************//**
                     * @brief		Error Loop (called by Buffer_Verify() if any error)
                     * @param[in]	none
                     * @return 		None
                     **********************************************************************/
                    void Error_Loop(void)
                    {
                    	/* Loop forever */
                    	while (1);
                    }
                    
                    
                    /*********************************************************************//**
                     * @brief		Verify buffer
                     * @param[in]	none
                     * @return 		None
                     **********************************************************************/
                    void Buffer_Verify(void)
                    {
                    	uint8_t i;
                    	uint8_t *src_addr = (uint8_t *) &Tx_Buf[0];
                    	uint8_t *dest_addr = (uint8_t *) &Rx_Buf[0];
                    
                    	for ( i = 0; i < BUFFER_SIZE; i++ )
                    	{
                    		if ( *src_addr++ != *dest_addr++ )
                    		{
                    			_DBG_("Verify error");
                    			/* Call Error Loop */
                    			Error_Loop();
                    		}
                    	}
                    }
                    
                    
                    /*********************************************************************//**
                     * @brief		Print Welcome menu
                     * @param[in]	none
                     * @return 		None
                     **********************************************************************/
                    void print_menu(void)
                    {
                    	_DBG(menu1);
                    }
                    
                    /*-------------------------MAIN FUNCTION------------------------------*/
                    /*********************************************************************//**
                     * @brief		c_entry: Main SSP program body
                     * @param[in]	None
                     * @return 		int
                     **********************************************************************/
                    int c_entry(void)
                    {
                    	PINSEL_CFG_Type PinCfg;
                    	SSP_DATA_SETUP_Type xferConfig;
                    
                    	/*
                    	 * Initialize SPI pin connect
                    	 * P0.15 - SCK;
                    	 * P0.16 - SSEL
                    	 * P0.17 - MISO
                    	 * P0.18 - MOSI
                    	 */
                    	PinCfg.Funcnum = 2;
                    	PinCfg.OpenDrain = 0;
                    	PinCfg.Pinmode = 0;
                    	PinCfg.Portnum = 0;
                    	PinCfg.Pinnum = 15;
                    	PINSEL_ConfigPin(&PinCfg);
                    	PinCfg.Pinnum = 17;
                    	PINSEL_ConfigPin(&PinCfg);
                    	PinCfg.Pinnum = 18;
                    	PINSEL_ConfigPin(&PinCfg);
                    	PinCfg.Pinnum = 16;
                    	PINSEL_ConfigPin(&PinCfg);
                    
                    	/* Initialize debug via UART0
                    	 * – 115200bps
                    	 * – 8 data bit
                    	 * – No parity
                    	 * – 1 stop bit
                    	 * – No flow control
                    	 */
                    	debug_frmwrk_init();
                    
                    	// print welcome screen
                    	print_menu();
                    
                    	// initialize SSP configuration structure to default
                    	SSP_ConfigStructInit(&SSP_ConfigStruct);
                    	// Initialize SSP peripheral with parameter given in structure above
                    	SSP_Init(LPC_SSP0, &SSP_ConfigStruct);
                    
                    	// Enable SSP peripheral
                    	SSP_Cmd(LPC_SSP0, ENABLE);
                    
                    	_DBG_("Press '1' to start transfer...");
                    	while (_DG != '1');
                    
                    	/* Initialize Buffer */
                    	_DBG_("Init buffer");
                    	Buffer_Init();
                    
                    	_DBG_("Start transfer...");
                    
                    	xferConfig.tx_data = Tx_Buf;
                    	xferConfig.rx_data = Rx_Buf;
                    	xferConfig.length = BUFFER_SIZE;
                    	SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING);
                    
                    	// Verify buffer after transferring
                    	Buffer_Verify();
                    	_DBG_("Verify complete!");
                    
                      /* Loop forever */
                      while(1);
                      return 1;
                    }
                    
                    /* With ARM and GHS toolsets, the entry point is main() - this will
                      allow the linker to generate wrapper code to setup stacks, allocate
                      heap area, and initialize and copy code and data segments. For GNU
                      toolsets, the entry point is through __start() in the crt0_gnu.asm
                      file, and that startup code will setup stacks and data */
                    int main(void)
                    {
                      return c_entry();
                    }
                    
                    
                    #ifdef DEBUG
                    /*******************************************************************************
                    * @brief		Reports the name of the source file and the source line number
                    * 				where the CHECK_PARAM error has occurred.
                    * @param[in]	file Pointer to the source file name
                    * @param[in]  line assert_param error line source number
                    * @return		None
                    *******************************************************************************/
                    void check_failed(uint8_t *file, uint32_t line)
                    {
                    	/* User can add his own implementation to report the file name and line number,
                    	 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
                    
                    	/* Infinite loop */
                    	while(1);
                    }
                    #endif
                    تولید کننده انواع تابلو فرمان آسانسور با تکنولوژی روز دنیا

                    دیدگاه


                      #11
                      پاسخ : SPI1 با LPC1768

                      من الان سخت افزار رو تغییر دادم و برگشتم سراغ spi ولی بازهم مشکل دارم
                      مثال از spi اگه دارید ممنون می شم
                      اینکار برای ارتباط با at45db321 است که بصورت spi است :
                      برای نوشتن که بعد از هر بایت که نوشتم بیت spif رو چک می کنم تا صفر بشه بعد بایت بعدی رو می نویسم ولی برای خوندن آیا لازم نیست چیزی رو چک کنم تا مطمن بشم دیتاها دریافت شده و تکمیله؟!

                      دیدگاه


                        #12
                        پاسخ : SPI1 با LPC1768

                        جریان چیه که توی تموم سمپلها برای ارسال و دریافت SPI یک تالع استفاده شده :
                        کد:
                        unsigned int SPI0(unsigned int val)
                        {
                        
                        unsigned int received = 0;
                        LPC_SPI->SPDR = val;
                        while( !(LPC_SPI->SPSR & 0x80));//wait for transfer to be completed
                        received=LPC_SPI->SPDR;
                        return(received);
                        }
                        ولی من می خوام با یک تابع یک بایت بفرستم و در واقع و در اونجا نیازی داره حتما چیزی بخونم ؟
                        و با تابع دیگه بخونم و آیا نیازی داره اونجا قیل از خوندن ، چیزی بنویسم ؟

                        دیدگاه


                          #13
                          پاسخ : SPI1 با LPC1768

                          من با اسکوپ گرفتم
                          به ازاه هر پالس کلاک دو بیت دیتا ارسال می شه
                          نمی دونم کجای تنظیمات اشتباه کردم که اینطوری شده


                          ببخشید الان با دقت تست کردم ؛ درسته
                          من توی لوپ aa هگز رو می فرستم و دیتاها رو نگاه می کنم که باید یک بیت در میان 0و1 باشه و اینطوری هم هست
                          و کلاک هم درسته
                          اولش فکر می کردم که اشتباه

                          دیدگاه


                            #14
                            پاسخ : SPI1 با LPC1768

                            من تمام تنظیمات رو مشابه مثالهای موجود رفتم و البته از سخت افزارم هم مطمن هستم
                            ولی نمی دونم چرا spi کار نمی کنه
                            واقعا نیاز به کمک دارم
                            نوشته اصلی توسط داریوش عباسی
                            جریان چیه که توی تموم سمپلها برای ارسال و دریافت SPI یک تالع استفاده شده :
                            کد:
                            unsigned int SPI0(unsigned int val)
                            {
                            
                            unsigned int received = 0;
                            LPC_SPI->SPDR = val;
                            while( !(LPC_SPI->SPSR & 0x80));//wait for transfer to be completed
                            received=LPC_SPI->SPDR;
                            return(received);
                            }
                            ولی من می خوام با یک تابع یک بایت بفرستم و در واقع و در اونجا نیازی داره حتما چیزی بخونم ؟
                            و با تابع دیگه بخونم و آیا نیازی داره اونجا قیل از خوندن ، چیزی بنویسم ؟
                            جواب این سوال می تونه کلید راه من باشه !

                            دیدگاه


                              #15
                              پاسخ : SPi با LPC1768

                              من شخصا هیچوقت با SPI با هیچ میکرویی کار نکردم و آرم رو هم حدود 2 ماهه به شدت دارم کار میکنم و متاسفانه گذرم به این قسمت نیفتاده. ولی چنتا سمپل داشتم که در اختیارتون گذاشتم و 2 تا سمپل دیگه هم دارم که با CMSIS نوشته شده اگه بدردتون میخوره تا بفرستم براتون.

                              دیدگاه

                              لطفا صبر کنید...
                              X