Skocz do zawartości

napiad

Użytkownicy
  • Zawartość

    16
  • Rejestracja

  • Ostatnio

Posty napisane przez napiad

  1. Próbowałem, kopiując w sumie cały kod, tylko przerabiając np. digitalWrite na setBits, tylko też nie działało, dlatego nie wiem w czym rzecz, czy to przy inicjalizacji spi czy gdzie...ale może jeszcze raz spróbuję

    Ok, dzięki, czekam

  2. Okej, ale w takim razie czemu pin jest podpisany RST, a nie CS. A na odwrocie jest coś podpisane CS, tylko nie jako pin, więc zakładałem, że CS nie jest w tym wypadku do sterowania programowo

    Na arduino użyłem tej biblioteki (załącznik) i działało, a tam np. nie używają CS

    IMG_20170410_175211_01.thumb.jpg.7f115c4b4f25a2a454df2564b2bc3355.jpg

    OLED.zip

  3. Właściwie to mam ten: https://sklep.avt.pl/wyswietlacz-oled-0-96-128-64-niebieski-spi.html (na początku myślałem, że są takie same, ale jednak nie do końca)

    tylko teraz który tryb tu jest zdefiniowany opornikami? stawiałbym też na 4spi

    ale ten RST to chyba nie jest chip select, tylko pin do restartu przed inicjalizacją wyświetlacza(?) w tym moim z tyłu jest narysowana ramka z napisanym CS, które jest zwarte do czegoś

  4. Polaryzację i fazę sprawdzałem i wydaje mi się, że jest dobrze (załączam fragment datacheetu). A co do szybkości to próbowałem też wyższe 'baud rate prescalery', więc to chyba nie to.

    Mógłbyś bardziej wytłumaczyć jak to z tym rejestrem? (nie jestem jeszcze w to zbyt biegły)

    Chodzi o rejestr u slave'a? (a odczytać chyba nie mogę, bo 'chyba' obsługuje tylko jednostronną komunikację (bez MISO), chociaż w sumie nie wiem, bo ma tylko piny SCL, SDA, RST, DC).

    Czy taki rejestr mam sprawdzać w stmie jakoś po prostu? I który to mógłby być?

    (Jutro też spróbuję zbadać oscyloskopem, może to coś wykaże)

    CaptureSPI.thumb.JPG.a9dcb7e1c5622389d8b667f69a736050.JPG

  5. Cześć!

    Korzystam z STM32F303RE i chciałem podłączyć do niego wyświetlacz oled na sterowniku SSD1306 (https://botland.com.pl/wyswietlacze-oled/8245-wyswietlacz-oled-niebieski-graficzny-096-128x64px-spii2c.html?search_query=oled&results=25) korzystając ze SPI. Mój kod na obecną chwilę wygląda tak:

    #include "stm32f30x.h"
    
    #define OLED_SCL_Pin GPIO_Pin_5
    #define OLED_SDA_Pin GPIO_Pin_7
    #define OLED_RST_Pin GPIO_Pin_9
    #define OLED_DC_Pin GPIO_Pin_8
    
    
    /* do funkcji delay */
    volatile uint32_t timer_ms = 0;
    
    void SysTick_Handler()
    {
       if (timer_ms) {
           timer_ms--;
       }
    }
    void delay_ms(int time)
    {
       timer_ms = time;
       while(timer_ms > 0){};
    }
    /* wysylanie bajta danych */
    void SPI_SendByte(uint8_t data)
    {
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET); //czeka az bufor bedzie wolny 
    SPI_SendData8(SPI1, data); //wysyla
    }
    
    /* wysylanie komendy do wyswietlacza */
    void OLED_WriteCmd(uint8_t cmd)
    {
    GPIO_ResetBits(GPIOA, OLED_DC_Pin); //DC 0 
    SPI_SendByte(cmd);
    }
    /* wysylanie danych do wyswietlacza */
    void OLED_WriteData(uint8_t data)
    {
    GPIO_SetBits(GPIOA, OLED_DC_Pin); //DC 1
    SPI_SendByte(data);
    }
    
    void OLED_Reset()
    {
    GPIO_ResetBits(GPIOA, OLED_RST_Pin); //RST 0
    delay_ms(50); //odczekanie
    GPIO_SetBits(GPIOA, OLED_RST_Pin); //RST 1
    }
    
    void OLED_Init()
    {	
    OLED_Reset(); //reset
    
    /* sugerowane komendy z user guide'a */
    OLED_WriteCmd(0xAE); //turn off oled panel
    OLED_WriteCmd(0x00); //set low column address
    OLED_WriteCmd(0x10); //set high column address
    OLED_WriteCmd(0x40); //set start line address
    OLED_WriteCmd(0x81); //set contrast control register
    OLED_WriteCmd(0xCF); 
    OLED_WriteCmd(0xA1); //set segment re-map 95 to 0
    OLED_WriteCmd(0xA6); //set normal display
    OLED_WriteCmd(0xA8); //set multiplex ratio(1 to 64)
    OLED_WriteCmd(0x3F); //1/64 duty
    OLED_WriteCmd(0xD3); //set display offset
    OLED_WriteCmd(0x00); //no offset
    OLED_WriteCmd(0xD5); //set display clock divide ratio/oscillator freq
    OLED_WriteCmd(0x80); //set divide radio
    OLED_WriteCmd(0xD9); //set pre-charge period
    OLED_WriteCmd(0xF1); 
    OLED_WriteCmd(0xDA); //set com pins hardware configuration
    OLED_WriteCmd(0x12);
    OLED_WriteCmd(0xDB); //set vcomh
    OLED_WriteCmd(0x40);
    OLED_WriteCmd(0x8D); //set CHarge Pump enable
    OLED_WriteCmd(0x14);
    OLED_WriteCmd(0xAF); //turn on oled panel
    }
    
    int main(void)
    {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
    
    SysTick_Config(SystemCoreClock / 1000);
    
    GPIO_InitTypeDef gpio;
    	gpio.GPIO_Pin = OLED_SCL_Pin | OLED_SDA_Pin;
    	gpio.GPIO_Mode = GPIO_Mode_AF;
    	gpio.GPIO_OType = GPIO_OType_PP;
    	gpio.GPIO_Speed = GPIO_Speed_Level_3;
    	gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(GPIOA, &gpio);
    
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_5);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_5);
    
    	gpio.GPIO_Pin = OLED_RST_Pin | OLED_DC_Pin;
    	gpio.GPIO_Speed = GPIO_Speed_Level_3;
    	gpio.GPIO_Mode = GPIO_Mode_OUT;
    	gpio.GPIO_OType = GPIO_OType_PP;
    	gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(GPIOA, &gpio);
    
    SPI_InitTypeDef spi;
    	SPI_StructInit(&spi);
    	spi.SPI_Direction = SPI_Direction_1Line_Tx;
    	spi.SPI_CPHA = SPI_CPHA_2Edge;
    	spi.SPI_CPOL = SPI_CPOL_High;
    	spi.SPI_DataSize = SPI_DataSize_8b;
    	spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
    	spi.SPI_Mode = SPI_Mode_Master;
    	spi.SPI_NSS = SPI_NSS_Soft;
    	spi.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_Init(SPI1, &spi);
    
    SPI_Cmd(SPI1, ENABLE);
    
    OLED_Init();
    delay_ms(50);
    
    OLED_WriteData(0xFF);
    
    while(1)
    {
    }
    }
    

    Jest dosyć podstawowy i bazuje po części na kursie z forbota i znalezionych rzeczach w internecia, no i na datasheecie, przynajmniej to, co mam nadzieję dobrze zrozumiałem (komendy inicjalizacyjne są również z user guide).

    A jednak wyświetlacz nie reaguje i pozostaje czarny, i nie wiem, w którym miejscu popełniam błąd, a kod nie jest w sumie aż tak skomplikowany. Może ktoś ma jakiś pomysł lub doświadczenie w takim przypadku?

  6. Ah, przypomniało mi się, że miałem się podzielić!

    A więc oto efekty (z których jestem całkiem zadowolony) :

    ale może przybliżę o co w tym chodzi - to ma być takie urządzonko, gdzie silnik będzie po prostu obracał śrubę trapezową, przez co zmieniał wysokość czegoś na tej śrubie trapezowej (jakiegoś czujnika na przykład)

    Najpierw (podczas 'resetu') sprawdzane jest maksymalna możliwa pozycja górna, potem dolna (przez krańcówki) i z tego wychodzi zakres. Do sterowania jest pokrętło z przyciskiem(enkoder), w menu można wybrać zmianę wysokości o 0.1/1/5mm, zobaczyć aktualną pozycję/zakres i włączyć ponownie 'reset'.

    Tę część skończyłem już jakiś czas temu, ale ostatnio postanowiłem pokombinować i spróbować zrobić jeszcze program na PC, który mógłby tym sterować (żeby było wygodniej) i myślę, że wyszedł mi całkiem przyzwoicie. (Szczególnie, że nigdy wcześniej czegoś takiego nie robiłem)

    Jeszcze raz dzięki za wcześniejszą pomoc marek1707, bardzo się przydała! I chętnie usłyszę jakąś opinie/krytykę 😉

  7. O, pewnie! już trochę czytałem (bo nie jest aż tak, że zabieram się z zerową wiedzą, bo zawsze się staram dowiedzieć jak najwięcej zanim czymś się zajmę - po prostu zdecydowanie brakuje mi praktyki i tej technicznej wiedzy (dopiero kończę liceum)), ale na pewno linki się przydadzą !

    Jasne! programu już główny zarys napisałem (tak myślę), tylko nie mam jak sprawdzić błędy w praktyce chwilowo, ale jak dostanę części i uda mi się skutecznie wszystko podłączyć, to na pewno się podzielę 😉

    Tak, to naleśnik, też lubię 😃

  8. Dzięki marek za rzeczową odpowiedź!

    Czyli silnika szukać z niższym napięciem, ale przez to będzie też większy prąd. Może np. taki: http://bit.ly/1RNgtlf (3.6V, 1.2A) (albo unipolarny trochę tańszy http://bit.ly/24HWAmU )

    Tylko wtedy jak to by było z płytką i zasilaczem. Płytka mogłaby być ta: http://bit.ly/1RNgBBj ? czy nie? znaczy jeśli wytrzymuje 1.2 A na cewkę (bez chłodzenia) to z silnikiem pasuje, tylko wtedy czy mogę podłączyć zasilacz (ten 12 voltowy, bo te na wyższe napięcie wydają mi się duużo droższe, z tego, co widzę) tylko np. 1.2A ? bo 2.4 chyba nie? ( http://bit.ly/1QZrBi7 np)

    więc jeśli tylko 1.2A czy to oznacza, że silnik dostanie po 0,6 na cewkę załóżmy? (odjąć zabrane przez sterownik), to jak bardzo będzie miał niższy moment? czy da radę jeszcze wystarczająco dobrze pracować? (bo myślę, że trochę mniejszy moment w razie czego nie byłby taki tragiczny, nic bardzo ciężkiego nie będzie podnosić, tylko takie ramię z jakimiś czujnikami czy coś)

  9. Cześć, po przejściu przez kurs Arduino z forbota chciałem podejść do bardziej samodzielnego projektu i mam nadzieję, że mnie nie przerośnie.

    Tak więc ma to być taki jakby podnośnik na śrubie trapezowej napędzanej silnikiem krokowym.

    Ale przechodząc do chwilowo najbardziej nurtujących mnie wątpliwości, to wybrałem już silnik (ten: http://bit.ly/20qFFjE) oraz do niego driver (ten: http://bit.ly/1TV3Ho2) (ale jeszcze nie kupiłem) i zastanawia mnie zasilanie silnika, ponieważ trochę gubię się w voltach i natężeniach po drodze, a boję się, że mógłbym coś zepsuć.

    Planowałem użyć takiego zasilacza ( http://bit.ly/1p53OBb ) dającego 12V i 1A, przy sterowniku napisane jest, że U od 8 - 35V, a I koło 1A bez chłodzenia może być, więc niby wszystko się zgadza. Tylko silnik (również na 12V) ma dany prąd tylko 0,5A - czy więc mogę tak to zasilanie zastosować?

    (sterownik można podobno regulować, więc czy musiałbym to zrobić, czy da radę bez regulacji?)

    Po drugie czy później używając biblioteki Stepper.h można sterować mając podłączenie od sterownika. Są tam 2 wyjścia step i dir, a wtedy który z pinów w funkcji Stepper(steps, pin1, pin2) jest którym?

    albo czy może spróbować z biblioteką Accelstepper, którą wyszukałem, bo też wydaje się fajna.

    Dzięki z góry za wszelką pomoc,wskazówki,uwagi. Na razie dopiero planuję, bo wolę mieć wszystko jakoś ułożone w głowie, a nawet chciałem spróbować zacząć pisać program, żeby zorientować się czy dam radę to ogarnąć, więc pewnie jakieś pytania się jeszcze pojawią.

  10. Cześć! Dopiero co kupiłem zestaw i powoli sobie próbuję

    (po pierwsze, wielki szacunek za kurs, jest świetnie, więc brnę dalej 😃 )

    Na pewno już były dobre rozwiązania, ale podpinam też swoje

    5.4

    #include <Servo.h> //Biblioteka odpowiedzialna za serwa
    
    Servo serwomechanizm;  //Tworzymy obiekt, dzięki któremu możemy odwołać się do serwa 
    String wpis = "";//wpisana pozycja
    int intwpis = 0;//wpisana pozycja w int
    boolean start = true;//podejście po wpisaniu liczby z 0-180 bądź nie
    void setup() 
    { 
     Serial.begin(9600);
     serwomechanizm.attach(9);  //Serwomechanizm podłączony do pinu 9
    
    } 
    
    void loop() 
    {  
     while (start == true)//kiedy podano liczbe 0-180
     {
       Serial.println("Podaj pozycje, do ktorej serwomechanizm ma sie obrocic (wpisujac liczbe)");
       //po otwarciu programu podaj prośbę o podanie pozycji
       while(Serial.available() == 0)//poczekaj na wpisanie pozycji
       {}
       if(Serial.available() > 0)//jeśli pozycja zostanie wpisana
       {
          wpis = Serial.readStringUntil('\n');//odczytaj pozycje
          intwpis = wpis.toInt();//zamien na typ int
          Serial.println("Wybrana pozycja:");//pokazuje wybraną pozycje
          Serial.println(intwpis);
    
           if((intwpis >= 0) && (intwpis <= 180))//jeśli należy do 0-180
           {
             serwomechanizm.write(intwpis);//wykonaj przesuniecie na dana pozycje
             start = true;//podano prawidlową pozycję
           }
           else//kiedy podano złą pozycję
           {
             Serial.println("Musisz podac liczbe z przedzialu 0 - 180. Sprobuj ponownie!");
             start = false;//podano złą pozycję
           }
         }
       }
     while (start == false)//po podaniu złej pozycji
     { 
       while(Serial.available() == 0)//poczekaj na wpisanie pozycji
       {}
       if(Serial.available() > 0)//jeśli pozycja zostanie wpisana
       {
         wpis = Serial.readStringUntil('\n');//odczytaj pozycje
         intwpis = wpis.toInt();//zamien na typ int
         Serial.println("Wybrana pozycja:");
         Serial.println(intwpis);
         if((intwpis >= 0) && (intwpis <= 180))
         {
           serwomechanizm.write(intwpis);//wykonaj przesuniecie na dana pozycje
           start = true;
         }
         else
         {
           Serial.println("Musisz podac liczbe z przedzialu 0 - 180. Sprobuj ponownie!");
           start = false;  
         }
       }
     }
    }
    

    pewnie można jakoś prościej, ale działa

    5.5

    #include <Servo.h>//biblioteka
    Servo serwomechanizm;//obiekt - serwo
    #define potencjometr A5
    int odczytPotencjometru;
    int odczytPrzeskalowany;
    void setup() {
     serwomechanizm.attach(9);
    }
    
    void loop() {
     odczytPotencjometru = analogRead(A5); //odczytujemy wartość napięcia
     odczytPrzeskalowany = map(odczytPotencjometru, 0, 1023, 0, 180);
     //przeskalowujemy odczytaną wartość na liczby 0-180 ~ pozycję serwo
     serwomechanizm.write(odczytPrzeskalowany); //ustawiamy serwo w wybranej pozycji
     delay(100); //małe opóźnienie
    }
    

    a tak poza tym to jeszcze pytanko:

    na obrazkach widziałem, że ze stabilizatorem zazwyczaj były podpinane dwa kondensatory bezbiegunowe

    w swoim zestawie dostałem tylko jeden taki (ten pomarańczowy mały okrągły) i drugi biegunowy; podłączyłem je i działa, tylko nie wiem czy "lepiej" by było dwa takie same czy jak to zmienia sytuację?

    (zielony jestem w elektronice praktycznej jakby co 😉

×
×
  • Utwórz nowe...

Ważne informacje

Ta strona używa ciasteczek (cookies), dzięki którym może działać lepiej. Więcej na ten temat znajdziesz w Polityce Prywatności.