Zmiana prędkości serwomechanizmu

[Spwrt]

Cześć. Zbudowałem manipulator, składający się z 6 serw. Wszystko działa tak jak powinno, aczkolwiek jest problem ze zmianą prędkości wykonywanej sekwencji. Próbowałem na dwa sposoby.

Pierwszy:

Zmienia prędkość za pomocą funkcji delay( ). Poniekąd działa, ale zastanawia mnie jedna rzecz, bo sprawdziłem jak długo zajmie serwomechanizmowi wykonanie ruchu przy opóźnieniu 100ms ( około 28s), a przy 25ms ( około 10s). Wydaje mi się ze czasy powinny być w stosunku 1/4, no ale moze źle rozumuje.

// funkcja odejmująca pozycje serwa
int dekrementacja(int pozycja) 
{ 
  {pozycja--;} 
  return pozycja;
} 
// funkcja dodająca pozycje serwa
int inkrementacja(int pozycja) 
{ 

    {pozycja++;}
  return pozycja;
} 


int sekwencja(int p1, int pk1,...,int petla) 
{ 
  for(int i=0;i < petla; i++)
  {
    
  if(p1 <= pk1)                            //Serwo 1                
  { p1 = inkrementacja(p1);
  serwomechanizm_1.write(p1); }
  else                                      
  { p1 = dekrementacja(p1);
  serwomechanizm_1.write(p1); }
  
    if(digitalRead(4) == HIGH delay(100); // Przycisk P3
       else delay(25);
 .
 .
 .
 }
  
 

 

Drugi:

Zmiana w funkcjach "dodajacych/odejmujacych pozycje". A mianowicie zamiast dodawania pozycji o 1 to wprowadzilem wartość 2. Regulujac tą wartością można zmieniac predkość. Jednak jest problem przy krańcowych pozycjach. (Serwo porusza się od 10 -150 stopni) gdy dojdzie do 150 zatrzymuje się przy przy niej. Skacze 148, 150,148,150... itd po kilku sekundach znowu zaczyna schodzic do 10 i jest to samo 12,10,12,10...itd.

// funkcja odejmująca pozycje serwa
int dekrementacja(int pozycja) 

  {pozycja=pozycja-2;} 
  return pozycja;
} 

// funkcja dodająca pozycje serwa
int inkrementacja(int pozycja) 
{ 

  {pozycja=pozycja+2;}
  return pozycja;
} 

Podpowiedzcie, jeśli macie pomysl jak regulować tą prędkością, bo pierwszy sposób działa, ale myśle że drugi byłby lepszy. Pozdro.

[marek1707]

Moim zdaniem dobrym pomysłem byłoby przejście na wartości ułamkowe. Nadal możesz używać zmiennych całkowitych typu int - procesor nawet się o tym nie dowie, a Ty wyobraź sobie, że przecinek takiej liczby przesuwasz np. o 8 bitów w lewo. Zamiast więc postaci 16.0 masz 8.8 - to liczby bitów a kropka oznacza pozycję przecinka, to typowa notacja. Dotychczasowe 1oznacza w nowej interpretacji 1/256, wartość 128 (czyli 0x0080) oznacza po nowemu 0.5 a 256 (czyli 0x0100) oznacza wartość 1.0. Dobrze jest operować wtedy na zmiennych bez znaku a więc unsigned int (lub uint16_t) , gdzie zamiast starego zakresu liczb całkowitych 0..65535 masz teraz 0 do 255.99609375 (czyli do 255 i 255/256, 0xFFFF). Operacje na położeniu serwa (dodawanie i odejmowanie kroku do pozycji) robisz w tym układzie dokładnie tak samo jak poprzednio pamiętając przy ustalaniu kroku, że wszystko przemnażasz (w głowie) przez współczynnik 1/256. Jeżeli swoją pętlę główną będziesz zawsze wykonywał np. z prędkością np. 100 razy na sekundę (opóźnienie 10ms) to żonglując wielkością kroku możesz dowolnie regulować prędkość serwa w bardzo szerokich granicach. Zadając np. step = 64 (czyli po nowemu 1/4) masz 100 takich dodawań na sekundę a to oznacza zmianę pozycji o 25 "działek"/s. Przy najmniejszym kroku = 1 masz teraz prędkość 0,390625 "działki" serwa na sekundę (100 * 1/256) a to już ledwo widać i serwo na pewno płynnie tego nie zrobi. Oczywiście przy aktualizacji pozycji (robionej za każdym obrotem pętli) musisz swoją wirtualną liczbę ułamkową skonwertować na prawdziwą całkowitą z przecinkiem na prawo od bitu 0, bo tylko taką postać rozumie metoda serwo.write(). Wystarczy więc zrobić:

p1 += step;
serwomechanizm_1.write(p1>>8);

i masz to z głowy. Zauważ, że tą metodą możesz ruszać wieloma serwami jednocześnie w jednej pętli z różnymi prędkościami. Wystarczy tylko przyjąć różne kroki dla różnych serw. Przy sprawdzaniu czy już osiągnąłeś pozycję końcową musisz przemnożyć ja także przez ten sam współczynnik, więc jadąc do przykładowej pozycji 150 teraz będzie:

if (p1 < 150<<8)

Oczywiście jeśli nie potrzebujesz aż takiej granulacji kroku to możesz przyjąć pozycję przecinka arbitralnie inaczej, np. na pozycji między 3 a 4 bitem. Wtedy masz notację "12.4", krok = 1/16, zakres pozycji od 0 do 4095.9375 i zapis do serwa:

serwomechanizm_1.write(p1>>4);

ale wg mnie to niczego nie poprawia, bo i tak zakres do 256 przy serwach wystarczy.

[Spwrt]

Dzięki bardzo za pomoc, troche mnie oswieciles, bo myslalem nad tym zeby krok dac jako ułamek, ale nie wiedzialem jak za bardzo. Tylko takie pytanko co znaczy ten zapis w środku funkcji write( p1 >>  8 ) ?

[marek1707]

No to chłopie czas na powtórzenie kursu języka. To jakbyś próbował pisać artykuły nie znając wszystkich liter. Rzuć tam okiem a najlepiej zatrzymaj się na dłużej bo pewno odkryjesz wiele nowych rzeczy:

https://pl.wikibooks.org/wiki/C

A w tym konkretnym przypadku znajdź rozdział "Operatory -> Przesunięcie bitowe".

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[Spwrt]

Próbuje coś rozkminić, ale niestety program coś nie działa tak jak powinien.

 

int krok = 1;

// funkcja odejmująca pozycje serwa
int dekrementacja(int pozycja) 
{
  pozycja-=krok;
  return pozycja;
} 

// funkcja dodająca pozycje serwa
int inkrementacja(int pozycja) 
{ 

  pozycja+=krok;
  return pozycja;
} 


void sekwencja(int p1, int pk1,..., int petla) 
{ 
  for(int i=0;i < petla; i++)
  {
 

  if(p1 <= pk1)                             
  { p1 = inkrementacja(p1);
  serwomechanizm_1.write(p1>>8); }
  else                                       //Serwo 1
  { p1 = dekrementacja(p1);
  serwomechanizm_1.write(p1>>8); }

 

Podpowiesz co jest źle ?

[marek1707]

Nie widzę całego kodu, nie rozumiem dlaczego wrzuciłeś taki mały fragment. Zakładasz, że tu gdzieś jest błąd a wszystko inne jest OK? To może - idąc dalej tą metodą - pokaż tylko jedną linię swojego programu a wtedy w niej na pewno sam szybko odkryjesz co jest nie tak.

A poważnie: przede wszystkim nie widzę jak miałoby działać machanie serwem w dwie strony od jednej granicy do drugiej, abstrahując od arytmetyki liczenia pozycji. Takie coś wymaga dwóch różnych stanów programu: raz tylko dodajesz aż osiągniesz górny limit a potem tylko odejmujesz aż spadniesz do dolnego. Tu tego, a w szczególności zmiennej stanu, nie widzę. Pełnej pętli też nie, więc o czym tu gadać?

[Spwrt]

#include <Servo.h>                       // biblioteka dla serwa
 int krok = 1;
 int czas_wstrzymania_sekwencji = 5000;   // parametr, regulujący czas wstrzymania pracy serw 
 Servo serwomechanizm_1;                  // deklaracja obiektów
 Servo serwomechanizm_2;
 Servo serwomechanizm_3;                  
 Servo serwomechanizm_4;                 
 Servo serwomechanizm_5;
 Servo serwomechanizm_6;


 void setup()
 {
 Serial.begin(9600);          // Komunikacja UART ( Ustawienie prędkości transmisji )
 pinMode(7,INPUT_PULLUP);     // przełącznik sterowania P2
 pinMode(4,INPUT_PULLUP);     // przełącznik prędkości P3
 pinMode(12,OUTPUT);          // dioda (Arduino)
 
 serwomechanizm_1.attach(9);  // serwo nr 1 podłączone do pinu 9  
 serwomechanizm_2.attach(11);  // serwo nr 2 podłączone do pinu 11
 serwomechanizm_3.attach(10);  // serwo nr 3 podłączone do pinu 10
 serwomechanizm_4.attach(6);  // serwo nr 4 podłączone do pinu 6
 serwomechanizm_5.attach(5); // serwo nr 5 podłączone do pinu 5
 serwomechanizm_6.attach(3); // serwo nr 6 podłączone do pinu 3 

}

// funkcja odejmująca pozycje serwa
int dekrementacja(int pozycja) 
{
  pozycja-=krok;
  return pozycja;
} 

// funkcja dodająca pozycje serwa
int inkrementacja(int pozycja) 
{ 

  pozycja+=krok;
  return pozycja;
} 


void sekwencja(int p1, int pk1, int p2, int pk2, // Główna funkcja
int p3, int pk3, int p4, int pk4,
int p5, int pk5, int p6, int pk6,
int petla) 
{ 
  for(int i=0;i < petla; i++)
  {
 

  if(p1 <= pk1)                             
  { p1 = inkrementacja(p1);
  serwomechanizm_1.write(p1>>8); }
  else                                       //Serwo 1
  { p1 = dekrementacja(p1);
  serwomechanizm_1.write(p1>>8); }

  if(p2 <= pk2)
  { p2 = inkrementacja(p2);
  serwomechanizm_2.write(p2>>8); }
  else                                       //Serwo 2
  { p2 = dekrementacja(p2);
  serwomechanizm_2.write(p2>>8); }
  
  if(p3 <= pk3)
  { p3 = inkrementacja(p3);
  serwomechanizm_3.write(p3>>8); }
  else                                       //Serwo 3
  { p3 = dekrementacja(p3);
  serwomechanizm_3.write(p3>>8); }

  if(p4 <= pk4)
  { p4= inkrementacja(p4);
  serwomechanizm_4.write(p4>>8); }
  else                                       //Serwo 4
  { p4 = dekrementacja(p4);
  serwomechanizm_4.write(p4>>8); }

  if(p5 <= pk5)
  { p5 = inkrementacja(p5);
  serwomechanizm_5.write(p5>>8); }
  else                                       //Serwo 5
  { p5 = dekrementacja(p5);
  serwomechanizm_5.write(p5>>8); }
  
  if(p6 <= pk6)
  { p6 = inkrementacja(p6);
  serwomechanizm_6.write(p6>>8); }
  else                                       //Serwo 6
  { p6 = dekrementacja(p6);
  serwomechanizm_6.write(p6>>8); }

 delay(100);

  
 Serial.print("Sekwencja ruchow");
 Serial.print("\t\t");
 Serial.print(p1, DEC);
 Serial.print("\t");
 Serial.print(p2, DEC);
 Serial.print("\t");
 Serial.print(p3, DEC);
 Serial.print("\t");
 Serial.print(p4, DEC);
 Serial.print("\t");
 Serial.print(p5, DEC);
 Serial.print("\t");
 Serial.print(p6, DEC);
 

}

}


void loop()
  {
 //Włączenie diody
 digitalWrite(12, HIGH);
 
 //Odczyt wartości z pinów ADC
 int odebraneDane_1 = analogRead(A0); 
 int odebraneDane_2 = analogRead(A1); 
 int odebraneDane_3 = analogRead(A2); 
 int odebraneDane_4 = analogRead(A3);
 int odebraneDane_5 = analogRead(A4);
 int odebraneDane_6 = analogRead(A5); 

 //Przeskalowanie odczytu z ADC (0-1023) na stopnie (0-180) 
 odebraneDane_1 = map(odebraneDane_1, 0, 1024,  0, 250); 
 odebraneDane_2 = map(odebraneDane_2, 0, 1024, 23, 350); 
 odebraneDane_3 = map(odebraneDane_3, 0, 1024, 23, 300);
 odebraneDane_4 = map(odebraneDane_4, 0, 1024, 10, 300);
 odebraneDane_5 = map(odebraneDane_5, 0, 1024, 0, 250); 
 odebraneDane_6 = map(odebraneDane_6, 0, 1024, 5, 180); 
if(digitalRead(4) == HIGH) krok=1;
else krok=10;
 if(digitalRead(7) == LOW) // P2
 
  {
   sekwencja(0,0  , 107,107 , 145,145  , 33,33  , 0,0 , 5,5 , 140);
   sekwencja(0,0  , 0,0 , 0,0  , 150,10  , 0,0 , 0,0 , 140);
   delay(3000);
    /*
sekwencja(0,0  , 125,52 , 29,58  , 174,163  , 52,52 , 5,35 , 73);   // opuszczanie ramienia
sekwencja(0,0  , 52,52 , 58,58  , 163,163  , 52,52 , 35,10 , 25);   // łapanie przedmiotu
sekwencja(0,90  , 52,80 , 58,58  , 163,163  , 52,52 , 10,10 , 90);   // przenoszenie
sekwencja(90,90  , 80,52 , 58,58  , 163,163  , 52,52 , 10,10 , 32);   // opuszczanie
sekwencja(90,90  , 52,52 , 58,58  , 163,163  , 52,52 , 10,35 , 25);   // puszczanie
sekwencja(90,90  , 52,72 , 58,58  , 163,163  , 52,52 , 35,35 , 20); 
sekwencja(90,0  , 72,125 , 58,29  , 163,174  , 52,52 , 35,5 , 90);   // powrot do pozycji pionowej
delay(czas_wstrzymania_sekwencji); 
  */
  }
else
  {
    
 serwomechanizm_1.write(odebraneDane_1);
 serwomechanizm_2.write(odebraneDane_2);
 serwomechanizm_3.write(odebraneDane_3);
 serwomechanizm_4.write(odebraneDane_4);
 serwomechanizm_5.write(odebraneDane_5);
 serwomechanizm_6.write(odebraneDane_6);

 Serial.print("Sterowanie reczne");
 
 Serial.print("\t\t");
 Serial.print(odebraneDane_1, DEC);
 
 Serial.print("\t");
 Serial.print(odebraneDane_2, DEC);

 Serial.print("\t");
 Serial.print(odebraneDane_3, DEC);

 Serial.print("\t");
 Serial.print(odebraneDane_4, DEC);

 Serial.print("\t");
 Serial.print(odebraneDane_5, DEC);

 Serial.print("\t");
 Serial.println(odebraneDane_6, DEC);

  }
}

Racja sorry

[Spwrt]

Dobra już mam olśniło mnie !

[marek1707]

Gratulacje dla Ciebie za sukces i dla siebie, że zostałem żółtą kaczuszką. Znajdź zatem chwilę czasu i opisz co wymyśliłeś, niech inni próbujący zrobić to samo (a temat wolnych ruchów serw powtarza się tutaj regularnie) mają z Ciebie pożytek. Dorzuć kod z jakimś opisem co było źle i jak to rozwiązałeś a być może ktoś będzie miał pomysł jak to samo zrobić inaczej, prościej albo nawet.. lepiej?

[Spwrt]

Mam dobry pomysł, ale jednak zatrzymałem się w jednym punkcie i nie mogę tego przeskoczyć, liczę na twoją  pomoc( Jeśli jeszcze nie straciłeś cierpliwości), a teraz opiszę co wymyśliłem i gdzie leży problem.

Żeby wszystkie serwa zaczynały i kończyły swoją pracę w tym samym momencie trzeba wprowadzić kilka zmiennych:

T - czas, w którym serwa mają się poruszać (w milisekundach)

O - opóźnienie po wykonaniu jednego obiegu pętli (w milisekundach)

T/O - ilość obiegów w ciągu zadanego czasu ( ilość pojedynczych kroków )

P1 - pozycja początkowa serwa

PK1 - pozycja końcowa serwa

KROK_1 -  zmienna dodawana do pozycji początkowej ( dodatnia gdy: P1 < PK1, ujemna gdy: P1>PK1)

Załóżmy, że:

T = 5s = 5000ms,

O = 20ms,

P1 = 50,

PK1 = 140,

Jeśli w ciągu 20ms mamy jedno dodanie kroku do pozycji początkowej to w ciągu 5000ms będzie ich 250

Dzieląc 5000ms/20ms = 250 kroków

P1 < PK1 dlatego KROK_1 > 0

Aby go obliczyć należy wykonać następujące działanie:

KROK_1 = (PK1 - P1)/ (T/O) = (140 - 50) / 250 = 0,36

Teraz trzeba wyznaczyć krok dla każdego serwa, a tak to wygląda w kodzie:

 #include <Servo.h>                       // biblioteka dla serwa
 
 Servo serwomechanizm_1;                  // deklaracja obiektów
 Servo serwomechanizm_2;
 Servo serwomechanizm_3;                  
 Servo serwomechanizm_4;                 
 Servo serwomechanizm_5;
 Servo serwomechanizm_6;

 int czas_wstrzymania_sekwencji = 5000;   
 float KROK_1; 
 float KROK_2;
 float KROK_3;
 float KROK_4;
 float KROK_5;
 float KROK_6;

 void setup()
 {
 Serial.begin(9600);          // Komunikacja UART ( Ustawienie prędkości transmisji )
   
 serwomechanizm_1.attach(9);  // serwo nr 1 podłączone do pinu 9  
 serwomechanizm_2.attach(11);  // serwo nr 2 podłączone do pinu 11
 serwomechanizm_3.attach(10);  // serwo nr 3 podłączone do pinu 10
 serwomechanizm_4.attach(6);  // serwo nr 4 podłączone do pinu 6
 serwomechanizm_5.attach(5); // serwo nr 5 podłączone do pinu 5
 serwomechanizm_6.attach(3); // serwo nr 6 podłączone do pinu 3 
}


void ObliczKrok(float P1, float PK1, float P2, float PK2,
                float P3, float PK3, float P4, float PK4,
                float P5, float PK5, float P6, float PK6,
                float T,float O)
{   
      if(P1 < PK1)   KROK_1 = (PK1 - P1)/(T/O);     // jeśli warunek jest spełniony to krok jest dodatni PK1 - P1 = 140 - 50 = 90 > 0
      else           KROK_1 = (P1 - PK1)/(T/O);     // jeśli nie to jest ujemny 
      
      if(P2 < PK2)   KROK_2 = (PK2 - P2)/(T/O);       
      else           KROK_2 = (P2 - PK2)/(T/O);    
     
      if(P3 < PK3)   KROK_3 = (PK3 - P3)/(T/O);        
      else           KROK_3 = (P3 - PK3)/(T/O);      
                          
      if(P4 < PK4)   KROK_4 = (PK4 - P4)/(T/O);     
      else           KROK_4 = (P4 - PK4)/(T/O);        
           
      if(P5 < PK5)   KROK_5 = (PK5 - P5)/(T/O);      
      else           KROK_5 = (P5 - PK5)/(T/O);       
      
      if(P6 < PK6)   KROK_6 = (PK6 - P6)/(T/O);     
      else           KROK_6 = (P6 - PK6)/(T/O);      
      
         
}
void sekwencja(float P1, float PK1, float P2, float PK2,
               float P3, float PK3, float P4, float PK4,
               float P5, float PK5, float P6, float PK6,
               float T, float O, int NumerSekwencji) 
{ 
    ObliczKrok(P1, PK1, P2, PK2, P3, PK3, P4, PK4, P5, PK5, P6, PK6, T, O);     // w tym miejscu wywoływana jest funkcja licząca kroki dla all serw        
                 
    for(int i = 0; i<T/O; i++) // pętla wykonuje obieg tyle razy ile jest kroków ma sekwencja ( T/O )
    {
      P1+=KROK_1;   // do pozycji początkowej dodawany jest krok wyliczony przed wejsciem do pętli for
      P2+=KROK_2;      
      P3+=KROK_3;             
      P4+=KROK_4;      
      P5+=KROK_5;     
      P6+=KROK_6;
      
      serwomechanizm_1.write(P1);   // pozycja serwa jest ustawiana w tym miejscu
      serwomechanizm_2.write(P2);
      serwomechanizm_3.write(P3);
      serwomechanizm_4.write(P4);
      serwomechanizm_5.write(P5);
      serwomechanizm_6.write(P6);
      
     
    Serial.print("S[");                 //na monitorze portu szer. pokazują się uaktualniane pozycje serw
    Serial.print(NumerSekwencji);
    Serial.print("]");
    Serial.print("\t");
    Serial.print(P1);
    Serial.print("\t");
    Serial.print(P2);
    Serial.print("\t");
    Serial.print(P3);
    Serial.print("\t");
    Serial.print(P4);
    Serial.print("\t");
    Serial.print(P5);
    Serial.print("\t");
    Serial.print(P6);
    Serial.print("\t");
    Serial.println(i);
    
    delay(O); // opóźnienie po całym obiegu pętli
    }  
}

void loop()
  {
		sekwencja(0,100  , 180,20 , 0,0  , 0,0  , 0,0 , 0,0 , 5000, 20, 1);  // przykładowa sekwencja dla 6 serw
		delay(czas_wstrzymania_sekwencji);  //zatrzymanie sekwencji ruchów na 5s
  }

Program działa w następujący sposób:

Mamy główną funkcje sekwencja(...) z parametrami, które ustawiają pozycje poczatkowe, koncowe, parametr T, O i NumerSekwencji. W jej wnętrzu jest wywołanie funkcji ObliczKrok() której parametry to parametry funkcji sekwencja. Cały problem tkwi w funkcji ObliczKrok, ponieważ krok ustawiany jest zawsze na wartość dodatnią. No i nie wiem gdzie jest błąd. Próbowałem wszystkiego, ale na marne, krok jest liczony dobrze, tylko z pominięciem znaku.

Wiem, że metoda jest dobra, ponieważ podrzucił mi ją kiedyś jeden z forumowiczów forbota, jednak nie wiedziałem jak się do tego zabrać i zrobiłem prostszy program.

Zależy mi bardzo znalezieniu błędu i skończeniu programu, bo czas mnie goni - inżynierka, a wtedy manipulator chodziłby naprawdę super.   @marek1707  znalazłbyś chwile, żeby looknąć? Byłbym wdzięczny 😄

 

[marek1707]

Zupełnie niepotrzebnie robisz to dziwne sprawdzenie:

if (P1 < PK1)
  KROK_1 = (PK1 - P1)/(T/O); // jeśli warunek jest spełniony to krok jest dodatni PK1 - P1 = 140 - 50 = 90 > 0
else
  KROK_1 = (P1 - PK1)/(T/O); // jeśli nie to jest ujemny

Za cały ten if wystarczy jedna instrukcja:

KROK_1 = (PK1 - P1)/(T/O);

Przecież znak kroku wyznaczasz niejako automatycznie, odejmując pozycje. Jeśli końcowa jest mniejsza od początkowej to jedziesz do tyłu i wynik w pierwszym nawiasie (a więc i całego dzielenia) wyjdzie ujemny. Dzielenie jest kosztowną operacją w każdym procesorze więc zamiast wielokrotnie robić (T/O) i potem jeszcze liczyć główny iloraz, możesz mnnożyć przez jednokrotnie wcześniej policzone O/T, czyż nie? Być może kompilator to sobie uprości i zamieni dzielenie na mnożenie przez odwrotność, ale nie wiemy tego na pewno i chyba warto dostrzegać takie rzeczy. Arytmetyka nie liczy się w czasie zerowym, tu masz jej sporo a zakładasz jakiś reżim czasu rzeczywistego. Może się okazać, że ruch/pętla mająca zrobić się w 5 sekund będzie się wykonywać sekund 7 a Ty będziesz zachodził w głowę dlaczego. 

Generalnie jest mi przykro, że liczysz to na zmiennym przecinku skoro już wiesz, że można takie operacje robić taniej i szybciej przy użyciu arytmetyki stałoprzecinkowej. No ale terminy mają swoje wymagania a w niedoczasie możesz być zdesperowany i nie mieć ochoty na zgłębianie jakichś technik odchudzania i przyspieszania kodu. Może kiedyś, prawda?

EDIT: Deklarując zmienne P, PK i KROK nie myślałeś o tablicach? Nie musiałbyś rozpisywać tego na długie ekrany kodu. Jedna prosta, zwarta pętla i z głowy.

Edytowano Styczeń 7, 2019 przez marek1707

[Spwrt]

Dziękuję bardzo, wszystko działa Królu Złoty ! Uprościłem wstępnie tak jak mówiłeś. Jutro spróbuje to zrobić na tablicach no i pomęcze się z tą pętlą czasu rzeczywistego, choć może to być trudne, no ale zobaczymy( no bo rzeczywiscie te T=3000 ( w parametrze) to nie są 3 sekundy 😄 ). A co do arytmetyki stałoprzecinkowej, to po inzynierce na pewno doczytam, bo bede i tak robil jeszcze jakies roboty, także optymalizacja kodu się przyda. Jeszcze raz dziękuje za wszystko !