Skocz do zawartości

davidpi

Użytkownicy
  • Zawartość

    240
  • Rejestracja

  • Ostatnio

  • Wygrane dni

    5

davidpi wygrał w ostatnim dniu 21 grudnia 2013

davidpi ma najbardziej lubianą zawartość!

Reputacja

32 Bardzo dobra

O davidpi

  • Ranga
    5/10

Informacje

  • Płeć
    Mężczyzna
  • Lokalizacja
    Kielce
  1. Sprowadziłem problem do prostego przypadku. Jeden master i dwa układy slave. Master wysyła dane bez DMA. Układy slave odbierają za pomocą DMA i wysyłają za pomocą DMA. Aby było łatwo analizować master nadaje kolejno w pętli for liczby od 1 do 50 z 10ms odstępami. Prędkość ustawiona na podzielnik przez 256. Układy slave odbierają dane do bufora, który następnie podglądam sobie w STMStudio. Jednocześnie układy slave nadają liczby od 10 do 1 z bufora 10-elementowego. Problem wygląda następująco. Jeżeli komunikacja odbywa się tylko od mastera do slava to wszystko działa znakomicie, nawet przy kilku układach slave. Dane, które trafiają do slava są OK. Również gdy układ slave nadaje, ale tylko zera (czyli pewnie linia MISO jest ciągle w stanie niskim) dane trafiające do slava są OK. Natomiast jeżeli układ slave nadaje jekieś dana inne niż zera to dane które przychodzą do slava są zakłócone. Czy ktoś z Was spotkał się z czymś takim? Sprawdźcie, proszę, moją inicjalizację SPI w obu układach. Testowałem to zarówno na docelowych płytkach jak i na Discovery i efekt taki sam. Kod dla mastera static void COM_SPIConf(void) { GPIOB->MODER |= GPIO_MODER_MODER12_0; GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR12_1; GPIOB->PUPDR |= GPIO_PUPDR_PUPDR12_0; GPIOD->MODER |= GPIO_MODER_MODER8_0 | GPIO_MODER_MODER9_0 | GPIO_MODER_MODER10_0 |GPIO_MODER_MODER11_0; GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR8_1 | GPIO_OSPEEDER_OSPEEDR9_1 | GPIO_OSPEEDER_OSPEEDR10_1 | GPIO_OSPEEDER_OSPEEDR11_1; GPIOD->PUPDR |= GPIO_PUPDR_PUPDR8_0 | GPIO_PUPDR_PUPDR9_0 | GPIO_PUPDR_PUPDR10_0 | GPIO_PUPDR_PUPDR11_0; GPIOB->MODER |= GPIO_MODER_MODER13_1 | GPIO_MODER_MODER14_1 | GPIO_MODER_MODER15_1; GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR13_1 | GPIO_OSPEEDER_OSPEEDR14_1 | GPIO_OSPEEDER_OSPEEDR15_1; GPIOB->AFR[1] |= 0x55500000; SPI2->CR1 |= SPI_CR1_BR | SPI_CR1_SSM | SPI_CR1_SSI | SPI_CR1_MSTR | SPI_CR1_SPE; SPI_CSALLOFF; } static void SPI_Send(uint8_t data) { while (!(SPI2->SR & SPI_SR_TXE)){;} SPI2->DR = data; while ((SPI2->SR & SPI_SR_BSY)){;} } static void COM_SelectDrive(uint8_t n) { switch(n) { case 0: SPI_CS0ON; break; case 1: SPI_CS1ON; break; case 2: SPI_CS2ON; break; case 3: SPI_CS3ON; break; case 4: SPI_CS4ON; break; default: break; } } static void COM_SendToOneDrive(uint8_t n) { delay_ms(10); COM_SelectDrive(n); for(uint32_t i=1;i<=50;i++) { SPI_Send(i); delay_ms(10); } SPI_CSALLOFF; } void COM_SendToDrives(void) { for(uint8_t i=0;i<5;i++) COM_SendToOneDrive(i); } Kod dla slava uint8_t b1[]={10,9,8,7,6,5,4,3,2,1}; uint8_t b2[55]; static void COM_SPIConf(void) { DMA1_Stream3->PAR = (uint32_t)&SPI2->DR; DMA1_Stream3->M0AR = (uint32_t)b2; DMA1_Stream3->NDTR = (uint16_t)55; DMA1_Stream3->CR = DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_EN; DMA1_Stream4->PAR = (uint32_t)&SPI2->DR; DMA1_Stream4->M0AR = (uint32_t)b1; DMA1_Stream4->NDTR = (uint16_t)10; DMA1_Stream4->CR = DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_DIR_0 | DMA_SxCR_EN; GPIOB->MODER |= GPIO_MODER_MODER12_1 | GPIO_MODER_MODER13_1 | GPIO_MODER_MODER14_1 | GPIO_MODER_MODER15_1; GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR12_1 | GPIO_OSPEEDER_OSPEEDR13_1 | GPIO_OSPEEDER_OSPEEDR14_1 | GPIO_OSPEEDER_OSPEEDR15_1; GPIOB->AFR[1] |= 0x55550000; SPI2->CR2 |= SPI_CR2_RXDMAEN; SPI2->CR2 |= SPI_CR2_TXDMAEN; SPI2->CR1 |= SPI_CR1_SPE; }
  2. Cześć. Potrzebuję Waszej pomocy w takiej sprawie. Mam dwa mikrokontrolery STM32F407VGT6 komunikujące się po SPI. W obydwu korzystam z SPI2. W układzie slave odbiór danych zrealizowany jest za pomocą DMA w trybie circular. DMA wrzuca dane do bufora kołowego. Wysyłanie ze slava również zrobione za pomocą DMA w trybie circular z osobnym buforem. Co jakiś czas zaglądam do bufora odbiorczego i sprawdzam czy są tam jakieś dane. Oraz co jakiś czas wrzucam do bufora nadawczego dane do wysłania. Układ master ma możliwość podłączenia 5 układów slave. Na razie testowałem tylko z jednym. W układzie master nadawanie jest zrobione bez DMA i bez przerwań, natomiast odbiór zrobiony jest z DMA i buforem kołowym, tak jak w układzie slave. I teraz na czym polega problem: Cała komunikacja jest ustawiona na full duplex. Ale jeżeli układ slave nic nie wysyła, lub jego bufor nadawczy jest pusty (same znaki NULL) to wszystko działa OK. Natomiast jeżeli slave zacznie coś wysyłać to jednocześnie dana przychodzące do niego zaczynają być zakłócane i komunikacja zaczyna szwankować. Czy ktoś z Was miał podobny problem?. Sprawdźcie, proszę, czy mój kod jest sensowny i czy w ogóle takie podejście do tej komunikacji jest sensowne. Poniżej kody dla slava i mastera. Całość pisana w Keil uVision. Oczywiście taktowanie dla wszystkich układów włączone. Procesor pracuje na 168MHz. Problemy występują niezależnie od prędkości SPI. SPI na porcie B na pinach PB12 do PB15. Układ slave: static void COM_SPIConf(void) { DMA1_Stream3->PAR = (uint32_t)&SPI2->DR; DMA1_Stream3->M0AR = (uint32_t)pC->bufread.buf; DMA1_Stream3->NDTR = (uint16_t)BUFR_LEN; DMA1_Stream3->CR = DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_EN; DMA1_Stream4->PAR = (uint32_t)&SPI2->DR; DMA1_Stream4->M0AR = (uint32_t)pC->bufwrite.buf; DMA1_Stream4->NDTR = (uint16_t)BUFW_LEN; DMA1_Stream4->CR = DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_DIR_0 | DMA_SxCR_EN; GPIOB->AFR[1] |= 0x55550000; GPIOB->MODER |= GPIO_MODER_MODER12_1 | GPIO_MODER_MODER13_1 | GPIO_MODER_MODER14_1 | GPIO_MODER_MODER15_1; GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR12 | GPIO_OSPEEDER_OSPEEDR13 | GPIO_OSPEEDER_OSPEEDR14 | GPIO_OSPEEDER_OSPEEDR15; SPI2->CR2 |= SPI_CR2_RXDMAEN | SPI_CR2_TXDMAEN; SPI2->CR1 |= SPI_CR1_CPHA | SPI_CR1_SPE; } void ClearStr(char* str, uint32_t l) { for(uint32_t i=0;i<l;i++) str[i] = '\0'; } static void Mot_Send(void) { ClearStr(pC->bufwrite.buf, BUFW_LEN); int32_t x[7]={0,0,0,0,0,0,0}; x[0] = 1; x[1] = pC->Mot[0].pos*10000; x[2] = pC->Mot[0].current*10000; x[3] = 2; x[4] = pC->Mot[1].pos*10000; x[5] = pC->Mot[1].current*10000; for(uint16_t i=0;i<6;i++) x[6] += x[i]; sprintf(pC->bufwrite.buf, "$%d %d %d %d %d %d %d*", x[0],x[1],x[2],x[3],x[4],x[5],x[6]); } void COM_Read() { LED3_OFF; char buf[BUFR_LEN], c=0x00; uint16_t j=0, cnt1=0, cnt2=0; eOnOff frame = Off; for(uint16_t i=0;i<BUFR_LEN;i++) { c = pC->bufread.buf[i]; if(c == '$') { ClearStr(buf, BUFR_LEN); frame = On; j=0; cnt1 = i; } else if(frame == On && c != '*') buf[j++] = c; else if(c == '*' && frame == On) { cnt2 = i; a++; int32_t x[3] = {0,0,0}; sscanf(buf, "%d %d %d", &x[0], &x[1], &x[2]); if(x[2] == (x[0]+x[1])) { b++; a--; LED3_ON; pC->Mot[0].posref = (float)x[0]/10000.0f; pC->Mot[1].posref = (float)x[1]/10000.0f; pC->tick = 0; for(uint16_t k=cnt1; k<cnt2; k++) pC->bufread.buf[k] = 0x00; frame = Off; } } } } Kod dla mastera static void COM_SPIConf(void) { DMA1_Stream3->PAR = (uint32_t)&SPI2->DR; DMA1_Stream3->M0AR = (uint32_t)pC->bufread.buf; DMA1_Stream3->NDTR = (uint16_t)BUFR_LEN; DMA1_Stream3->CR |= DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_EN; GPIOB->MODER |= GPIO_MODER_MODER12_0; GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR12; GPIOB->PUPDR |= GPIO_PUPDR_PUPDR12_1; GPIOD->MODER |= GPIO_MODER_MODER8_0 | GPIO_MODER_MODER9_0 | GPIO_MODER_MODER10_0 |GPIO_MODER_MODER11_0; GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR8 | GPIO_OSPEEDER_OSPEEDR9 | GPIO_OSPEEDER_OSPEEDR10 | GPIO_OSPEEDER_OSPEEDR11; GPIOD->PUPDR |= GPIO_PUPDR_PUPDR8_1 | GPIO_PUPDR_PUPDR9_1 | GPIO_PUPDR_PUPDR10_1 | GPIO_PUPDR_PUPDR11_1; GPIOB->AFR[1] |= 0x55500000; GPIOB->MODER |= GPIO_MODER_MODER13_1 | GPIO_MODER_MODER14_1 | GPIO_MODER_MODER15_1; GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR13 | GPIO_OSPEEDER_OSPEEDR14 | GPIO_OSPEEDER_OSPEEDR15; SPI2->CR2 |= SPI_CR2_RXDMAEN; SPI2->CR1 |= SPI_CR1_BR_1 | SPI_CR1_SSM | SPI_CR1_SSI | SPI_CR1_MSTR | SPI_CR1_CPHA | SPI_CR1_SPE; SPI_CSALLOFF; } void ClearStr(char* str, uint32_t l) { for(uint32_t i=0;i<l;i++) str[i] = '\0'; } static void COM_SendToOneDrive(uint8_t n) { ClearStr(pC->bufwrite.buf, BUFW_LEN); int32_t x[3]; x[0] = pC->Mot[0].posref*10000; x[1] = pC->Mot[1].posref*10000; x[2] = x[0]+x[1]; sprintf(pC->bufwrite.buf, "$%d %d %d*", x[0],x[1],x[2]); COM_SelectDrive(n); for(uint32_t i=0;i<BUFW_LEN;i++) SPI_Send(pC->bufwrite.buf[i]); SPI_CSALLOFF; } void COM_SendToDrives(void) { for(uint8_t i=0;i<5;i++) COM_SendToOneDrive(i); }
  3. Jeszcze raz dzięki za zainteresowanie. Lubię gdy odpisujesz na moje posty. Zawsze wtedy uświadamiam sobie jak mało jeszcze wiem o elektronice Układ ten ma być czymś w rodzaju uniwersalnego sterownika albo karty pomiarowej. Jego pierwszym zastosowaniem będzie sterowanie zaworami pneumatycznymi za pomocą napięcia 0-10V. Oraz obsługa czujników RS422 i generowanie napięcia 0-10V proporcjonalnie do odczytu z czujników. Napięcie to trafi na kartę pomiarową systemu czasu rzeczywistego firmy Speedgoat. Karta ta ma rozdzielczość 16bit. Nie mogę do niej podłączyć bezpośrednio czujników, bo ma ona tylko wejścia i wyjścia analogowe. Chciałbym uzyskać realnie dokładność na poziomie 10mV dla zakresu 0-10V, o ile to w ogóle możliwe. Całość będzie zasilana z zasilacza laboratoryjnego lub z akumulatorów. Chciałbym mieć również możliwość generowania i pomiaru napięć ujemnych. Zakres -10V do 10V. Odnośnie schematu to chyba lepiej będzie jak zacznę projektować od nowa, uwzględniając Twoje uwagi, zamiast poprawiać istniejący. Zatem pozwolę sobie dopytać Cię o więcej szczegółów. Ad1. Całość będę próbkował maksymalnie 50kHz. Na więcej i tak pewnie nie pozwoli mi speedgoat. Co znaczy buforowanie sygnału analogowego? Jak to zrealizować? O ochronie ESD całkowicie zapomniałem. Czy do ochrony EMI wystarczą kondensatory do masy? Ad2. Ten ADC został wybrany właściwie tylko dlatego, że potrzebuję 12 kanałów. Więc dwa scalaki po sześć. Nie mam wymagań krytycznych co do tego aby pomiar był robiony równolegle na wszystkich kanałach. Natomiast rozdzielczość 16 bit ponieważ nasze karty taką maja. Ad3. Rozumiem, że przetwornica odpada. Poszukam jakiegoś rozwiązania bez gotowych przetwornic. Ad4. To oczywiście zamierzony błąd. Za dławikiem nadal jest 24V. Potrzebowałem innego symbolu, bo napięcie za dławikiem ma zasilać część analogową. Ad5. Tutaj oczywiście jest tak samo. zwykłe 5V powstaje na przetwornicy i służy do zasilania procesora. A 5V/2 powstaje na LM7805 i ma służyć do zasilania układów analogowych. Ad6. Zasilanie tylko dwóch układów ADC. Prąd w sumie to 60mA. Moc dla 24V to ok 1.14W Ad7. Hmm nie wiem jak policzyć ten prąd. Nie wiem jaki prąd pobierają ADC i DAC ze źródła referencyjnego. Co to za skrót ppm? Czy to jest part per milion? Czy to oznacza jedną milionową część nominalnego napięcia wyjściowego(2.5V/1000000)? Ad8. Zadbam o to w następnych schematach. Ad9. Czy pytasz o interfejsy cyfrowe układów ADC i DAC? Wszystko będzie na jednej płytce PCB. A więc kilka do kilkunastu cm. Całość będzie sterowana z STM32F4 DISCOVERY. Faktycznie zapomniałem o podciągnięciu linii. I znowu muszę zapytać o co chodzi z buforowaniem? Ad10. Chyba faktycznie nie ma możliwości pracy unipolarnej. Duży błąd z mojej strony. Ad11. Chciałem zrobić taką sztuczkę, aby wybierać tryb pracy bipolary lub unipolarny. Po to aby dla unipolarnego 0-10V mieć pełne 16bit, a nie tylko połowę z tego zakresu. Czy w ogóle jest możliwość takiego przełączania.
  4. Witam. Chciałbym prosić o sprawdzenie kilku rzeczy na schemacie, który udało mi się popełnić. Układ ma być sterownikiem z 12 wyjściami analogowymi i 12 wejściami analogowymi. Oraz możliwością podłączenia 8 enkoderów w standardzie napięć RS422. 1. Do płytki ma być podłączone 8 czujników. Chciałbym prosić o sprawdzenie układów do konwersji na standard RS422 (MAX485 lub zamienniki) z interfejsem SSI. Czy mogę wszystkie 8 czujników taktować jednym sygnałem zegarowym? Czy oporniki przy tych układów mają dobre wartości? 2. Czy dobrze zaprojektowałem tor zasilania? Całość zasilana z 24V z zasilacza laboratoryjnego. Za dławikiem jest wykorzystywane do zasilania części analogowej, a sprzed dławika do zasilania części cyfrowej. Czy przetwornica do generowania napięcia symetrycznego jest dobrze podłączona? Czy powinienem jeszcze jakoś zadbać bardziej o filtrację zasilania? 3. Czy przetworniki ADC i DAC wymagają jeszcze jakich zabiegów, czy można uznać je za podłączone poprawnie? 4. Chciałbym za pomocą zworki JP2 podłączać do wejść VSS w przetwornikach naprzemiennie masę i -12V. Czy może to być zrealizowane w ten sposób? Z góry dziękuję i pozdrawiam. PS. Schemat w załączniku, bo nie mogę dodać zdjęcia. Jeżeli się uda to wrzucę również zdjęcie. PS2 Już udało mi się dodać zdjęcie. Wyciąłem najważniejszy fragment bo chyba plik był zbyt duży. untitled.sch
  5. Bardzo fajnie CI to wyszło. Próbowałeś rysować mozaikę ścieżek na laminacie, aby wykonać jakąś PCB? Jak z dokładnością urządzenia?
  6. Biorąc pod uwagę to co powiedział marek1707 duza lepsza byłaby gąsienica zrobiona z takiego paska. http://www.cncland.pl/pasy-obustronnie-zebate No i oczywiście dołożenie kilku kół dociskowych wzdłuż gąsienicy.
  7. Oczywiście mówię tutaj o manipulatorze równoległym 6DOF. Nie mam na myśli delty 3DOF z nabudowanymi stopniami na platformie. Da się rozbić taki manipulator na niezależne ramiona. Pozycja i orientacja platformy definiują jej ułożenie w przestrzeni, a więc mamy jasno określone gdzie kończą się ramiona. I wtedy każde ramię jak manipulator szeregowy z notacji DH. Popełniłem takie coś na moją magisterkę https://www.forbot.pl/forum/topics7/manipulator-platforma-stewarta-vt7761.htm Właśnie zrobiłem w ten sposób, bo nie miałem koncepcji jak zrobić cały manipulator z zależności geometrycznych. Nie wiem czy w ogóle się da.
  8. No tak, ale jak wyprowadzić z zależności geometrycznych dla delty 6DOF?? Mnie się nie udało jej zrobić bez notacji DH.
  9. Pytam, ponieważ ciekawi mnie czy robiłeś te równania z zależności geometrycznych, czy stosując notację Denavitta-Hartenberga. A co za tym idzie czy w efekcie musisz rozwiązywać układy równań??
  10. Bardzo fajna konstrukcja. Kawał dobrej roboty. Mam pytanie odnośnie kinematyki i sterowania. Czy równania wyprowadzałeś sam, czy stosowałeś jakiś robotic toolbox w matlabie?? Rozumiem, że podczas sterowania ta kinematyka jest w czasie rzeczywistym przeliczana. Czy robi to Twój sterownik, czy jest to robione z poziomu PC, matlaba?
  11. Witam. Potrzebuję pomocy przy schemacie mostka H. Sygnały sterujące kierunkiem idą z procesora na ULN, który odpala górne mosfety typu P. Natomiast PWM idzie prosto z procesora na mosfet typu N. Czy ten schemat ma szansę zadziałać?? Całość będzie zasilana z lipola 4S. Pobór prądu maksymalnie 30A. Układ ten zlutowałem, ale podczas testów upaliłem ULN i jeden tranzystor. I już nie wiem czy to wina schematu, czy błędy podczas lutowania. Silnik jest zabezpieczony transilem, warystorem i kondensatorem przylutowanymi przy samym silniku. Z góry dziękuję za pomoc.
  12. Pomyśl przez chwilę. Nie znalazłeś nigdzie rozwiązania ponieważ dla robota kartezjańskiego się czegoś takiego nie rozwiązuje. Ponieważ ten robot zawsze pracuje tylko we współrzędnych kartezjańskich. Więc przeliczanie z kartezjańskich na kartezjańskie nie ma sensu. Do czego Ci to w ogóle potrzebne??
  13. Podając Ci linka sądziłem, że się do nich odezwiesz z zapytaniem. Na pewno dostałbyś jakąś ofertę. Tu jest jeden z silników sprzedawanych przez firmę na którą dałem Ci namiary. http://allegro.pl/silnik-z-przekladnia-planetarna-63-obr-min-12v-i4309074084.html Ewentualnie odezwij się do nich. Dostaniesz pełny katalog i na pewno coś sobie wybierzesz. Ja dzisiaj od nich kupiłem sześć silników do łazika marsjańskiego.
×
×
  • Utwórz nowe...