Skocz do zawartości

simoon87

Użytkownicy
  • Zawartość

    74
  • Rejestracja

  • Ostatnio

  • Wygrane dni

    2

simoon87 wygrał w ostatnim dniu 4 stycznia 2013

simoon87 ma najbardziej lubianą zawartość!

Reputacja

9 Neutralna

O simoon87

  • Ranga
    4/10
  • Urodziny 15.12.1987

Informacje

  • Płeć
    Mężczyzna
  • Lokalizacja
    Bydgoszcz
  • Zawód
    Integrator Systemów Elektronicznych
  1. Dzięki Tobie rozwikłałem zagadkę! Wielkie dzięki. Zakładałem projekt tak samo jak w kursie z jedną różnicą.... W kursie wybierana jest płytka Nuceo w oknie MCU Configuration: Natomiast ja dodałem 2 swoje płytki: ZL27arm, oraz płytkę swojego urządzenia. Gdy wybiore jedną z nich do Startup ładowany jest plik: startup_stm32.s. Jeśli wybiorę Nuceo faktycznie jest plik: startup_stm32f10x_ms.S Po ręcznej podmianie plików projekt Żyje!!! Jeszcze raz wielkie dzięki
  2. Dzisiaj przeinstalowałem OpenSTM32, założyłem nowy projekt, przekopiowałem wszystkie swoje pliki *.c *.h skompilowałem i dalej nie działa. Nie mam już pomysłów w załączniku przesyłam wyeksportowany projekt. W związku z tym mam prośbę do Ciebie Elvis, jakbyś mógł rzucić na niego okiem może coś zauważysz.... sp_open.zip
  3. Tak do końca nie mogę zrobić Kopiuj/Wklej wiec założyłem nowy projekt pozamieniałem na USART1 oraz odpowiednie GPIO (nie robię tego na Nuceo). Cały czas nie działa. Jutro przeinstaluje całe to OpenSTM32 bo już nie mam innych pomysłów.
  4. Dodanie USART_ClearITPendingBit(USART1, USART_IT_TXE); nic nie zmienia. W dalszym ciągu procesor w ogóle nie wchodzi do USART1_IRQHandler() Pisząc ten kod posiłkowałem się Książką STM32 Aplikacje i ćwiczenia w języku C. Autor w żadnym z kodów nie używał funkcji USART_ClearITPendingBit. Mam prośbę mógłbyś udostępnić Twój projekt z OpenSTM32 skoro u Ciebie działa chciałbym zaimportować go do siebie i porównać co robię nie tak.
  5. Nie, to jest tak, że działa tylko funkcja USART_SendData() która jest standardowo w pliku stm32f10x_usart.h ale ona wysyła bajt bez obsługi przerwania. Nie działa ani USART_SendChar ani USART_Puts które ładują odpowiednio znak lub łańcuch do bufora cyklicznego a następnie wywołują przerwanie. To, że program w ogóle nie wchodzi do przerwania zdiagnozowałem w banalny sposób, na sam początku funkcji obsługi przerwania dodałem zasiedzenie diody. Niestety dioda się nie świeci. Dodatkowo w Debugu widać ze program wykonuje się OK do momentu w którym powinien wejść do przerwania i nagle umiera. Kod przerwanie poniżej: void USART1_IRQHandler(void) { GPIO_WriteBit( LED_GPIO, ERR_LED, 0); //DEBUG if( USART_GetITStatus(USART1, USART_IT_TXE) == SET ) { // sprawdzamy czy indeksy są różne if( Buffer.TxBeg != Buffer.TxEnd ) { Buffer.TxEnd = (Buffer.TxEnd + 1) & TX_BUF_MASK; // obliczamy i zapamiętujemy nowy indeks konca (może się zrównać z poczatkiem) USART1->DR = Buffer.TxBuf[Buffer.TxEnd]; // zwracamy bajt pobrany z bufora jako rezultat funkcji } else { USART_ITConfig(USART1, USART_IT_TXE, DISABLE); // wylacz przerwanie = koniec transmisji } } if( USART_GetITStatus(USART1, USART_IT_TC) == SET ) //gdy bufor nadawczy pusty { SendMode(FALSE); // odbiornik załaczony && nadajnik wyłaczony } if( USART_GetITStatus(USART1, USART_IT_RXNE) == SET ) { register uint8_t tmp_head; register uint8_t data; tmp_head = (Buffer.RxBeg + 1) & RX_BUF_MASK; // obliczamy nowy indeks poczatku data = (uint8_t)(USART1->DR); if( tmp_head == Buffer.RxEnd ) Buffer.RxBeg = Buffer.RxEnd; // sprawdzamy nadmisanie else { switch( data ) { case 0: break; // ignorujemy bajt = 0 case 10: break; // ignorujemy znak LF case 13: Buffer.ascii_line++; // sygnalizujemy obecność kolejnej linii w buforze default : Buffer.RxBeg = tmp_head; Buffer.RxBuf[tmp_head] = data; } } } } Co do stosu to jestem sceptycznie nastawiony gdyż ten sam kod działa w Keil oraz ten program robi tylko 2 rzeczy miga diodą oraz wysyła jeden znak. Co miało by przepełniać stos? plik main: #include "SystemInit.h" //Konfiguracja systemu int main(void) { RCC_Config(); GPIO_Config(); RS485_Configuration(9600, USART_Parity_Even); if( SysTick_Config_Mod(SysTick_CLKSource_HCLK_Div8, 90000ul) ) while(1); GPIO_WriteBit( LED_GPIO, ERR_LED, 1); //Wygaszenie diody ERROR for(;;) { if(!SysTimer.SoftTimer[0]) //100ms { SysTimer.SoftTimer[0]=10; GPIO_WriteBit( LED_GPIO, LIVE_LED, (BitAction)(1-GPIO_ReadOutputDataBit(LED_GPIO, LIVE_LED)) ); // XOR LIVE LED } if(!SysTimer.SoftTimer[1]) //500ms { SysTimer.SoftTimer[1]=50; SendMode(TRUE); // USART_SendData(USART1, 'X'); //Działa ale to jest wyslanie bez obsługi przerwania // USART_SendChar(USART1, 'X'); //nie działa USART_Puts( USART1, "X" ); } } return 0; } Edit: Bez inicjalizacji PLL wszystko bez zmian
  6. Nie, korzystają z tej samej wersji (StdPeriph_Lib_V3.5.0). Sprawdzałem Poza tym System Workbench for STM32 samo pobiera sobie biblioteki StdPeriph w trakcie tworzenia projektu wiec nie ma mowy o pomyłce prędzej mógłbym się pomylić dodając ręcznie biblioteki do uVision. Treker, używałeś w tym IDE Usartu z obsługą przerwań? Chciałbym ustalić czy jest to problem u mnie czy coś innego?
  7. Źródło problemu częściowo zostało znalezione. Jest to wina IDE używałem System Workbench for STM32 polecanego w kursie i ku mojemu zaskoczeniu kod po przekopiowaniu do Keil uVision5 działa bez zarzutu. W System Workbench for STM32 USART działał w moim kodzie tylko gdy używam go bez obsługi przerwań. Czy ktoś Was spotkał się z takim problemem? Nie ukrywam, że bardziej przyzwyczajony jestem do Eclipse i brakuje mi kilku udogodnień w Keilu.
  8. TAK void RCC_Config(void) { ErrorStatus HSEStartUpStatus; //zmienna opisujaca rezultat uruchomienia HSE RCC_DeInit(); //Reset ustawien RCC RCC_HSEConfig(RCC_HSE_ON); //Wlaczenie HSE HSEStartUpStatus = RCC_WaitForHSEStartUp(); //Odczekaj az HSE bedzie gotowy if(HSEStartUpStatus == SUCCESS) { FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);// FLASH_SetLatency(FLASH_Latency_2); //ustaw zwloke dla pamieci Flash; zaleznie od taktowania rdzenia //0:<24MHz; 1:24~48MHz; 2:>48MHz RCC_HCLKConfig(RCC_SYSCLK_Div1); //ustaw HCLK=SYSCLK RCC_PCLK2Config(RCC_HCLK_Div1); //ustaw PCLK2=HCLK RCC_PCLK1Config(RCC_HCLK_Div2); //ustaw PCLK1=HCLK/2 RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9); //ustaw PLLCLK = HSE*9 czyli 8MHz * 9 = 72 MHz RCC_PLLCmd(ENABLE); //wlacz PLL while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET); //odczekaj na poprawne uruchomienie PLL RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); //ustaw PLL jako zrodlo sygnalu zegarowego while(RCC_GetSYSCLKSource() != 0x08); //odczekaj az PLL bedzie sygnalem zegarowym systemu /*Tu nalezy umiescic kod zwiazny z konfiguracja sygnalow zegarowych potrzebnych w programie peryferiow*/ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//wlacz taktowanie portu GPIO A enkoder RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//wlacz taktowanie portu GPIO B led RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);//wlacz taktowanie USART1 uart RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); } else {} }
  9. Mam pytanie z innej beczki próbuje skonfigurować USART w STM32F103RTB6 z obsługą przerwań oraz buforem cyklicznym. USART podłączony jest do SN75176 ( transceiver RS485) schemat poniżej: Mój problem jest taki że procesor w ogóle nie wchodzi do przerwania USART1_IRQHandler oraz wygląda jakby się zawiesił. Dodatkowo jeśli wysyłam w taki sposób USART_SendData(USART1, 'X'); zamiast USART_Puts( USART1, "485 test!\n" ); to transmisja działa. Wychodzi więc, że błąd jest gdzieś w funkcji SendChar lub w konfiguracji ale niestety nie potrafię go znaleźć. Chciałbym prosić bardziej doświadczonych forumowiczów o pomoc w rozwiązaniu problemu. konfiguracja USART1 9600 8e1: void RS485_Configuration(uint32_t baudrate, uint16_t parity) { GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; USART_ClockInitTypeDef USART_ClockInitStructure; NVIC_InitTypeDef NVIC_InitStructure; USART_DeInit(USART1); #ifdef VECT_TAB_RAM /* Set the Vector Table base location at 0x20000000 */ NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); #else /* VECT_TAB_FLASH */ /* Set the Vector Table base location at 0x08000000 */ NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0); #endif /* Enable the USART1 Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; // USART1_IRQn NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Config DE/nRE */ /* Configure (PA.11) as Output push-pull */ GPIO_InitStructure.GPIO_Pin = DO_485; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Configure USART1 Tx (PA.9) as alternate function push-pull */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Configure USART1 Rx (PA.10) as input floating */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = baudrate; USART_InitStructure.USART_WordLength = USART_WordLength_9b; USART_InitStructure.USART_StopBits = USART_StopBits_1; if( (parity != USART_Parity_Even) && (parity != USART_Parity_Odd) ) { parity = USART_Parity_No; } USART_InitStructure.USART_Parity = parity ; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_ClockInitStructure.USART_Clock = USART_Clock_Disable; USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low; USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge; USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable; /* Configure the USART1 */ USART_Init(USART1, &USART_InitStructure); USART_ClockInit(USART1,&USART_ClockInitStructure); /* Enable the USART1 */ USART_Cmd(USART1, ENABLE); /* Send RS485 in Rece Mode */ SendMode(FALSE); } Funkcja SendChar: void USART_SendChar(USART_TypeDef* USARTx, uint8_t Char) { /* Check the parameters */ assert_param(IS_USART_ALL_PERIPH(USARTx)); assert_param(IS_USART_DATA(Char)); /* Fill Tx buffor */ uint8_t tmp_head; tmp_head = (Buffer.TxBeg+1) & TX_BUF_MASK; while(tmp_head == Buffer.TxEnd) {} Buffer.TxBuf[tmp_head]=Char; Buffer.TxBeg=tmp_head; /* Turn On Tx Interrupt / Starting transmit */ USART_ITConfig(USARTx, USART_IT_TXE, ENABLE); } Funkcja Puts void USART_Puts( USART_TypeDef* USARTx, char *s ) { register uint8_t c; while ((c = *s++)) USART_SendChar( USARTx, c ); }
  10. Z podstawi nie zrobisz programatrora z jednego prostego powodu. Piny programujące z dolnego gniazda nie są podłączone nigdzie indziej poza gniazdem opisanym jako FT232 i to cały czaś próbuje Tobie przekazać. at2313 możesz zaprogramować tylko przez avrdude i tylko używajac dolnego gniazda i przewodów a nie przez bootloader. napisałem wcześniej wyraźnie: (bootlader dostarczony przez Andtech obsługuje tylko atmege16 i 32 po uprzednim wgranu odpowiedniecgo wsadu bootloadera który dołączyłem do paczki zip) Jeśli wgrasz bootloader od andtech do at2313 to nie zadziała.
  11. Dobra od początku... nie zrozumieliśmy się a w zasadzie Ty mnie nie zrozumiałeś. Programator i bootloader to dwie różne rzeczy i obie funkcje są realizowane przez ft232rl. Programator zawarty w zestawie EvB obsługiwany jest przez avrdude i to jest fakt! Połączenie ktore jest przedstawione na obrazku było omawiane na forum producenta w zwiazku z pytaniem jak wgrać bootloader do nowej atmegi (innej niż dostarczona przez Andtech) bez zewnetrznego programatora. Reasumując jeśli chcesz programować procesor w zestawie używasz Bootloadera (and-loader) i nie trzeba nic łączyć przewodami. Gdyż txd i rxd jest juz połączone na pcb. (bootlader dostarczony przez Andtech obsługuje tylko atmege16 i 32 po uprzednim wgranu odpowiedniecgo wsadu bootloadera który dołączyłem do paczki zip) Jeśli chesz zaprogramować inną atmege w jakimś zewnetrznym układzie podłączasz tą "inną atmege" do pinów w dolenej częsci płytki i programujesz przez avrdude... Jeśli nie znalazleś wersji avrdude obsługującej ft232rl jako programator isp to w załączniku masz paczkę. EvB-ISP.zip
  12. Z Twojego ostaniego postu wniosku że masz płytke firmy andtech. Jeśli tak to nie producent milczy tylko kiepsko szukasz, na stronie w instruncji jak i na forum jest taki oto obrazek pokazujący jak podłączyć inny procesor (to złącza na dole to wyjscie z układu ft232rl na ktorym jest zrobiony ten mega prosty programator, ktory obsługiwany jest przez avrdude. And-Load to bootloader który ładuje program przez TXD i RXD czyli uart)
  13. Proponuję przejrzeć dokładnie dokumentacje od procesora tzn. UM10398 (UserManual) oraz LPC11xx Datasheet. A dowiesz się z nich że na PIO0_2 nie da się wygenerować sprzętowego PWM gdyż pin ten nie posiada takiej funkcji. Masz książkę i coś wydaje mi się że nawet nie przeczytałeś całego rozdziału o licznikach w którym zawarta jest informacja podobnie jak w Manualu że PWM można generować z nóżek oznaczonych jako MATx LPC_IOCON->PIO0_9 = 0x02; LPC_IOCON->SWCLK_PIO0_10 = 0x03; Tab 79 i 80. strona 78 UserManual (UM10398) - jest to wybór funkcji pinu LPC_TMR16B0->PWMC = 0x06; Tab 229. strona 263-264 UserManual (UM10398) - wybór aktywnych kanałów PWM timera CT16B0 Te informacje plus książka którą posiadasz powinna wystarczyć do opanowania PWM.
  14. if (PINC && 0x01) w tego typu miejscach powinno być if (PINC & 0x01)
×
×
  • Utwórz nowe...