OK Mégsem
Fórum témák

» Több friss téma
Fórum » ARM - Miértek hogyanok
ARM - Miértek hogyanok
 
Témaindító: gtk, idő: Jún 26, 2007
Témakörök:
Lapozás: OK   60 / 177
(#) toto válasza Suncorgo hozzászólására (») Máj 27, 2015 /
 
Mit értesz azon, hogy akad a léptetőmotor?
Egyáltalán nem megy, vagy csak lelassul a léptetés, amikor az USART dolgozik?
Az interruptok időtartamát nézted már? Csak egy tipp, de ha az USART kiszolgálása sokáig tart, a következő motor léptetésnek szerintem várakoznia kell, amíg az USART interrupt service be nem fejeződik, még akkor is, ha a Timernek magasabb a prioritása.
Nem találtam erről leírást (szóval bocs, ha tévedek), de az NVIC szerintem alapban tiltja a Global interruptot addig, amíg egy interrupt service-ben van.
(#) kapu48 válasza Suncorgo hozzászólására (») Máj 27, 2015 /
 
Rossz az egész USART1_IRQHandler szervezése!

Nem szabad kivárni, amíg elmegy 1 egész sor: uart_karakterlanc_kuldes(uart_rx_adat); ???
És addig nem csinálni semmi mást!

Tessék karakterenként kezelni, Vétel: megjött 1 karakter kapsz megszakítást: eltárolod, kilépsz …
Adás: Elment 1 karakter kapsz megszakítás, küldöd a következőt, kilépsz …
És a két INT akció között bőven van időd egyéb feladatra!
(#) Suncorgo válasza toto hozzászólására (») Máj 27, 2015 /
 
A léptetőmotor léptetéséhez jelsorozatra van szükség, step jelre. Mint egy signal generátor. Ennek a jelsorozatnak csúszik el az időzítése.
(#) Suncorgo válasza kapu48 hozzászólására (») Máj 27, 2015 /
 
Az NVIC nem pont arra való hogy ha benne vagyok egy alacsonyabb prioritású ISR-ben akkor azt megszakítja és a magasabb prioritású ISR indítja el? Tehát lényegében itt is az van hogy az ISR-ben a lehető legkevesebb időt kell eltölteni amelyet úgy tudok elképzelni hogy egy flag-et billentek be ha megvan az egész visszaküldendő adat és a főszálból kell figyelnem ezt a flag-et amely immár onnan fogja visszaküldeni az egész karakterláncot. Ekkor viszont nem értem hogy mi értelme is van az NVIC-nek és a prioritás megadási lehetőségeknek? Ugye amíg a főprogram küldi az adatot addig a timer ISR szabadon tud megszakításokat generálni és léptetni a motort.
(#) kapu48 válasza Suncorgo hozzászólására (») Máj 27, 2015 /
 
Én viszont úgy értelmeztem, hogy a torlódó megszakítások végrehajtási sorrendjét tudod beállítani.
De ezt kevés debugolással könnyen le ellenőrizheted.
(#) Suncorgo válasza kapu48 hozzászólására (») Máj 27, 2015 /
 
Ezért is nem értettem hogy egy Arduino-n futó GRBL controller a 8 bites AVR-ek 16Mhz sebességével hogyan is képes visszaküldeni a szerszámpozíciót (uart kommunikáció) léptetőmotor vezérlés közben. Hát így. Köszönöm
(#) kapu48 válasza Suncorgo hozzászólására (») Máj 27, 2015 /
 
Az AVR-nél bevan vésve a HW-be az INT sorrend, nem tudod SW-báől újra szervezni!
(#) Suncorgo hozzászólása Jún 2, 2015 /
 
Sziasztok!

Egy olyan problémába futottam amely teljesen keresztbe tett nekem. Szinte teljesen lámának érzem magam, vagy egy BUG-ról van szó.

uart-on adatot fogadok, ezzel egy flaget állítok be amely elindít 3 timert/countert (TIM2-3-4). Ez az interpolátorom 3 tengelyének a lépésidőzítője. Mind 3 timer ISR-jében a timerek saját magukat képesek leállítani, közben a fóprogramban figyelem a 3 timert és a flag-et. A 3 timer leáll, debuggolásnál látom hogy már nem fut az ISR egyiknél sem, viszont a timer/counter engedélyező bitet olvasva azt látom hogy a 3-ból 2 timer nem kapcsolt ki. Ez hogy lehet? Így beakad a programom.

Ez a main függvényben van, a főprogram:
  1. while(1)
  2.         {
  3.                 if(uart_adat_feldolgozasi_kerelem)
  4.                 {
  5.                         if( strstr(uart_rx_adat, "$") )
  6.                         {
  7.                                 cnc_parancs_olvasas_es_vegrehajtas(uart_rx_adat);
  8.                         }
  9.                         else
  10.                         {
  11.                                 if(cnc_allapot == KESZENLET)
  12.                                 {
  13.                                         cnc_gkod_olvasas(uart_rx_adat);
  14.                                 }
  15.                                 else
  16.                                 {
  17.                                         cnc_valasz = HIBA_GEP_FOGLALT;
  18.                                 }
  19.                         }
  20.                        
  21.                         UART_RX_ADAT_TORLES;
  22.                         uart_adat_feldolgozasi_kerelem = HAMIS;
  23.                 }
  24.                
  25.                 t1 = READ_BIT(TIM2->CR1, TIM_CR1_CEN);
  26.                 t2 = READ_BIT(TIM3->CR1, TIM_CR1_CEN);
  27.                 t3 = READ_BIT(TIM4->CR1, TIM_CR1_CEN);
  28.                
  29.                 //if( !READ_BIT(TIM2->CR1, TIM_CR1_CEN) && !READ_BIT(TIM3->CR1, TIM_CR1_CEN) && !READ_BIT(TIM4->CR1, TIM_CR1_CEN) && cnc_allapot != KESZENLET)
  30.                 if( !t1 && !t2 && !t3 && (cnc_allapot != KESZENLET))
  31.                 {
  32.                         cnc_valasz = GKOD_OK;
  33.                         cnc_allapot = KESZENLET;
  34.                 }
  35.                
  36.                 if(cnc_valasz != SEMMI)
  37.                 {
  38.                         switch (cnc_valasz)
  39.                         {
  40.                                 case PARANCS_OK:
  41.                                         uart_karakterlanc_kuldes("PARANCS_OK");
  42.                                 break;
  43.                                
  44.                                 case HIBA_ISMERETLEN_PARANCS:
  45.                                         uart_karakterlanc_kuldes("HIBA_ISMERETLEN_PARANCS");
  46.                                 break;
  47.                                
  48.                                 case GKOD_OK:
  49.                                         uart_karakterlanc_kuldes("GKOD_OK");
  50.                                 break;
  51.                                
  52.                                 case HIBA_ISMERETLEN_GKOD:
  53.                                         uart_karakterlanc_kuldes("HIBA_ISMERETLEN_GKOD");
  54.                                 break;
  55.                                
  56.                                 case HIBA_GEP_FOGLALT:
  57.                                         uart_karakterlanc_kuldes("HIBA_GEP_FOGLALT");
  58.                                 break;
  59.                                
  60.                                 case HIBA_VEGALLAS:
  61.                                         uart_karakterlanc_kuldes("HIBA_VEGALLAS");
  62.                                 break;
  63.                         }
  64.                        
  65. //                      cnc_x_szerszampozicio = uj_cnc_x_szerszampozicio;
  66. //                      cnc_y_szerszampozicio = uj_cnc_y_szerszampozicio;
  67. //                      cnc_z_szerszampozicio = uj_cnc_z_szerszampozicio;
  68.                        
  69.                         cnc_valasz = SEMMI;
  70.                         cnc_szerszampoziciok_kuldese();
  71.                         uart_karakterlanc_vege();
  72.                 }
  73.                
  74.                 vegallaskapcsolok_es_erinto_allapot_kuldes();
  75.                
  76. //              if(cnc_allapot != KESZENLET)
  77. //              {
  78. //                      cnc_szerszampoziciok_kuldese();
  79. //                      uart_karakterlanc_vege();
  80. //              }
  81.         }


t1-3 változók a timerek állapota, és ezeket a biteket hiába olvasom azt adják vissza hogy a timerek futnak. Miért?

Timer-ek initializálása:
  1. void cnc_initializalas(void)
  2. {
  3.         double buffer_szorzo;
  4.         TIM_TimeBaseInitTypeDef timerInitStructure;
  5.         NVIC_InitTypeDef nvicStructure;
  6.        
  7.         cnc_felbontas = ((MENETEMELKEDES / (360.0 / LEPTETOMOTOR_LEPESSZOGE)) / MIKROLEPES_MOD);
  8.         cnc_lepes_per_mm = 1.0 / cnc_felbontas;
  9.        
  10.         mikrolepes_initializalasa();
  11.        
  12.         //felbontás szorzó/osztó keresése kerekítéshez
  13.         buffer_szorzo = 10;
  14.        
  15.         while(1)
  16.         {
  17.                 if(((unsigned long)(cnc_felbontas * buffer_szorzo)) == ((double)(cnc_felbontas * buffer_szorzo)))
  18.                 {
  19.                         szorzo_oszto_kerekiteshez = buffer_szorzo;
  20.                         break;
  21.                 }
  22.                 else
  23.                 {
  24.                         buffer_szorzo *= 10;
  25.                 }
  26.         }
  27.        
  28.         //Timer 2,3,4
  29.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  30.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  31.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
  32.  
  33.         timerInitStructure.TIM_Prescaler = 42 - 1;
  34.         timerInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  35.         timerInitStructure.TIM_Period = (65536 / (200 / 30.52)) - 1;
  36.         timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
  37.         timerInitStructure.TIM_RepetitionCounter = 0;
  38.         TIM_TimeBaseInit(TIM2, &timerInitStructure);
  39.         TIM_TimeBaseInit(TIM3, &timerInitStructure);
  40.         TIM_TimeBaseInit(TIM4, &timerInitStructure);
  41.        
  42.         elotolas_beallitas_x(ALAP_SEBESSEG_MMPP);
  43.         elotolas_beallitas_y(ALAP_SEBESSEG_MMPP);
  44.         elotolas_beallitas_z(ALAP_SEBESSEG_MMPP);
  45.        
  46.         TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
  47.         TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);
  48.         TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
  49.        
  50.         nvicStructure.NVIC_IRQChannel = TIM2_IRQn;
  51.         nvicStructure.NVIC_IRQChannelPreemptionPriority = 0;
  52.         nvicStructure.NVIC_IRQChannelSubPriority = 0;
  53.         nvicStructure.NVIC_IRQChannelCmd = ENABLE;
  54.         NVIC_Init(&nvicStructure);
  55.        
  56.         nvicStructure.NVIC_IRQChannel = TIM3_IRQn;
  57.         NVIC_Init(&nvicStructure);
  58.        
  59.         nvicStructure.NVIC_IRQChannel = TIM4_IRQn;
  60.         NVIC_Init(&nvicStructure);
  61.        
  62.         TIM_Cmd(TIM2, DISABLE);
  63.         TIM_Cmd(TIM3, DISABLE);
  64.         TIM_Cmd(TIM4, DISABLE);
  65. }


Timerek ISR és frekvenciabeállító metódusai:
  1. void TIM2_IRQHandler(void)
  2. {
  3.         if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  4.         {
  5.                 if(uj_cnc_x_szerszampozicio > (cnc_x_szerszampozicio + (cnc_felbontas / 2)))
  6.                 {
  7.                         x_plusz();
  8.                 }
  9.                 else if(uj_cnc_x_szerszampozicio < (cnc_x_szerszampozicio - (cnc_felbontas / 2)))
  10.                 {
  11.                         x_minusz();
  12.                 }
  13.                 else
  14.                 {
  15.                         TIM_Cmd(TIM2, DISABLE);
  16.                         cnc_x_szerszampozicio = uj_cnc_x_szerszampozicio;
  17.                 }
  18.                
  19.                 TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  20.         }
  21. }
  22.  
  23. void TIM3_IRQHandler(void)
  24. {
  25.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
  26.         {
  27.                 if(uj_cnc_y_szerszampozicio > (cnc_y_szerszampozicio + (cnc_felbontas / 2)))
  28.                 {
  29.                         y_plusz();
  30.                 }
  31.                 else if(uj_cnc_y_szerszampozicio < (cnc_y_szerszampozicio - (cnc_felbontas / 2)))
  32.                 {
  33.                         y_minusz();
  34.                 }
  35.                 else
  36.                 {
  37.                         TIM_Cmd(TIM3, DISABLE);
  38.                         cnc_y_szerszampozicio = uj_cnc_y_szerszampozicio;
  39.                 }
  40.                
  41.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
  42.         }
  43. }
  44.  
  45. void TIM4_IRQHandler(void)
  46. {
  47.         if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
  48.         {
  49.                 if(uj_cnc_z_szerszampozicio > (cnc_z_szerszampozicio + (cnc_felbontas / 2)))
  50.                 {
  51.                         z_plusz();
  52.                 }
  53.                 else if(uj_cnc_z_szerszampozicio < (cnc_z_szerszampozicio - (cnc_felbontas / 2)))
  54.                 {
  55.                         z_minusz();
  56.                 }
  57.                 else
  58.                 {
  59.                         TIM_Cmd(TIM4, DISABLE);
  60.                         cnc_z_szerszampozicio = uj_cnc_z_szerszampozicio;
  61.                 }
  62.                
  63.                 TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
  64.         }
  65. }
  66.  
  67. void elotolas_beallitas_x(double mmpp)
  68. {
  69.         TIM2->ARR = (65536 / (((mmpp / 60) * cnc_lepes_per_mm) / 30.52)) - 1;
  70.         //TIM2->ARR = ((((1000000.0*60.0) / mmpp) / cnc_lepes_per_mm));
  71. }
  72.  
  73. void elotolas_beallitas_y(double mmpp)
  74. {
  75.         TIM3->ARR = (65536 / (((mmpp / 60) * cnc_lepes_per_mm) / 30.52)) - 1;
  76.         //TIM2->ARR = ((((1000000.0*60.0) / mmpp) / cnc_lepes_per_mm));
  77. }
  78.  
  79. void elotolas_beallitas_z(double mmpp)
  80. {
  81.         TIM4->ARR = (65536 / (((mmpp / 60) * cnc_lepes_per_mm) / 30.52)) - 1;
  82.         //TIM2->ARR = ((((1000000.0*60.0) / mmpp) / cnc_lepes_per_mm));
  83. }


Itt indítom el a 3 timert:
  1. void cnc_gyorsmenet_inditasa(void)
  2. {
  3.         double x_tavolsag, y_tavolsag, z_tavolsag, tavolsag;
  4.        
  5.         cnc_allapot = G0;
  6.        
  7.         //tengelyek sebességszámolása
  8.         x_tavolsag = abszolut_ertek(kerekites_long_double(uj_cnc_x_szerszampozicio - cnc_x_szerszampozicio));
  9.         y_tavolsag = abszolut_ertek(kerekites_long_double(uj_cnc_y_szerszampozicio - cnc_y_szerszampozicio));
  10.         z_tavolsag = abszolut_ertek(kerekites_long_double(uj_cnc_z_szerszampozicio - cnc_z_szerszampozicio));
  11.        
  12.         tavolsag = kerekites_long_double(sqrt( pow(x_tavolsag,2.0) + pow(y_tavolsag,2.0) + pow(z_tavolsag,2.0))); //(tér)vektor hossza
  13.        
  14.         elotolas_beallitas_x( (x_tavolsag / tavolsag) * ALAP_SEBESSEG_MMPP);
  15.         elotolas_beallitas_y( (y_tavolsag / tavolsag) * ALAP_SEBESSEG_MMPP);
  16.         elotolas_beallitas_z( (z_tavolsag / tavolsag) * ALAP_SEBESSEG_MMPP);
  17.        
  18.         TIM2->CNT = 0;
  19.         TIM3->CNT = 0;
  20.         TIM4->CNT = 0;
  21.        
  22.         TIM_Cmd(TIM2, ENABLE);
  23.         TIM_Cmd(TIM3, ENABLE);
  24.         TIM_Cmd(TIM4, ENABLE);
  25. }


Ugye egy control regiszter kapcsolok be a főprogramból és olvasom. A kikapcsolás pedig saját maga ISR-jéből történik. Úgy tudom ha egy globális változót használok ISR-en belül akkor annak típusa mindig volatile de egy control regisztert nem tudok volatile-re beállítani.
Létezik hogy ezért nem működik megfelelően a kódom? Nálatok hogyan van a fordító beállítva? Az is lehet hogy csak egy optimalizációs beállítás vagy ilyesmi van elállítva nálam.
A hozzászólás módosítva: Jún 2, 2015

keil.jpg		    
(#) kapu48 válasza Suncorgo hozzászólására (») Jún 3, 2015 /
 
Én sehol nem látom, hogy ezekben a if vizsgálatokban levő értékeket, menetközben változtatnád?
  1. if(uj_cnc_x_szerszampozicio > (cnc_x_szerszampozicio + (cnc_felbontas / 2)))
  2.                 {
  3.                         x_plusz(); // Ezt sem látom???
  4.                 }
  5.                 else if(uj_cnc_x_szerszampozicio < (cnc_x_szerszampozicio - (cnc_felbontas / 2)))
  6.                 {
  7.                         x_minusz();// Ez mit tesz? Ezt sem látom???
  8.  
  9.                 }
  10.                 else  
  11. // Mikor teljesül:  if(uj_cnc_x_szerszampozicio == (cnc_x_szerszampozicio - (cnc_felbontas / 2)))
  12.                 {  // Ide, hogyan kerülünk be?
  13.                         TIM_Cmd(TIM2, DISABLE);
  14.                         cnc_x_szerszampozicio = uj_cnc_x_szerszampozicio;
  15.                 }

Mikor fut így bele az else ágba?
A hozzászólás módosítva: Jún 3, 2015
(#) Suncorgo válasza kapu48 hozzászólására (») Jún 3, 2015 /
 
Igazad van, igen azok a függvények olvassák az aktuális végálláskapcsolót és a gép felbontásával növelik vagy csökkentik a cnc pozícióváltozókat.

  1. unsigned char x_plusz(void)
  2. {
  3.         if(!X_PLUSZ_VEGALLAS_ALLAPOT)
  4.         {
  5.                 X_EGY_LEPES_PLUSZBA;
  6.                 cnc_x_szerszampozicio = kerekites_long_double(cnc_x_szerszampozicio + cnc_felbontas);
  7.         }
  8.         else
  9.         {
  10.                 return HIBA_VEGALLAS;
  11.         }
  12.        
  13.         return 0;
  14. }
  15.  
  16. unsigned char x_minusz(void)
  17. {
  18.         if(!X_MINUSZ_VEGALLAS_ALLAPOT)
  19.         {
  20.                 X_EGY_LEPES_MINUSZBA;
  21.                 cnc_x_szerszampozicio = kerekites_long_double(cnc_x_szerszampozicio - cnc_felbontas);
  22.         }
  23.         else
  24.         {
  25.                 return HIBA_VEGALLAS;
  26.         }
  27.        
  28.         return 0;
  29. }
  30.  
  31. unsigned char y_plusz(void)
  32. {
  33.         if(!Y_PLUSZ_VEGALLAS_ALLAPOT)
  34.         {
  35.                 Y_EGY_LEPES_PLUSZBA;
  36.                 cnc_y_szerszampozicio = kerekites_long_double(cnc_y_szerszampozicio + cnc_felbontas);
  37.         }
  38.         else
  39.         {
  40.                 return HIBA_VEGALLAS;
  41.         }
  42.        
  43.         return 0;
  44. }
  45.  
  46. unsigned char y_minusz(void)
  47. {
  48.         if(!Y_MINUSZ_VEGALLAS_ALLAPOT)
  49.         {
  50.                 Y_EGY_LEPES_MINUSZBA;
  51.                 cnc_y_szerszampozicio = kerekites_long_double(cnc_y_szerszampozicio - cnc_felbontas);
  52.         }
  53.         else
  54.         {
  55.                 return HIBA_VEGALLAS;
  56.         }
  57.        
  58.         return 0;
  59. }
  60.  
  61. unsigned char z_plusz(void)
  62. {
  63.         if(!Z_PLUSZ_VEGALLAS_ALLAPOT)
  64.         {
  65.                 Z_EGY_LEPES_PLUSZBA;
  66.                 cnc_z_szerszampozicio = kerekites_long_double(cnc_z_szerszampozicio + cnc_felbontas);
  67.         }
  68.         else
  69.         {
  70.                 return HIBA_VEGALLAS;
  71.         }
  72.        
  73.         return 0;
  74. }
  75.  
  76. unsigned char z_minusz(void)
  77. {
  78.         if(!Z_MINUSZ_VEGALLAS_ALLAPOT)
  79.         {
  80.                 Z_EGY_LEPES_MINUSZBA;
  81.                 cnc_z_szerszampozicio = kerekites_long_double(cnc_z_szerszampozicio - cnc_felbontas);
  82.         }
  83.         else
  84.         {
  85.                 return HIBA_VEGALLAS;
  86.         }
  87.        
  88.         return 0;
  89. }


Viszont tegnap éjjel rájöttem a bibire, most más problémán tornázok.

A tegnapi hiba akkor jött elő mikor valamelyik tengellyel nem mentem semerre így a megteendő távolság nulla volt. Így az autoreload regiszterbe is nullát írt, ezért nem következett be az aktuális timer ISR-je sem. Ezt orvosoltam a timerek indításnál:

  1. if(x_tavolsag > cnc_felbontas){ TIM_Cmd(TIM2, ENABLE); }
  2.         if(y_tavolsag > cnc_felbontas){ TIM_Cmd(TIM3, ENABLE); }
  3.         if(z_tavolsag > cnc_felbontas){ TIM_Cmd(TIM4, ENABLE); }


Így jó lett.
(#) Suncorgo hozzászólása Jún 3, 2015 /
 
Azóta megírtam hozzá a gyorsítás lassítás algoritmusokat, de ha valamelyik tengellyel kevesebbet kell lépni mint a megadott gyorsítási/lassítási távolság akkor az a tengely ugye nem éri el a G0 gyorsmenet max sebességét mert a gyorsítás_eddig és lassítás_innen változók összecsúsznak.

pl:
x tengellyel mennem kell 10mm-ert. A gyorsítási és lassítási távolságom 1mm. Ekkor:
gyorsítás_eddig = aktuális_pozíció + gyorsítás_lassítás_távolság = 1mm
lassítás_innen = (aktuális_pozíció + x_távolság) - gyorsítás_lassítás_távolság = 9mm

Ekkor 0-1mmig gyorsít, 9-10mm-ig lassít.

Ha mind 3 tengellyel többet lépek mint a gyorsítási lassítási távolság akkor hibátlan, ha valamelyikkel kevesebbet akkor elcsúszik az a tengely a többitől amelyik kevesebb utat tesz meg.

Indítás:

  1. void cnc_gyorsmenet_inditasa(void)
  2. {
  3.         double x_tavolsag, y_tavolsag, z_tavolsag, tavolsag;
  4.         long double igenyelt_x_sebesseg_mmpp, igenyelt_y_sebesseg_mmpp, igenyelt_z_sebesseg_mmpp;
  5.         long double sebesseg_kulonbseg_x, sebesseg_kulonbseg_y, sebesseg_kulonbseg_z;
  6.        
  7.         //tengelyek sebességszámolása
  8.         x_tavolsag = abszolut_ertek(kerekites_long_double(uj_cnc_x_szerszampozicio - cnc_x_szerszampozicio));
  9.         y_tavolsag = abszolut_ertek(kerekites_long_double(uj_cnc_y_szerszampozicio - cnc_y_szerszampozicio));
  10.         z_tavolsag = abszolut_ertek(kerekites_long_double(uj_cnc_z_szerszampozicio - cnc_z_szerszampozicio));
  11.        
  12.         tavolsag = kerekites_long_double(sqrt( pow(x_tavolsag,2.0) + pow(y_tavolsag,2.0) + pow(z_tavolsag,2.0))); //(tér)vektor hossza
  13.        
  14.         aktualis_x_sebesseg_mmpp = (x_tavolsag / tavolsag) * ALAP_SEBESSEG_MMPP;
  15.         aktualis_y_sebesseg_mmpp = (y_tavolsag / tavolsag) * ALAP_SEBESSEG_MMPP;
  16.         aktualis_z_sebesseg_mmpp = (z_tavolsag / tavolsag) * ALAP_SEBESSEG_MMPP;
  17.        
  18.         igenyelt_x_sebesseg_mmpp = (x_tavolsag / tavolsag) * MAX_SEBESSEG_MMPP;
  19.         igenyelt_y_sebesseg_mmpp = (y_tavolsag / tavolsag) * MAX_SEBESSEG_MMPP;
  20.         igenyelt_z_sebesseg_mmpp = (z_tavolsag / tavolsag) * MAX_SEBESSEG_MMPP;
  21.        
  22.         sebesseg_kulonbseg_x = igenyelt_x_sebesseg_mmpp - aktualis_x_sebesseg_mmpp;
  23.         sebesseg_kulonbseg_y = igenyelt_y_sebesseg_mmpp - aktualis_y_sebesseg_mmpp;
  24.         sebesseg_kulonbseg_z = igenyelt_z_sebesseg_mmpp - aktualis_z_sebesseg_mmpp;
  25.        
  26.         sebesseg_egyseg_x = sebesseg_kulonbseg_x / (GYORSITAS_LASSITAS_TAVOLSAG_MM / cnc_felbontas);
  27.         sebesseg_egyseg_y = sebesseg_kulonbseg_y / (GYORSITAS_LASSITAS_TAVOLSAG_MM / cnc_felbontas);
  28.         sebesseg_egyseg_z = sebesseg_kulonbseg_z / (GYORSITAS_LASSITAS_TAVOLSAG_MM / cnc_felbontas);
  29.        
  30. //      if(((x_tavolsag > 0) && (x_tavolsag < (GYORSITAS_LASSITAS_TAVOLSAG_MM * 2))) || ((y_tavolsag > 0) && (y_tavolsag < (GYORSITAS_LASSITAS_TAVOLSAG_MM * 2))) || ((z_tavolsag > 0) && (z_tavolsag < (GYORSITAS_LASSITAS_TAVOLSAG_MM * 2))))
  31. //      {
  32. //              sebesseg_egyseg_x = 0;
  33. //              sebesseg_egyseg_y = 0;
  34. //              sebesseg_egyseg_z = 0;
  35. //      }
  36.        
  37.         elotolas_beallitas_x(aktualis_x_sebesseg_mmpp);
  38.         elotolas_beallitas_y(aktualis_y_sebesseg_mmpp);
  39.         elotolas_beallitas_z(aktualis_z_sebesseg_mmpp);
  40.        
  41.         if(uj_cnc_x_szerszampozicio > cnc_x_szerszampozicio)
  42.         {
  43.                 x_gyorsitas_eddig = cnc_x_szerszampozicio + GYORSITAS_LASSITAS_TAVOLSAG_MM;
  44.                 x_lassitas_innen = uj_cnc_x_szerszampozicio - GYORSITAS_LASSITAS_TAVOLSAG_MM;
  45.         }
  46.         else if(uj_cnc_x_szerszampozicio < cnc_x_szerszampozicio)
  47.         {
  48.                 x_gyorsitas_eddig = cnc_x_szerszampozicio - GYORSITAS_LASSITAS_TAVOLSAG_MM;
  49.                 x_lassitas_innen = uj_cnc_x_szerszampozicio + GYORSITAS_LASSITAS_TAVOLSAG_MM;
  50.         }
  51.        
  52.         if(uj_cnc_y_szerszampozicio > cnc_y_szerszampozicio)
  53.         {
  54.                 y_gyorsitas_eddig = cnc_y_szerszampozicio + GYORSITAS_LASSITAS_TAVOLSAG_MM;
  55.                 y_lassitas_innen = uj_cnc_y_szerszampozicio - GYORSITAS_LASSITAS_TAVOLSAG_MM;
  56.         }
  57.         else if(uj_cnc_y_szerszampozicio < cnc_y_szerszampozicio)
  58.         {
  59.                 y_gyorsitas_eddig = cnc_y_szerszampozicio - GYORSITAS_LASSITAS_TAVOLSAG_MM;
  60.                 y_lassitas_innen = uj_cnc_y_szerszampozicio + GYORSITAS_LASSITAS_TAVOLSAG_MM;
  61.         }
  62.        
  63.         if(uj_cnc_z_szerszampozicio > cnc_z_szerszampozicio)
  64.         {
  65.                 z_gyorsitas_eddig = cnc_z_szerszampozicio + GYORSITAS_LASSITAS_TAVOLSAG_MM;
  66.                 z_lassitas_innen = uj_cnc_z_szerszampozicio - GYORSITAS_LASSITAS_TAVOLSAG_MM;
  67.         }
  68.         else if(uj_cnc_z_szerszampozicio < cnc_z_szerszampozicio)
  69.         {
  70.                 z_gyorsitas_eddig = cnc_z_szerszampozicio - GYORSITAS_LASSITAS_TAVOLSAG_MM;
  71.                 z_lassitas_innen = uj_cnc_z_szerszampozicio + GYORSITAS_LASSITAS_TAVOLSAG_MM;
  72.         }
  73.        
  74.         TIM2->CNT = 0;
  75.         TIM3->CNT = 0;
  76.         TIM4->CNT = 0;
  77.        
  78.         if(x_tavolsag > cnc_felbontas){ TIM_Cmd(TIM2, ENABLE); }
  79.         if(y_tavolsag > cnc_felbontas){ TIM_Cmd(TIM3, ENABLE); }
  80.         if(z_tavolsag > cnc_felbontas){ TIM_Cmd(TIM4, ENABLE); }
  81.        
  82.         cnc_allapot = G0;
  83. }


ISR:
  1. void TIM2_IRQHandler(void)
  2. {
  3.         if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  4.         {
  5.                 //gyorsítás lassítás
  6.                 if(uj_cnc_x_szerszampozicio > cnc_x_szerszampozicio)
  7.                 {
  8.                         if(cnc_x_szerszampozicio < x_gyorsitas_eddig)
  9.                         {
  10.                                 aktualis_x_sebesseg_mmpp += sebesseg_egyseg_x;
  11.                         }
  12.                        
  13.                         if(cnc_x_szerszampozicio > x_lassitas_innen)
  14.                         {
  15.                                 aktualis_x_sebesseg_mmpp -= sebesseg_egyseg_x;
  16.                         }
  17.                 }
  18.                 else if(uj_cnc_x_szerszampozicio < cnc_x_szerszampozicio)
  19.                 {
  20.                         if(cnc_x_szerszampozicio > x_gyorsitas_eddig)
  21.                         {
  22.                                 aktualis_x_sebesseg_mmpp += sebesseg_egyseg_x;
  23.                         }
  24.                        
  25.                         if(cnc_x_szerszampozicio < x_lassitas_innen)
  26.                         {
  27.                                 aktualis_x_sebesseg_mmpp -= sebesseg_egyseg_x;
  28.                         }
  29.                 }
  30.                
  31.                 elotolas_beallitas_x(aktualis_x_sebesseg_mmpp);
  32.                
  33.                 //léptetés
  34.                 if(uj_cnc_x_szerszampozicio > (cnc_x_szerszampozicio + (cnc_felbontas / 2)))
  35.                 {
  36.                         x_plusz();
  37.                 }
  38.                 else if(uj_cnc_x_szerszampozicio < (cnc_x_szerszampozicio - (cnc_felbontas / 2)))
  39.                 {
  40.                         x_minusz();
  41.                 }
  42.                 else
  43.                 {
  44.                         TIM_Cmd(TIM2, DISABLE);
  45.                         cnc_x_szerszampozicio = uj_cnc_x_szerszampozicio;
  46.                 }
  47.                
  48.                 TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  49.         }
  50. }
  51.  
  52. void TIM3_IRQHandler(void)
  53. {
  54.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
  55.         {
  56.                 //gyorsítás lassítás
  57.                 if(uj_cnc_y_szerszampozicio > cnc_y_szerszampozicio)
  58.                 {
  59.                         if(cnc_y_szerszampozicio < y_gyorsitas_eddig)
  60.                         {
  61.                                 aktualis_y_sebesseg_mmpp += sebesseg_egyseg_y;
  62.                                 elotolas_beallitas_y(aktualis_y_sebesseg_mmpp);
  63.                         }
  64.                        
  65.                         if(cnc_y_szerszampozicio > y_lassitas_innen)
  66.                         {
  67.                                 aktualis_y_sebesseg_mmpp -= sebesseg_egyseg_y;
  68.                                 elotolas_beallitas_y(aktualis_y_sebesseg_mmpp);
  69.                         }
  70.                 }
  71.                 else if(uj_cnc_y_szerszampozicio < cnc_y_szerszampozicio)
  72.                 {
  73.                         if(cnc_y_szerszampozicio > y_gyorsitas_eddig)
  74.                         {
  75.                                 aktualis_y_sebesseg_mmpp += sebesseg_egyseg_y;
  76.                                 elotolas_beallitas_y(aktualis_y_sebesseg_mmpp);
  77.                         }
  78.                        
  79.                         if(cnc_y_szerszampozicio < y_lassitas_innen)
  80.                         {
  81.                                 aktualis_y_sebesseg_mmpp -= sebesseg_egyseg_y;
  82.                                 elotolas_beallitas_y(aktualis_y_sebesseg_mmpp);
  83.                         }
  84.                 }
  85.                
  86.                 //léptetés
  87.                 if(uj_cnc_y_szerszampozicio > (cnc_y_szerszampozicio + (cnc_felbontas / 2)))
  88.                 {
  89.                         y_plusz();
  90.                 }
  91.                 else if(uj_cnc_y_szerszampozicio < (cnc_y_szerszampozicio - (cnc_felbontas / 2)))
  92.                 {
  93.                         y_minusz();
  94.                 }
  95.                 else
  96.                 {
  97.                         TIM_Cmd(TIM3, DISABLE);
  98.                         cnc_y_szerszampozicio = uj_cnc_y_szerszampozicio;
  99.                 }
  100.                
  101.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
  102.         }
  103. }
  104.  
  105. void TIM4_IRQHandler(void)
  106. {
  107.         if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
  108.         {
  109.                 //gyorsítás lassítás
  110.                 if(uj_cnc_z_szerszampozicio > cnc_z_szerszampozicio)
  111.                 {
  112.                         if(cnc_z_szerszampozicio < z_gyorsitas_eddig)
  113.                         {
  114.                                 aktualis_z_sebesseg_mmpp += sebesseg_egyseg_z;
  115.                                 elotolas_beallitas_z(aktualis_z_sebesseg_mmpp);
  116.                         }
  117.                        
  118.                         if(cnc_z_szerszampozicio > z_lassitas_innen)
  119.                         {
  120.                                 aktualis_z_sebesseg_mmpp -= sebesseg_egyseg_z;
  121.                                 elotolas_beallitas_z(aktualis_z_sebesseg_mmpp);
  122.                         }
  123.                 }
  124.                 else if(uj_cnc_z_szerszampozicio < cnc_z_szerszampozicio)
  125.                 {
  126.                         if(cnc_z_szerszampozicio > z_gyorsitas_eddig)
  127.                         {
  128.                                 aktualis_z_sebesseg_mmpp += sebesseg_egyseg_z;
  129.                                 elotolas_beallitas_z(aktualis_z_sebesseg_mmpp);
  130.                         }
  131.                        
  132.                         if(cnc_z_szerszampozicio < z_lassitas_innen)
  133.                         {
  134.                                 aktualis_z_sebesseg_mmpp -= sebesseg_egyseg_z;
  135.                                 elotolas_beallitas_z(aktualis_z_sebesseg_mmpp);
  136.                         }
  137.                 }
  138.                
  139.                 //léptetés
  140.                 if(uj_cnc_z_szerszampozicio > (cnc_z_szerszampozicio + (cnc_felbontas / 2)))
  141.                 {
  142.                         z_plusz();
  143.                 }
  144.                 else if(uj_cnc_z_szerszampozicio < (cnc_z_szerszampozicio - (cnc_felbontas / 2)))
  145.                 {
  146.                         z_minusz();
  147.                 }
  148.                 else
  149.                 {
  150.                         TIM_Cmd(TIM4, DISABLE);
  151.                         cnc_z_szerszampozicio = uj_cnc_z_szerszampozicio;
  152.                 }
  153.                
  154.                 TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
  155.         }
  156. }


Azt gondoltam hogy így 3 timerrel jobb lesz mint egyel, viszont így meg nem tudom megakadályozni a 3 timer elcsúszását.

Vissza kell írnom egy timerre, egy megszakítással és egyenes arányossággal számolni a pozíciókat és ezzel lépkedni.
(#) wbt válasza Suncorgo hozzászólására (») Jún 4, 2015 /
 
Szia! Bocsánat, hogy belekontárkodom, de szerintem a tengelyenkénti Timer-eknek csak üresjárásban van értelme, ott meg elméletileg nem számít az út "torzulása". Miért nem használsz csak 1db STEP timert? A legnagyobb aktuális sebességet úgy is a "leglassabb" tengely határozza meg. Még egy apró szakmai kérdésem lenne: azt hogyan oldod meg, hogy az előtolás sebessége állandó legyen? (gondolok itt arra, hogy egy 0,0=>0,100 egyenesnél a 0,0=>100,100 vonal 1.4-el nagyobb út).
(#) Suncorgo válasza wbt hozzászólására (») Jún 4, 2015 /
 
Ezt jó hogy eszembe juttatod. Egyenlőre úgy megy a dolog hogy a 3 tengely közül veszem a legnagyobb táv abszulútértékét és elosztom a felbontással. Ekkor kijon hogy hány lépés is kell az adott sorhoz. Ez egy számláló maximuma. Ebből a maximumból számolok mind 3 tengelynek lépési egységet amelyet majd a timer isrben beszorzok az isr lefutás számlálóval és hozzáadom az induló pozícióhoz. Ekkor kapok 3 számolt pozícióértéket. Megnézem pluszba és minuszba is mind 3 tengelyen hogy nagyobb-e az eltérés mint a gép felbontása és ha igen akkor lépek vele amerre kell egyet. Tehát nálam most lényegében a legnagyobb távolságot megtévő tengelynek van állandó sebessége és a másik kettő vagy egy tengelyé hozzáadódik.
(#) wbt válasza Suncorgo hozzászólására (») Jún 4, 2015 /
 
Szia! Szorzol? O.k. biztos van rá idő (nekem AVR-en nem volt, főleg nem lebegőpontossal). Azt hittem Bresenham a vonalhúzód. (ha jól értem, most az egyenes általános egyenletét használod, meredekséget számolva) Bresenham-nál tudsz olyat csinálni (ha fontos az állandó előtolás), hogy a Step-timer értékét szorzod 1.4-el, ha 2 tengely lép, 1.7-el ha mindhárom. A gyorsítás/lassítás meg adja magát, a leghosszabb tengelyre számolva (mert ugye a többi csak is lassabb lehet, max. ugyan annyi).
(#) Suncorgo válasza wbt hozzászólására (») Jún 5, 2015 /
 
Igen 168Mhz-ből csak telik rá egy kis idő de, inkább beillesztem a kódom, egy kód többet mond ezer szónál

Interpolátor indítás előkészítés:
  1. void cnc_G0_inditasa(void)
  2. {
  3.         long double x_tavolsag = kerekites_long_double(uj_cnc_x_szerszampozicio - cnc_x_szerszampozicio);
  4.         long double y_tavolsag = kerekites_long_double(uj_cnc_y_szerszampozicio - cnc_y_szerszampozicio);
  5.         long double z_tavolsag = kerekites_long_double(uj_cnc_z_szerszampozicio - cnc_z_szerszampozicio);
  6.        
  7.         long double legnagyobb_tavolsag = abszolut_ertek(x_tavolsag);
  8.        
  9.         if(abszolut_ertek(y_tavolsag) > legnagyobb_tavolsag) { legnagyobb_tavolsag = abszolut_ertek(y_tavolsag); }
  10.         if(abszolut_ertek(z_tavolsag) > legnagyobb_tavolsag) { legnagyobb_tavolsag = abszolut_ertek(z_tavolsag); }
  11.        
  12.         interpolator_lepes_igeny = legnagyobb_tavolsag / cnc_felbontas;
  13.         intepolator_lepes_szamlalo = 0;
  14.        
  15.         interpolator_x_indulo_pozicio = cnc_x_szerszampozicio;
  16.         interpolator_y_indulo_pozicio = cnc_y_szerszampozicio;
  17.         interpolator_z_indulo_pozicio = cnc_z_szerszampozicio;
  18.        
  19.         interpolator_x_lepes_egyseg = x_tavolsag / interpolator_lepes_igeny;
  20.         interpolator_y_lepes_egyseg = y_tavolsag / interpolator_lepes_igeny;
  21.         interpolator_z_lepes_egyseg = z_tavolsag / interpolator_lepes_igeny;
  22.        
  23.         //gyorsítás/lassítás
  24.         interpolator_aktualis_sebesseg_mmpp = ALAP_SEBESSEG_MMPP;
  25.        
  26.         elotolas_beallitas(interpolator_aktualis_sebesseg_mmpp);
  27.        
  28.         interpolator_elotolas_kulonbseg = MAX_SEBESSEG_MMPP - ALAP_SEBESSEG_MMPP;
  29.         interpolator_elotolas_egyseg = interpolator_elotolas_kulonbseg / (GYORSITAS_LASSITAS_TAVOLSAG_MM / cnc_felbontas);
  30.         interpolator_gyorsitas_eddig_lepes = GYORSITAS_LASSITAS_TAVOLSAG_MM / cnc_felbontas;
  31.         interpolator_lassitas_innen_lepes = interpolator_lepes_igeny - (GYORSITAS_LASSITAS_TAVOLSAG_MM / cnc_felbontas);
  32.        
  33.         TIM2->CNT = 0;
  34.         cnc_allapot = G0;
  35.         TIM_Cmd(TIM2, ENABLE);
  36. }


ISR:
  1. void linearis_interpolator_ISR()
  2. {
  3.         //gyorsítás lassítás
  4.         if(intepolator_lepes_szamlalo < interpolator_gyorsitas_eddig_lepes)
  5.         {
  6.                 interpolator_aktualis_sebesseg_mmpp += interpolator_elotolas_egyseg;
  7.                 elotolas_beallitas(interpolator_aktualis_sebesseg_mmpp);
  8.         }
  9.        
  10.         if(intepolator_lepes_szamlalo > interpolator_lassitas_innen_lepes)
  11.         {
  12.                 interpolator_aktualis_sebesseg_mmpp -= interpolator_elotolas_egyseg;
  13.                 elotolas_beallitas(interpolator_aktualis_sebesseg_mmpp);
  14.         }
  15.        
  16.         interpolator_szamolt_x_pozicio = kerekites_long_double(interpolator_x_indulo_pozicio + (interpolator_x_lepes_egyseg * intepolator_lepes_szamlalo));
  17.         interpolator_szamolt_y_pozicio = kerekites_long_double(interpolator_y_indulo_pozicio + (interpolator_y_lepes_egyseg * intepolator_lepes_szamlalo));
  18.         interpolator_szamolt_z_pozicio = kerekites_long_double(interpolator_z_indulo_pozicio + (interpolator_z_lepes_egyseg * intepolator_lepes_szamlalo));
  19.        
  20.         //x léptetés
  21.         if(interpolator_szamolt_x_pozicio >= kerekites_long_double(cnc_x_szerszampozicio + cnc_felbontas))
  22.         {
  23.                 x_plusz();
  24.         }
  25.        
  26.         if(interpolator_szamolt_x_pozicio <= kerekites_long_double(cnc_x_szerszampozicio - cnc_felbontas))
  27.         {
  28.                 x_minusz();
  29.         }
  30.        
  31.         //y léptetés
  32.         if(interpolator_szamolt_y_pozicio >= kerekites_long_double(cnc_y_szerszampozicio + cnc_felbontas))
  33.         {
  34.                 y_plusz();
  35.         }
  36.        
  37.         if(interpolator_szamolt_y_pozicio <= kerekites_long_double(cnc_y_szerszampozicio - cnc_felbontas))
  38.         {
  39.                 y_minusz();
  40.         }
  41.        
  42.         //z léptetés
  43.         if(interpolator_szamolt_z_pozicio >= kerekites_long_double(cnc_z_szerszampozicio + cnc_felbontas))
  44.         {
  45.                 z_plusz();
  46.         }
  47.        
  48.         if(interpolator_szamolt_z_pozicio <= kerekites_long_double(cnc_z_szerszampozicio - cnc_felbontas))
  49.         {
  50.                 z_minusz();
  51.         }
  52.        
  53.         //interpolator
  54.         if(intepolator_lepes_szamlalo < interpolator_lepes_igeny)
  55.         {
  56.                 intepolator_lepes_szamlalo++;
  57.         }
  58.         else
  59.         {
  60.                 TIM_Cmd(TIM2, DISABLE);
  61.                 cnc_valasz = GKOD_OK;
  62.                 cnc_allapot = KESZENLET;
  63.         }
  64. }
  65.  
  66. void elotolas_beallitas(double mmpp)
  67. {
  68.         TIM2->ARR = (65536 / (((mmpp / 60) * cnc_lepes_per_mm) / 30.52)) - 1;
  69. }


Ezt a Bresenham vonalhúzást áttanulmányozom a nagyobb sebesség érdekében és megpróbálom implementálni.
(#) wbt válasza Suncorgo hozzászólására (») Jún 5, 2015 /
 
Hát igen, az erőmű... Én igaz, hogy 16MHz/AVR-re és csak 2D-t csináltam, de 5000step/sec-el tudtam menni (úgy, hogy HPGL volt a bejárat, az fordult 2-felé, ha karakter volt a kérés, akkor lebontotta vektorkra, átszaladt egy transzformációs mátrixon, hogy lehessen csűrni-csavarni-hajlítani a karakterképeket és ment a stepper pufferbe, mindeközben tapicsos grafikus LCD-n, ha kellett szimulálta a rajzolatot vagy menüzött). Szóval nem kötelező ezt használni, ha bírja a cucc és nagyon mással nem kell foglalkoznia (igazából grafikailag duplázható az algoritmus sebessége, de az most Neked nem jó). Ha nem boldogulsz, papíron csináld meg mondjuk a 0,0=>17,3 vonalat (direkt ilyen elvetemült számok), azonnal megérted a működését.
(#) killbill válasza wbt hozzászólására (») Jún 5, 2015 /
 
Idézet:
„Szorzol? O.k. biztos van rá idő”
1 orajel a 32x32 bit.
(#) Suncorgo válasza wbt hozzászólására (») Jún 5, 2015 /
 
Most nálam 420mm/perc a biztonságos sebesség, mármint amelyik tengelyen (Z) a marómotor súlya van. (a többi megy gyosabban is) 3db NEMA17 léptetőmocival, DRV2588 meghajtókkal. M6 menetes szár 2db kotyogásmentesre ellenfeszített anyával minden tengelyen. 8-as mikrolépésben. 1mm menetemelkedés. Most a G0 11200 lépés/sec-re van korlátozva és nem a CPU sebesség szab határt hanem a táp 12V-ja. Ha ettől jobban gyorsítok akkor annyira lecsökken a léptetőmotorok áramfelvétele (ugye a forgatónyomatékkal együtt) hogy kap egy kis terhelés és már meg is állt. Nincs visszacsatolás, útmérő. Így inkább lassabban menjen de ne tévedjen, pontosan (lépésvesztés).

Közben rájöttem hogy annyit nem nyerek rajta hogy megérje átírni az interpolátorom. Szóval maradt
A hozzászólás módosítva: Jún 5, 2015
(#) wbt válasza killbill hozzászólására (») Jún 5, 2015 /
 
Ezt én is tudom, ..
Többi üzenetem kitöröltem, nem akarok hitvitát a 32-bit aritmetika / egész között.
Jó, most nincs kiélezve a feladat, de a töltögetést/komparálást is számold már hozzá...mindegy, kiszálltam, csak segíteni akartam...
(#) wbt válasza Suncorgo hozzászólására (») Jún 5, 2015 /
 
ja, hát vast azt nem ismertetted eddig, ha ennyi elég, akkor elég... már bocs, de 12V táp...az nagyon keskeny. Én anno 24V /20A-el is szenvedtem, most meg előfordul 70V/350A csúcsban. Szerintem, ha jót akarsz, növeld a tápfeszt.
Bevégeztem...JAni
(#) kapu48 válasza wbt hozzászólására (») Jún 5, 2015 /
 
Tisztelt Wbt!
Nehogy megsértődj már!
Hasznosak voltak a hszek nem szabad törölni! Kérjük vissza!

Most kezd érdekes lenni a téma, jól jönnek a tapasztalt hozzáértők!
Szerintem, majd ahogy szaporodnak a feladatok, és kezd kifulladni a proceszor idő, rájön, hogy spórolni kel az erőforrásosokkal!

Én pl. eddig azt hitem, hogy szervomotort akarunk vezérelni!
Ha viszont léptetőmotor, akkor mért nem lépésszámlálással mérjük az út hosszát?
(#) kapu48 válasza killbill hozzászólására (») Jún 5, 2015 /
 
Tisztelt killbill!
Honnan veted az 1 szorzás 1 órajel adatot?
Itt pl. nem találok erre utalást, 3.6 Multiply and divide instructions :
STM32F4 Series Cortex®-M4 programming manual

Ha hozzá kalkuláljuk a regiszterek feltöltését is?
  1. Examples
  2. MUL R10, R2, R5 ; multiply, R10 = R2 x R5
  3. MLA R10, R2, R1, R5 ; multiply with accumulate, R10 = (R2 x R1) + R5
  4. MULS R0, R2, R2 ; multiply with flag update, R0 = R2 x R2
  5. MULLT R2, R3, R2 ; conditionally multiply, R2 = R3 x R2
  6. MLS R4, R5, R6, R7 ; multiply with subtract, R4 = R7 - (R5 x R6)
(#) killbill válasza kapu48 hozzászólására (») Jún 5, 2015 /
 
Az emlekeimbol vettem. Es meg az is lehet, hogy 2 orajel. De a szorzas, az szorzas es nem regiszter toltogetes. Igazabol csak azert irtam, mert mar megszoktuk, hogy a szorzas az nagyon draga muvelet, de ARM-en (mondjuk M3-mon) nem dragabb, mint egy osszeadas.
(#) kapu48 válasza killbill hozzászólására (») Jún 5, 2015 /
 
Bocsi!

A kérdésem lényege a forrás lett volna, ahol az utasításokhoz szükséges órajelekre található utalás!
(#) killbill válasza kapu48 hozzászólására (») Jún 6, 2015 / 1
 
Bővebben: Link
(#) killbill válasza wbt hozzászólására (») Jún 6, 2015 /
 
Idézet:
„Szorzol? O.k. biztos van rá idő (nekem AVR-en nem volt,”
AVR vs. ARM. En csak ehhez szoltam hozza.
(#) kapu48 válasza killbill hozzászólására (») Jún 6, 2015 /
 
Köszönöm!
(#) gtk válasza kapu48 hozzászólására (») Jún 6, 2015 /
 
Idézet:
„Ha viszont léptetőmotor, akkor mért nem lépésszámlálással mérjük az út hosszát?”
Peldaul azert, mert ha egy lepes kiesik, nincs informaciod rola.
(#) kapu48 válasza gtk hozzászólására (») Jún 6, 2015 /
 
„Peldaul azert, mert ha egy lepes kiesik, nincs informaciod rola.” ???
Ezt most abszolúte nem értem!

Miért, ha nincsen visszajelzésed, bármilyen módszerrel lesz valami infód a ténylegesen megtett
útról?

A jobbak épen ezért használnak szervomotort, és enkodert!
A hozzászólás módosítva: Jún 6, 2015
(#) kapu48 válasza wbt hozzászólására (») Jún 6, 2015 /
 
A 12V-os meghajtás szerintem is édes kevés lesz!

Kellene legalább a duplája. És tengelyenként megoldani a PWM-es leszabályozását álló helyzetben, csak kisebb tartó fessz kel.
Különben túlmelegszenek a motorok.
A hozzászólás módosítva: Jún 6, 2015
Ezekre szükség lehet! - HESTORE.HU

NEMA17-CABLE-100
24/8mm WH
MAX6921AWI+
330 K 1%
VMD-52
Következő: »»   60 / 177
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem