Skocz do zawartości

Vroobee

Użytkownicy
  • Zawartość

    128
  • Rejestracja

  • Ostatnio

  • Wygrane dni

    4

Vroobee wygrał w ostatnim dniu 26 października 2016

Vroobee ma najbardziej lubianą zawartość!

Reputacja

15 Dobra

O Vroobee

  • Ranga
    5/10

Informacje

  • Płeć
    Mężczyzna

Ostatnio na profilu byli

Blok z ostatnio odwiedzającymi jest wyłączony i nie jest wyświetlany innym użytkownikom.

  1. Akurat ATmega328 wynikła z prostego faktu, że miałem w szufladzie 10 sztuk kupionych gdzieś w chinach akurat w obudowie QFN. Od jakiegoś czasu po prostu szukam rozwiązań jak najmniejszych oraz możliwych do zlutowania przeze mnie - stąd zamiłowanie do tego typu obudów oraz elementów SMD 0402 Natomiast nie zastanawiałem się nad ATmega32U4. Miałem kiedyś ten procek, miły całkiem. Ale QFN jest nieco większy (44 piny zamiast 32 chociaż i tak dla tych rozmiarów to nie argument). Zapewne będę rozwijał projekt dalej więc w wersji 2.0 pewnie uwzględnię opcje z wbudowanym kontrolerem USB.
  2. @Gieneq FT230XQ to po prostu konwerter USB-UART. Działanie podobne do każdego FT232 od procka do FT230 komunikacja po UART potem już USB. Niestety ATmega328 nie posiada wbudowanego USB.
  3. @Gieneq starałem się żeby wszystko było w miarę przemyślane - tolerancje wymiarowe, prowadzenie ścieżek itp. Oczywiście na tyle na ile moja znajomość mechaniki i elektroniki na to pozwala dyplomy robiłem z zupełnie innej tematyki. Dziedzina ta sama, bo diagnostyka maszyn, natomiast konstrukcja dotyczyła całego stanowiska do testowania łożysk wraz z oprogramowaniem akwizycyjnym i analizującym.
  4. VibSense + VibDongle 1) Wprowadzenie Jakiś czas temu po zajęciach przeprowadzonych na politechnice dotyczących ogólnej oceny stanu technicznego maszyn i urządzeń doszedłem do wniosku, że fajnie byłoby zagłębić się bardziej w temat pomiaru drgań. Drgania mechaniczne są symptomem, który dobrze reprezentuje stan techniczny maszyny. Zazwyczaj im wyższe tym gorszy jej stan techniczny. Wykonując dodatkowe analizy np. analiza widmowa w określonym paśmie pomiarowym, można po rozkładzie widma zdecydować, który podzespół jest uszkodzony. Dlatego postanowiłem zaprojektować i wykonać prototyp urządzenia, które z założenia miało: dokonywać pomiaru drgań w paśmie minimum do 1000 Hz, umożliwić pomiar bez konieczności stosowania okablowania w okolicy maszyny (przez nieuwagę taki przewód może się wkręcić w wirnik - konsekwencje mogą być różne), montaż na magnes (maszyny zazwyczaj są wykonane ze stali więc jest to dość pewny sposób mocowania), w wypadku gdy wykorzystujemy transmisję bezprzewodową i nie mamy możliwości połączenia się z odbiornikiem z różnych powodów, zapis na pamięć wewnętrzną lub kartę pamięci, możliwość odczytywania danych z wielu czujników jednocześnie. Wedle tych założeń powstał projekt, który nazwałem VibSense - czyli po prostu czujnik drgań. Do tego pomysłu doszedł drugi, VibDongle - urządzenie do akwizycji danych z czujników VibSense. 2) VibSense Ideą, która przyświecała podczas projektowania czujnika, było możliwe zastosowanie w przemyśle oraz w zastosowaniach amatorskich. Oczywiście prototyp raczej nie mógłby zostać wdrożony w przemysł, tutaj należałoby się zastanowić nad dodatkowymi rozwiązaniami typu zmiana złącz transmisyjnych z micro USB na przemysłowe, obudowa z klasą ochronności IP65 chociażby. Temat do dalszych rozważań jest. Opisany tutaj projekt raczej jest konstrukcją hobbystyczną. Założenia projektowe: konstrukcja mobilna - małe wymiary, zasilanie z akumulatora Li-Pol komunikacja bezprzewodowa - zastosowanie komunikacji radiowej ze względu na mniejszą energochłonność modułów radiowych względem modułów WiFi chociażby, parametrem decyzyjnym był również zasięg. pomiar drgań minimum do 1 kHz (szersze pasmo mile widziane) możliwość zapisu na kartę microSD lub pamięć wewnętrzna komunikacja RS232-USB - na potrzeby bootloadera lub zwykłej przewodowej wymiany danych. minimum jeden przycisk - zawsze się przydaje, minimum jedna dioda jak najmniejsze PCB - stąd założenie obudów SMD dla większości układów oraz rozmiarów elementów SMD 0402. Na ww. założeniach oparłem całą elektronikę, która jest wykorzystywana w przypadku modułu VibSense: procesor ATmega328 - procek w sumie jeden z najprostszych i miałem akurat w szufladzie wersję SMD, wystarczająca ilość portów do tego projektu, wszystkich opcji było w sam raz, FT230XQ - układ RS232, komunikacja procesor-komputer po USB, posiada jedną z mniejszych obudów SMD i spełnia swoją funkcję, ADXL345 - trójosiowy akcelerometr cyfrowy, niski pobór prądu, magistrala SPI/I2C, pomiar do +/-16g czyli ok. 160 m/s2 w przypadku przyspieszeń drgań (w zupełności wystarczająco), maksymalna częstotliwość wysyłania danych 3200 Hz co daje pasmo pomiarowe 1600 Hz jeżeli chcemy uniknąc w minimalnym stopniu zjawiska aliasingu, 2 wyjścia przerwań, napięcie zasilania do 3V6; Czego chcieć więcej RFM73-D - komunikacja radiowa 2,4 GHz, zastosowania przemysłowe na 2,4 GHz raczej nie są dobrym pomysłem ale takie moduły akurat miałem i znam je w miarę więc wykorzystałem w projekcie slot na karty microSD - zapis na nośnik zewnętrzny, microswitch podłączony pod wejście INT procesora dwukolorowa dioda LED czerwono-zielona złącze programatora ISP - w razie bootloader by nie działał złącze micro USB zasilanie akumulatorem LiPol 3V6 o pojemności 80 mAh układ nadzorujący ładowanie akumulatora MCP73833 stabilizator napięciowy LDO na 2V8 - na takim napięciu działa całą elektronika. Płytki zostały wykonane przez JLCPCB - jakość bardzo dobra, zarówno ścieżki, jak i warstwa opisowa. Polecam producenta PCB bardzo gorąco zdjęcia płytek po zlutowaniu zamieszczam poniżej. Pochwalę się - wszystko lutowane ręcznie przeze mnie 3) VibDongle W przypadku tego urządzenia chciałem wykonać coś co będzie zbierać dane od wszystkich czujników, które są zamontowane na maszynie. Urządzenie miało być małych rozmiarów i być podłączane jako dongle do portu USB komputera. VibDongle powstał na praktycznie takich samych komponentach jak VibSense, oczywiście bez akcelerometru, przycisku i slotu na kartę oraz z wtyczką USB. Poza tym - dokładnie to samo. 4) Schematy elektryczne Schematy elektryczne załączam poniżej. Może, któreś z rozwiązań przyda się komuś chociaż nie jest to nic zaskakującego. Wszystkie połączenia zgodne z notami katalogowymi producentów. 5) Funkcjonalność Jeśli chodzi o funkcjonalność modułów współpracujących ze sobą, założenia były następujące: praca w sieci - połączenie wielu czujników z jednym modułem odbiorczym możliwość parowania czujników z odbiornikiem wysyłanie i odbiór danych z maksymalną częstotliwością jaką daje moduł ADXL tak aby nie było opóźnień czasowych; niezbędne do przetwarzania danych w trybie semi-real time, w przypadku braku odbiornika zapis na kartę micro SD, możliwość czasowego wyzwolenia pomiaru po wciśnięciu przycisku odbiór danych przez VibDongle i wysyłka po USB, analiza danych już w aplikacji na komputerze Na razie sama funkcjonalność jest nieco ograniczona. Testowane były tylko 2 moduły VibSense współpracujące z VibDongle. Tryb software'owego parowania i przesyłania danych działa bez zarzutu - oczywiście nie obyło się bez kłopotów z elektroniką oraz problemów programowych Do opracowania zostało jeszcze: zapis na kartę, konkretny system przesyłania danych tak aby nie zapychać kolejki przy dużej ilości czujników podłączonych do jednego VibDongle oraz aplikacja na PC do akwizycji i analizy danych. Dodatkowo można wykonać cyfrowo w programie samego czujnika całkowanie przyspieszeń drgań na prędkości drgań oraz wyliczyć wartość RMS w paśmie 10 - 1000 Hz. Dzięki temu będzie możliwa ocena ogólnego stanu technicznego maszyny wirnikowej z wykorzystaniem normy PN ISO 10816. W zdjęciach dodałem zrzut z terminala z info AT (tak, moduł obsługuje komendy AT) oraz przesłanie jednego pomiaru. 6) Obudowa Aby całości nadać jakiś kształt (na razie tylko czujnikowi) wykonałem prototyp obudowy. Prototyp został wydrukowany na drukarce 3D dzięki uprzejmości mojego znajomego oraz zamodelowany we Fusion 360. Następna sztuka będzie trochę bardziej obła, ponieważ nieco przeszkadzają mi ostre brzegi nakrętki od spodu są przyklejone dzięki czemu możliwe jest zarówno skręcenie obudowy jak i dokręcenie magnesu do podstawy. Wymiary płytek PCB: VibSense 35 x 35 mm VibDongle (ze złączem USB) 60 x 15 mm 7) Podsumowanie Na razie całość prosta bo prosta ale spełnia swoje zadanie. Do zrobienia zostało jeszcze sporo ale na to muszę mieć trochę więcej czasu. W miarę postępów w pracach będę aktualizował temat WA_dongle.pdf WA_sense_v1.pdf
  5. Witam, jeśli ktoś z Was ogarniał bibliotekę p.Mirka do RFM69CW może spróbuje mi na to odpowiedzieć bo ja już w sumie nie wiem o co chodzi. Więc, wykorzystując bibliotekę z GB dot. RFM69CW i to że ten moduł od wersji HW teoretycznie nie powinien różnić się prawie niczym jeśli chodzi o zasadę działania postanowiłem napisać prosty program do wysyłki danych. ALE niestety zauważyłem, że moduł nie bardzo pozwala na zapis do niektórych rejestrów. Po kolei - init przebiega pomyślnie praktycznie tak samo jak w GB z drobną różnicą, że wartości takie jak częstotliwość nośna itp. wpisuję na stałe bez możliwości wpisania ich jako argument funkcji. Na koniec initu - standby plus rxon. Moduł przechodzi w tryb odbioru. Po czym próbuję coś wysłać i tu zonk. Nawet nie mogę zapisać nic do kolejki FIFO. Za każdym sprawdzeniem zapełnienia bufora przed i po funkcji rfm69_fifo_transfer() otrzymuję flagę FIFO_NO_EMPTY jako pusty bufor. I tu pojawia się pytanie czy ten moduł ma jakieś specjalne warunki działania, żeby móc cokolwiek zapisać do bufora ? Również późniejsze przejście do trybu txon() kończy się timeoutem i wywaleniem funkcji. Proszę o wskazówki co mogło pójść nie tak. Aaaaa i ciągle w sumie wskazywane jest bufor fifo jako NotEmpty, brak możliwości skasowania bufora FIFO. Po wywołaniu funkcji fifo_clear nadal jest NotEmpty.
  6. Hmm to ciekawe, nie sprawdzałem stabilności napięć. Zaufałem, ze skoro zasilacz umożliwia podłączenie kilku na raz do płyty głównej komputera to raczej muszą być stabilne. CHOCIAŻ do myślenia dała mi teraz trochę jedna sytuacja. Podczas pierwszego podpięcia na chama przekaźników do obu kanałów zasilając komparator linią 12V i wcześniejsze przekaźniki z cewka na 5V z szyny 5V zauważyłem spadek napięcia na linii 12V aż o 1,5V. Nie było wtedy podłączonego tzw. dummy load’u 33R/10W. Może kwestia tej stabilizacji właśnie. Przełącznik dobieralem taki żeby wytrzymał maksymalna moc jaka może dać zasilacz na wyjściu czyli 50W dla jednego kanału (5V i 10A). A przynajmniej tak mi się wydaje na oznaczeniu ma 0,5A dla 125VDC wiec chyba da radę.
  7. W porządku, zaraz siądę do ogarniania. Co do tego co robię: próbuję przerobić zasilacz ATX na dwukanałowy zasilacz "laboratoryjny" z 3 ustawianymi napięciami wyjściowymi tj. 3V3, 5V i +/-12V. Chciałem ograniczyć ilość wyjść do max 2 czerwonych (napięcia pozytywne i negatywne) i jednego czarnego (masa), więc napięcia na każdym kanale przełączam obrotówką. Dlatego chciałem zrobić układ, który przy przełączeniu się na napięcie 12V załączy przekaźnik doprowadzający do drugiego wyjścia czerwonego napięcie -12V. Przy napięciach wyjściowych 3V3 i 5V drugie wyjście byłoby po prostu nieaktywne. Mogę dołączyć schemat dla pojedynczego kanału zasilacza - @marek1707 mógłbyś zerknąć na poprawność połączeń ? Dodatkowo zamieszczę schemat całej płytki sterującej przekaźnikami z opisem wyprowadzeń wzmacniacza i stopnia wyjściowego. P.s. kropka przy nr wyszła z rozpędu Z góry przepraszam za to, że schemat na kartce ale po prostu jest mi szybciej i łatwiej. Mam nadzieję, że nie jest to problemem. starałem się wszystko opisać tak, żeby wszystko co jest istotne znalazło się na schemacie. Pomiar napięcia i prądu realizowany na tego typu mierniczku (zapewne każdemu znany): https://www.aliexpress.com/item/0-28-Red-Blue-LED-DC-0-100V-10A-Dual-display-Meter-Digital-Voltmeter-Ammeter-Panel/32310008404.html . Oczywiście nie jest to reklama tego konkretnego miernika - podałem link jako przykład
  8. 1) foto nr. 1 - układ jest poprawny 2) wyprowadzenia sprawdzałem kilka razy i się zastanawiam czy sygnały podpinam dobrze. Dlatego proszę o potwierdzenie podpięcia i czy ew. modyfikacja na sprzężenie zwrotne dodatnie to tylko podpięcie pomiędzy wyjście, a plus ? 3) napięcie pomiędzy VCC, a masą to 12V więc chyba jest okej. 4) o dziwo zasilacz laboratoryjny przy podłączeniu układu daje 0,000 A (nie wiem o co chodzi). 5) stopień wyjściowy działa na 100% - sprawdzałem 6) napięcia wejściowe są doprowadzane, również sprawdzałem. Spróbuję przerobić ten wzmacniacz na opcję ze sprzężeniem zwrotnym dodatnim i odfiltrować lekko referencję. Ew. proszę o podpowiedź jaki układ byłby pinoutem zbliżony żeby był typowym komparatorem, a nie musiałbym za nadto przerabiać płytki. Pomęczę się jeszcze trochę ze sprawdzaniem przewodności scieżek itp.
  9. Witam, mógłby ktoś sprawdzić schemat podłączenia układu porównującego napięcie bazującego na komparatorze (wzmacniacz LM358N). Coś nie chce działać jak powinno. Napięcie referencyjne ustawione na 8,5 V. Po przekroczeniu tego napięcia układ wyjściowy ma załączać przekaźnik 12V. Całość zasilana z jednego napięcia (12V właśnie). Komparator nie daje na wyjściu żadnego napięcia w momencie przekroczenia napięcia referencyjnego ani gdy Uref jest wyższe niż napięcie podane na wejście nieodwracające. Ktoś wie, co może być nie tak ?
  10. Przesyłam cały folder z programem, może jest jeszcze coś co przeoczyłem dziękuję za chęć pomocy. [ Dodano: 19-03-2018, 10:08 ] OK znalazłem błąd ... w startup_stm32.s jest funkcja USART IRQ zatytułowana: USART2_EXTI26_IRQHandler (!!!) a nie jak miałem wcześniej zapisane: USART2_IRQHandler Dlatego nie mógł wejść do przerwania dzięki za zwrócenie uwagi na bibliotekę startup_stm32.s USART_STM32F3.zip
  11. Drzewko projektu, proszę bardzo i breakpoint .... znaczy ten co nie wszedł w sumie
  12. Jak coś jeszcze dodać to proszę o dopisanie skąd co wpisać. Wygląda na to że to coś z Watchdogiem i wpada w jakiś Infinite_Loop [ Dodano: 18-03-2018, 22:10 ] W sensie jest opcja, że to błąd w bibliotece ?
  13. Zawiesza w sensie gdy w pętli głównej miga diodą to po przyjęciu przerwania dioda już nie miga a co dokładnie Cię interesuje jako informacja z debugera (nie wywala żadnego błędu, po prostu procek jakby przestaje pracować)
  14. Witam, przychodzę z problemem natury dość dziwnej. Może ktoś będzie wiedział o co chodzi. Mianowicie wykorzystując przerwanie od UART przesyłając znak jakikolwiek w stronę procka (np. wpisując w terminalu) procek się zawiesza. Tą samą (własną) bibliotekę przepisałem wykorzystałem na STM32F103RBT6 i wszystko jest ok. Może ktoś z Was znajdzie jakiś błąd jeśli chodzi o ten typ procków (STM32F3). Poniżej dołączam kody: #include "stm32f30x.h" #include <stdbool.h> #include "Delay/delay.h" #include "RCC_Init/rcc_init.h" #include "GPIO_Init/gpio_init.h" #include "USART_STM32/usart_stm32.h" #define LED_ON GPIO_SetBits(GPIOB, GPIO_Pin_3) #define LED_OFF GPIO_ResetBits(GPIOB, GPIO_Pin_3) void LED_TOG(uint32_t time); uint32_t counter; char data = 0; int main(void) { systick_conf; rcc_init(); gpio_init(); nvic_init(); usart_init(USART2, 115200); usart_puts(USART2, "\r\nDevice ready ...\r\n"); _delay_ms(500); while(1){ if (odebranoDane == true){ usart_puts(USART2, buforRx); odebranoDane = false; } } } void LED_TOG (uint32_t time){ LED_ON; _delay_ms(time/2); LED_OFF; _delay_ms(time/2); } void gpio_init(void){ GPIO_InitTypeDef gpio; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB, ENABLE); GPIO_StructInit(&gpio); //********************USART *********************** //USART Rx gpio.GPIO_Pin = GPIO_Pin_15; gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_Speed = GPIO_Speed_50MHz; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOA, &gpio); GPIO_PinAFConfig(GPIOA, GPIO_PinSource15, GPIO_AF_7); //USART Tx gpio.GPIO_Pin = GPIO_Pin_2; gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_Speed = GPIO_Speed_50MHz; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOA, &gpio); GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_7); //*****************GPIO********************** //LED_NUCLEO gpio.GPIO_Pin = GPIO_Pin_3; gpio.GPIO_Mode = GPIO_Mode_OUT; GPIO_Init(GPIOB, &gpio); } void nvic_init(void){ NVIC_InitTypeDef nvic; //EXTI_InitTypeDef exti; #ifdef VECT_TAB_RAM NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); #else NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0); #endif NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); nvic.NVIC_IRQChannel = USART2_IRQn; nvic.NVIC_IRQChannelPreemptionPriority = 0; nvic.NVIC_IRQChannelSubPriority = 0; nvic.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&nvic); } #include "usart_stm32.h" #include <stdlib.h> #include <string.h> #include <stdbool.h> char buforRx[bufLength] = {0}; char bufRxIndex = 0; char buforTx[bufLength] = {0}; char bufTxIndex = 0; bool odebranoDane = false; void usart_init ( USART_TypeDef* USARTx, uint32_t BAUDRATE){ USART_InitTypeDef usart; if (USARTx == USART1){ RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); } else if (USARTx == USART2){ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); } USART_StructInit(&usart); // ---------- USART CONFIGURATION ------------ usart.USART_BaudRate = BAUDRATE; #if USART_WORD_LENGTH == 0 usart.USART_WordLength = USART_WordLength_8b; #endif #if USART_WORD_LENGTH == 1 usart.USART_WordLength = USART_WordLength_9b; #endif #if USART_PARITY == 0 usart.USART_Parity = USART_Parity_No; #endif #if USART_PARITY == 1 usart.USART_Parity = USART_Parity_Even; #endif #if USART_PARITY == 2 usart.USART_Parity = USART_Parity_Odd; #endif #if USART_STOP == 0 usart.USART_StopBits = USART_StopBits_1; #endif #if USART_STOP == 1 usart.USART_StopBits = USART_StopBits_2; #endif #if USART_STOP == 2 usart.USART_StopBits = USART_StopBits_1_5; #endif #if USART_HARDWARE_FLOW_CRTL == 0 usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None; #endif #if USART_HARDWARE_FLOW_CRTL == 1 usart.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS; #endif #if USART_HARDWARE_FLOW_CRTL == 2 usart.USART_HardwareFlowControl = USART_HardwareFlowControl_CTS; #endif #if USART_HARDWARE_FLOW_CRTL == 3 usart.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS_CTS; #endif #if USART_MODE_RX_ENABLE == 1 && USART_MODE_TX_ENABLE == 1 usart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; #endif #if USART_MODE_RX_ENABLE == 1 && USART_MODE_TX_ENABLE == 0 usart.USART_Mode = USART_Mode_Rx; #endif #if USART_MODE_RX_ENABLE == 0 && USART_MODE_TX_ENABLE == 1 usart.USART_Mode = USART_Mode_Tx; #endif //-------------------------------------------------- USART_Init(USARTx, &usart); #if USART_Rx_IT_ENABLE == 1 USART_ITConfig(USARTx, USART_IT_RXNE, ENABLE); #endif USART_Cmd(USARTx, ENABLE); } void usart_putc ( USART_TypeDef* USARTx, char c){ while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET); USART_SendData(USARTx, c); } void usart_puts ( USART_TypeDef* USARTx, const char *s ) { while ( *s ) usart_putc (USARTx, *s++); } void usart_putint ( USART_TypeDef* USARTx, int value, int radix ){ char string [17]; itoa (value, string, radix); usart_puts(USARTx, string); } char usart_getc ( USART_TypeDef* USARTx ){ char c; if (USART_GetFlagStatus(USARTx, USART_FLAG_RXNE)){ c = USART_ReceiveData(USARTx); } return c; } #if USART_Rx_IT_ENABLE == 1 void USART2_IRQHandler (void){ volatile unsigned long int delay; if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET){ buforRx[bufRxIndex] = USART_ReceiveData(USART2); if(buforRx[bufRxIndex] == 0x0D){ odebranoDane = true; while (bufRxIndex < bufLength){ buforRx[bufRxIndex] = 0; bufRxIndex++; } bufRxIndex = 0; } else { if(buforRx[bufRxIndex] != 0x0D){ bufRxIndex++; if(bufRxIndex > bufLength){ bufRxIndex = 0; } } } } if(USART_GetITStatus(USART2, USART_IT_TXE) != RESET){ USART_SendData(USART2, buforTx[bufTxIndex++]); for (delay = 0; delay < 150000; delay++); if(buforTx[bufTxIndex - 1] == 0x0D){ USART_ITConfig(USART2, USART_IT_TXE, DISABLE); bufTxIndex = 0; } } } #endif PARAMETRY USART: #define bufLength 32 extern char buforRx[bufLength]; extern char bufRxIndex; extern char buforTx[bufLength]; extern char bufTxIndex; extern bool odebranoDane; //----------- USART CONFIGURATION ------------ #define USART_Rx_IT_ENABLE 1 // 0 - DISABLE // 1 - ENABLE #define USART_WORD_LENGTH 0 // 0 - USART_WordLength_8b // 1 - USART_WordLength_9b #define USART_PARITY 0 // 0 - USART_Parity_No // 1 - USART_Parity_Even // 2 - USART_Parity_Odd #define USART_STOP 0 // 0 - USART_StopBits_1 // 1 - USART_StopBits_2 // 2 - USART_StopBits_1_5 #define USART_HARDWARE_FLOW_CRTL 0 // 0 - USART_HardwareFlowControl_None // 1 - USART_HardwareFlowControl_RTS // 2 - USART_HardwareFlowControl_CTS // 3 - USART_HardwareFlowControl_RTS_CTS #define USART_MODE_RX_ENABLE 1 // 0 - Rx DISABLE // 1 - Rx ENABLE #define USART_MODE_TX_ENABLE 1 // 0 - Tx DISABLE // 1 - Tx ENABLE
×
×
  • Utwórz nowe...