cnc.info.pl - FORUM CNC

tuxcnc pisze:ktoś wyjaśni sens ekonomiczny tego przedsięwzięcia ...

Sens ekonomiczny? Ma dla ciebie znaczenie czy bułka jest za 50gr lub 60gr? Kupujesz tańszą czy smaczniejszą?

No, są tacy co na przykład rżną tytoń i odkrywają w tym sens ekonomiczny.... ich wolna wola. Jak się nie wchłania osobiście wytworzonego dymu i nie pije ogłupiaczy, to jest kasa na coś innego. Gdy się ma przewagę przychodów nad wydatkami i przyjemność odkrywa w rzeczach prostych i dostępnych, to można

.

Ja kupuję gotowe zabawki i składam z tego coś, co robi to co wymyśliłem. Ostatnio testuję manipulatorek za 3$, i czujnik ruchu za 4$ (przykładowe zastosowanie). Od pomysłu do wykonania nie ma lutowania.

Widzę, że te płytki http://www.shop.kristech.eu/product_inf ... cts_id=336
bardziej dostosowane są do aplikacji przemysłowych niż "zwykłe" arduino:

na stronie kristech.eu - pisze:zasilanie napięciem stałym od 9 do 30V DC co umożliwia podłączenie wiele różnych zasilaczy,
również standardowego napięcia 24V stosowanego w aplikacjach przemysłowych,
płytka posiada możliwość zamontowania dodatkowego precyzyjnego źródła napięcia odniesienia dla części analogowej
płytka została tak zaprojektowania aby była odporna na zakłócenia

https://www.olimex.com/dev/DUINO/OLIMEX ... NO-328.pdf
https://www.olimex.com/dev/olimexino-328.html
Dla początkujących utrudnienie - programator trzeba mieć.
Z drugiej strony jest też możliwość przejścia na coś szybszego:

[youtube][/youtube]

Ten wyświetlacz z przyciskami można kupić stąd: http://dx.com/p/jy-mcu-8x-red-light-dig ... 4?item=247 - nad 8 przyciskami ma dwukolorowe diody.

markcomp77 pisze:czas trwania impulsu STEP wychodzi 5.2us (mierzone)

Da się takie rzeczy pomierzyć jakąś tanią metodą? Na przykład: wiem, że impuls szybko osiąga 5V. Podłączam kondensator xx pF lub xnF, który gromadzi ładunek i załączy jakiś układ gdy czas trwania impulsu będzie większy niż np. 1us i ten czas dałoby się regulować jakimś precyzyjnym potencjometrem? Układem wzorcowym kalibrowałoby się punkt graniczny i potem sprawdzanie czasu impulsu. Kilka prób i wiem jaki jest czas impulsu.

Chodziło mi o płynność działania programu. To co zrobiłem jest jeszcze wrażliwe na czas wykonania operacji arytmetycznych. Zakończenie pętli, instrukcje przed pętlą, dodatkowe instrukcje przy spełnieniu jakiegoś warunku mogą wydłużyć przerwę między krokami i rampa przestaje być gładka. Trzeba na niższym poziomie kontrolować czas. delayMicroseconds() ma ograniczenie do 16383 i przy wolniejszej jeździe trzeba dołożyć użycie delay() lub oprzeć się na millis() i mocros().

Przydałoby się sprawdzić jak wygląda cała rampa przy pomocy jakiejś szybkiej akwizycji danych. Dla mnie to co już mam na ucho jest ok.

Przy okazji testów przyłapałem sterownik silnika krokowego (albo to sam silnik tak ma?) na jakieś stuki (200 cichych "tupnięć" na obrót) na każdy fizyczny krok niezależnie od ustawionego mikrokoku. Ciekawe czy są silniki krokowe lepsze i znacznie gorsze w danej serii biorąc pod uwagę płynność ich pracy przy wysokich mikrokokach.

Gdyby ktoś potrzebował bardzo ładnej delikatnej dłuuugiej rampy, to tak wygląda gotowiec z użyciem AccelStepper.

Kod: Zaznacz cały

#include <AccelStepper.h> 
// pobierz i wgraj do libraries stąd: 
// http://www.open.com.au/mikem/arduino/AccelStepper/
// 

AccelStepper osX(1, 6, 5);  //   pin 6 - STEP, pin 5 - DIR
int goX = 16000;                //   idź do wsp. X
int ile = 1; 
void setup() {  
  osX.setMaxSpeed(10000);    // do pierwszej próby długiej rampy daj: 1000  
  osX.setAcceleration(1500);  // oraz maleńkie przyspieszenie: 10 i mikrokrok 16.
} 

void loop(){ 
  if (osX.distanceToGo() == 0) { 
  //  idź do współrzędnej po przeciwnej stronie początku układu wsp.
    goX = -goX; 
    osX.moveTo(goX); 

    for (int k=1; k < ile ; k++) { delay(200); } ; 
    ile = int ( ile * 5 / 4 ) + 1; // wydłużacz przerw między ruchami w lewo i w prawo.
  } 
  osX.run(); 
}

Jak zwykle ciekawość, bo "procesor" jest od tego żeby pracował.

Yogi_ pisze: Rampa/2 - jakiś_procent?
Znaczy jest tak /\ a sztucznie robimy tak /-\ (nie ma górnej kreski)? Żeby nie przekombinować i używać takich samych obliczeń?

Zgadza się, kroki/2 minus kilka sztuk na wykonanie poziomu. Wystarczy jedna instrukcja warunkowa zatrzymująca dalsze przyspieszanie w części startowej. W niektórych przypadkach ryzykuje się jednak dużym zrywem.

Film z tą nową rampą: http://youtu.be/9pyRgWdDvBE dla współczynnika łagodności 18 i od pierwszego kroku poniżej 0.5 obr/min.
Algorytm wymyśliłem sam na podstawie doświadczeń z poprzednimi wersjami i przemyśleń nad rampami w programach, które używam do sterowania maszynami (nie tylko cnconv).
Pierwszy sposób skojarzyłem ze sklejaniem funkcji. W kolejnych skorzystałem z różnych sugestii, o których piszę na forum lub zamieściłem w arkuszu kalkulacyjnym. Dla lepszego zrozumienia rampy osie poziome powinny być czasem nie krokiem. Można te przyspieszenia kątowe przeliczyć sobie na przyspieszenia liniowe dla danego układu i wyliczyć siłę bezwładności i moment bezwładności. Może w kolejnej wersji.

Które przeliczenia są szybsze jeszcze nie wiem.

Rampy w Arduino ciąg dalszy.
Tym razem inna prosta metoda i szybka rampa bez zbędnego bujania się na małej prędkości. W rampie są oba przegięcia, o których była wcześniej mowa. Do funkcji wykonującej rampę podaję trzy parametry:

przerwa_startowa - np. 10000 mikrosekund - odpowiada to około 4 obr/minutę
przerwa_przelotu - np. 50 mikrosekund - ponad 600 obr/minutę
wspolczynnik_lagodnosci - liczba całkowita od 3 (ostro) do 8 (łagodnie)

Przerwę między krokami zmniejszam zaczynając od przerwy startowej o wartość wyliczoną wzorem:

int ( aktualna_przerwa - przerwa_przelotu ) / wspolczynnik_lagodnosci ) + 1

aż do osiągnięcia przerwy równej przerwie przelotu.

Obliczenia i wykres prędkości i przyspieszeń tutaj: rampa5.ods.
Rampa jest symetryczna - przerwy podczas startu są zapamiętywane w tabeli przerw i przy lądowaniu odtwarzane.

Kod: Zaznacz cały

// rampa metodą podziału przez n
void rampan(int steps, int NN, int usmax, int usmin){ 
         // steps - liczba krokow do wykonania 
         // NN    - parametr podziału, od 3 do 8, 8 - lagodnie, 3 ostro
         // usmax - przerwa us przy maksymalnej prędkości 
         // usmin - przerwa us przy najmniejszej prędkości 
  int przerwa = usmin;               // przerwa początkowa
  int poziomo ;                      // licznik kroków na pełnej prędkości  
  int licznik=0;                     // licznik elementów tabeli przerw
  int pip = 20;                      // 20us - impuls step
  int dir = (steps > 0)? HIGH:LOW;   // 
  steps = abs(steps);                // wyciągnięcie kierunku z podanej liczby kroków.
  digitalWrite(DIR_PIN,dir);         // ustaw kierunek
   //  start rampy
   do { 
    licznik = licznik + 1; 
    przerwa = przerwa - int(( przerwa - usmax ) / NN) - 1 ; 
    if ( przerwa < usmax ) { przerwa = usmax ; } ; 
    tabela[licznik] = przerwa ; 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(pip); 
    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(przerwa); 
  } while(przerwa > usmax) ; 
    // jazda na pełnej prędkości
    poziomo = steps - 2 * licznik;    
    przerwa=usmax; 
    for(int FF = 1; FF  <  poziomo ; FF++ ){ 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(pip); 
    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(przerwa); 
   }  
  // pętla hamowania
    for(int KK = licznik; KK > 1 ; KK-- ){ 
    przerwa=tabela[KK]; 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(pip); 
    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(przerwa); 
  } 
}

przykładowe użycie:

Kod: Zaznacz cały

    rampan(-1600, 8, 100, 10000); 
    rampan(1600, 8, 100, 10000);

Pełny gotowy kod w załączonym arkuszu kalkulacyjnym: rampa5.ods.
Brakuje jedynie sprawdzenia "czy warto się rozpędzać" gdy podana liczba kroków jest za mała do wejścia na pełne obroty.
Tym razem nie ma co filmować i pokazywać, bo szybko wchodzi na obroty i hamuje.
Ta krótka rampa może być przydatna do wykonywania silnikiem szybkich ruchów po zastąpieniu delayMicroseconds obsługą timera.
Przy współczynniku łagodności 12 wychodzi 80 kroków:

Wykres przedstawia unormowaną prędkość i przyspieszenie. Patrząc od prawej do lewej, schody na przyspieszeniu są związane ze zmianą przerwy między krokami kolejno o 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6 itd..

Korzystając z porady Yogi_ zrobiłem arkusz z kombinacją instrukcji warunkowych i dodawania na liczbach całkowitych (czas między krokami w mikrosekundach): rampa4.ods (wykres na przykładzie hamowania).

Kod: Zaznacz cały

// rampa opracowana metodą przyrostu przyrostu
void ramppp(int steps, int KR1, int KR2, int KR3, int usmax, int usmin){ 
  int przerwa=0;                     //
  int PR=0;                          // przyrost
  int pip = 20;                      // 20us - impuls step
  int dir = (steps > 0)? HIGH:LOW; 
  steps = abs(steps);                // wyciągnięcie kierunku z podanej liczby kroków.
  digitalWrite(DIR_PIN,dir);         // ustaw kierunek
  
  // pętla przyspieszanie
  int poziomo = steps - 2 * (KR3 + 4 * KR1 + 2 * KR2) ; 
  PR = 0; 
  for(int KR = 1; KR < (KR3 + 4 * KR1 + 2 * KR2); KR++){ 
    PR = PR + 1;                                    // etap1
    if ( KR > KR1 ) {PR = PR + 1 ; } ;                 // etap2
    if ( KR > ( KR1 + KR2) ) {PR = PR + 1 ; } ;          // etap3
    if ( KR > ( 2 * KR1 + KR2 ) ) {PR = PR + 1 ; } ;       // etap4
    if ( KR > ( 2 * KR1 + KR2 + KR3 ) ) {PR = PR + 1 ; } ;   //etap5
    if ( KR > ( 3 * KR1 + KR2 + KR3 ) ) {PR = PR + 1 ; } ;     //etap6
    if ( KR > ( 3 * KR1 + 2* KR2 + KR3 ) ) {PR = PR + 1 ; } ;    //etap7
    przerwa = usmin - PR ; 
    if ( przerwa < usmax ) { przerwa = usmax ; } ; 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(pip); 
    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(przerwa); 
  }   
    
  // jazda na pełnej prędkości
    for(int FF = 1; FF < poziomo ; FF++ ){ 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(pip); 
    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(przerwa); 
   }  

  // pętla hamowania
  PR = 0; 
  for(int KR = 1; KR < (KR3 + 4*KR1 + 2*KR2); KR++){ 
    PR = PR + 1;                                    // etap1
    if ( KR > KR1 ) {PR = PR + 1 ; } ;                 // etap2
    if ( KR > ( KR1 + KR2) ) {PR = PR + 1 ; } ;          // etap3
    if ( KR > ( 2 * KR1 + KR2 ) ) {PR = PR + 1 ; } ;       // etap4
    if ( KR > ( 2 * KR1 + KR2 + KR3 ) ) {PR = PR + 1 ; } ;   //etap5
    if ( KR > ( 3 * KR1 + KR2 + KR3 ) ) {PR = PR + 1 ; } ;     //etap6
    if ( KR > ( 3 * KR1 + 2* KR2 + KR3 ) ) {PR = PR + 1 ; } ;    //etap7
    przerwa = PR + usmax ; 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(pip); 
    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(przerwa); 
  }

przykładowe użycie:

for (int k =1; k<20 ; k++){
ramppp(-10000, k* 60, 0, 200, 500, 1000);
ramppp(10000, k* 60, 0, 200, 500, 1000);
}

Jest jeszcze parę drobnych błędów (liczba kroków całej rampy i brak wyliczenia prędkości startu) z powodu których działa dobrze tylko hamowanie:

http://youtu.be/vahPeqZsCB0

Wcześniej były zbyt duże uderzenia na początku rampy hamowania i końcu przyspieszania:

http://youtu.be/Q-80IXh8vf4

Do mnie dotarł już modulik STM32F4 DISCOVERY.

Taki ładny, że chyba będę musiał zrobić przezroczystą obudowę z plexy ciętej laserem.

Czas to nie pieniądz - to życie!

Do linków o rampie dorzucam przykład użycia funkcji sklejanych:

https://github.com/kerinin/arduino-splines
https://github.com/kerinin/arduino-thermostat

http://en.wikipedia.org/wiki/Spline_%28mathematics%29
http://en.wikipedia.org/wiki/Spline_interpolation

Trochę to skomplikowane i dużo liczenia, ale może być użyteczne.
Na początek ograniczyłem się do tego:

$Obrazek$

to jest krzywa podobna do rozkładu normalnego: http://pl.wikipedia.org/wiki/Rozk%C5%82ad_normalny

i z tego:

można zrobić to:

jako krzywą przyrostu wygładzonej rampy z dwoma przegięciami.
Tu pierwsza niedokończona próba: rampa3.ods zatrzymałem się na adaptacji wzoru.
Dalej z tym ruszę za kilka dni.

Dzięki, niestety i tak ten sposób na górce rampy nie daje łagodnego przejścia na stałą prędkość.
Próbuję teraz zrobić zmienne przyrosty, w arkuszu już działa ale z tłumaczeniem gorzej.

Idea liczenia przyrostu w tym pliku: rampa3.ods

Znaleziono 21 wyników

Sens ekonomiczny ;)

Łańcuch rolkowy 06B-1 (3/8") Tsubaki 500mm

Dysk na rzepy 150 18A975/P180

Znaleziono 21 wyników

Sens ekonomiczny ;)

Łańcuch rolkowy 06B-1 (3/8") Tsubaki 500mm

Dysk na rzepy 150 18A975/P180

Zaloguj się • Zarejestruj się

Połącz się z kontem sieci społecznościowej