Управление PWM в определенном алгоритме

marov.a · 2016-09-22 23:39:27

Помогите,пожалуйста,советом или предложением. Не могу связать в кучу несколько функций. Описание на фото, я думаю в графическом виде более наглядно.

R-потенциометры на аналоговых входах
Сигнал запуска на любом цифровом
PWM- один выход.

vvr · 2016-09-23 07:41:12

а зачем потенциометры

marov.a · 2016-09-23 08:47:33

Для быстрой, простой и наглядной регулировки данного сигнала в любой момент.Если сделать кнопочное управление- будет не так визуально понятно что на сколько.

vvr · 2016-09-23 08:57:56

вы не написали что будет визуализация процесса

так в чём проблемка ?
картинка понятно
кода никто не видит

NoName · 2016-09-23 09:11:29

vvr, я думаю что он хочет алгоритм и код

R1-R5 крутилки для коррекции характеристик сигнала )

marov.a, если сами не хочете делать закажите юному дарованию что "скетчь $" пишет )
или мне за какую то плюшку с магазина ), но макет давайте сами соберете, а то плюшек в магазине ( http://arduino-ua.com/ ) не хватит )

вот только характеристики PWM не указаны, может ему нужен 32битный )

marov.a · 2016-09-23 13:05:18

Визуализация- расположение потенциометров. У меня не получается связать в кучу считывание показаний потенциометров с выполнением процесса. ШИМ стандартный 0-255, макет я сам соберу, все равно его придется внедрять в уже существующие рамки силовой части. Я не прошу сделать все за меня бесплатно))))Приятное и плодотворное сотрудничество всегда более плодоносное)))

NoName · 2016-09-23 13:12:09

у Вас 4 state work и один wait , условно
state 2, 4 расчетные
давайте я Вам вечером напишу основу, проверите сами.
в дар приму что то из инструментов, по результатам работы )

объясните точку завершения, не понял

Остання редакція NoName (2016-09-23 13:14:12)

marov.a · 2016-09-23 13:24:36

точка запуска- появление 1 на входе
точка завершения- возврат с 1 к 0 на том-же входе

NoName · 2016-09-23 13:31:15

что делать когда длительность TR2 больше чем длительность удержания кнопки? т.е. т.н. нештатное завершение задачи для Вашей картинки

marov.a · 2016-09-23 16:29:47

Выполнение TR5 с величины шим данного момента

qwone · 2016-09-23 17:26:09

Лучше и проще решать такую задачу в 2 вычислительных потока. 1 - поток задаваемая функция, 2 сьем информации с потенциометров и перевод в переменные.
Вот примерно шаблон для создания такой программы.
ПС: Пока мешать не буду вашему творчеству своим кодом.

//#1
  void setup1(){
  }
  void loop1(){
  }
//#2
  void setup2(){
  }
  void loop2(){
  }
//#3
  void setup3(){
  }
  void loop3(){
  }
void setup() {
//#1
  setup1();
//#2
  setup2();
//#3
  setup3();
}

void loop() {
  static uint32_t MILLIS ;
  MILLIS = millis() ; 

//#1 1000 миллисекунд вычислит. поток 1
  static uint32_t future1 = 0 ;
  if (MILLIS>=future1) {
  future1 = MILLIS + 1000 ;
  loop1();
  MILLIS = millis() ;    
  }
//#2  200 миллисекунд вычислит. поток 2
  static uint32_t future2 = 0 ;
  if (MILLIS>=future2) {
  future2 = MILLIS + 200 ;
  loop2();
  MILLIS = millis() ;    
  }
//#3  100 миллисекунд вычислит. поток 3
  static uint32_t future3 = 0 ;
  if (MILLIS>=future3) {
  future3 = MILLIS + 100 ;
  loop3();  
  }
}

Остання редакція qwone (2016-09-23 17:28:13)

vvr · 2016-09-23 18:28:46

если на входе 1 то запускается цикл
по окончании цикла проверяем вход
если 0 то ничего
если 1 то цикл повторяется
так ?

marov.a · 2016-09-23 20:22:57

Есть точка начала- на вход поступает 1...начинается цикл TR2 по окончанию которого шим переходит в режим R4 и длится до переключения входа с 1 до 0( не регламентировано по времени). При появлении 0-я выполняется цикл TR5. Как правильно задал вопрос NoName- не зависимо от этапа выполнения, если появляется 0, выполняется TR2 с размерности шим присутствующей в данный момент до 0.

NoName · 2016-09-23 20:42:03

ну так, небольшой набросок )
del,
см ниже

Остання редакція NoName (2016-09-24 13:35:17)

vvr · 2016-09-23 21:03:41

те TR2 - 3 выполняется по-любому

NoName · 2016-09-23 21:15:40

Сегодня 21:03:41
vvr, думаю нет,
при аварийном выходе, активация ST_TIME_R5,
код не дописан, но основа прописана, завтра допишу )

marov.a · 2016-09-23 21:43:16

у меня Leonardo пока пишет так
Arduino: 1.6.11 (Windows 10), TD: 1.30, Плата:"Arduino Leonardo"

C:\Users\РђРґРјРёРЅРёСЃС‚СЂР°С‚РѕСЂ\Desktop\sketch_sep23a\sketch_sep23a.ino:13:19: fatal error: Timer.h: No such file or directory

compilation terminated.

exit status 1
Ошибка компиляции для платы Arduino Leonardo.

NoName · 2016-09-23 21:50:38

http://www.doctormonk.com/2012/01/ardui … brary.html
я сам пока не смотрел, да и проверить не на чем,
потому сами.
пока посмотрите код, время работы таска не реализовано,но то ет мелочи, основу посмотрите, все понятно?

marov.a · 2016-09-23 22:04:53

спс, подгрузил библиотеку, компилировал, загрузил....сейчас разбираю.
typedef enum {
R1 = A0,
R2 = A1,
R3 = A2,
R4 = A3,
R5 = A4,
} TE_IO_NAME;

and

// potentiometer wiper (middle terminal) connected to digital pin
int input_array_pin[] = {3,3,3,3,3};
int out_pwm_pin = 13;
int digi_start_pin = 8;

qwone · 2016-09-23 22:05:21

marov.a пише:

у меня Leonardo пока пишет так
C:\Users\РђРґРјРёРЅРёСЃС‚СЂР°С‚РѕСЂ\Desktop\sketch_sep23a\sketch_sep23a.ino:13:19: fatal error: Timer.h: No such file or directory

Пишет что надо поставить библиотеку в систему. И кроме вас никто не сможет это сделать. Потому что надо руками.

Эскиз ->include library -> menage libraries ну и там ищи .

marov.a · 2016-09-23 22:14:04

qwone пише:

marov.a пише:
у меня Leonardo пока пишет так
C:\Users\РђРґРјРёРЅРёСЃС‚СЂР°С‚РѕСЂ\Desktop\sketch_sep23a\sketch_sep23a.ino:13:19: fatal error: Timer.h: No such file or directory
Пишет что надо поставить библиотеку в систему. И кроме вас никто не сможет это сделать. Потому что надо руками.
Эскиз ->include library -> menage libraries ну и там ищи .

Уже поставил спс...

marov.a · 2016-09-23 22:37:03

Теперь представляю какого мне объема инфы не хватает для решения этой задачи самостоятельно....

NoName · 2016-09-24 13:34:13

код немного сложноват для блокнота (((
убрал таймер (, я думал что ето системная либа

код "на посмотреть" удалил, там явно не дописано
в общем посмотрите, а то я не уверен что все там работает ), блокировки защитные позже допишу

этот кусок Вы правите под себя

int input_array_pin[] = { 4,6,8,9,10 };
int out_pwm_pin = 3;
int digi_start_pin = 12;

del

обновленная версия ниже

Остання редакція NoName (2016-09-26 21:04:15)

marov.a · 2016-09-24 14:16:52

pinMode (out_pwm_pin, OUTPUT); // sets the pin as output
pinMode (LED_PIN_DEMO, OUTPUT); // sets the pin as output
??? set_new_pwm ( 0 ); // disable pwm

здесь чего то не хватает? компилятор ругается

NoName · 2016-09-24 17:10:33

поставил
arduino leonardo

Sketch uses 7,408 bytes (25%) of program storage space. Maximum is 28,672 bytes.
Global variables use 286 bytes (11%) of dynamic memory, leaving 2,274 bytes for local variables. Maximum is 2,560 bytes.
пробуйте

/*
 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 00):
 * <devgate.info эт gmail.com> wrote this file.  As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer or device ( arduino-ua.com ) in return.   
 * Chingiz Sunlucid 
 * ----------------------------------------------------------------------------
 *  Date : 2016.09.24  
 * ----------------------------------------------------------------------------
 */
 
// ARDUINO PIN  CONFIG
// for example
// Arduino leonardo

/*
Input and Output

Each of the 20 digital i/o pins on the Leonardo can be used as an input or output, using pinMode(), digitalWrite(), and digitalRead() functions. They operate at 5 volts. Each pin can provide or receive a maximum of 40 mA and has an internal pull-up resistor (disconnected by default) of 20-50 kOhms. In addition, some pins have specialized functions:

Serial: 0 (RX) and 1 (TX). Used to receive (RX) and transmit (TX) TTL serial data using the ATmega32U4 hardware serial capability. Note that on the Leonardo, the Serial class refers to USB (CDC) communication; for TTL serial on pins 0 and 1, use the Serial1 class.
TWI: 2 (SDA) and 3 (SCL). Support TWI communication using the Wire library.
External Interrupts: 3 (interrupt 0), 2 (interrupt 1), 0 (interrupt 2), 1 (interrupt 3) and 7 (interrupt 4). These pins can be configured to trigger an interrupt on a low value, a rising or falling edge, or a change in value. See the attachInterrupt() function for details.
PWM: 3, 5, 6, 9, 10, 11, and 13. Provide 8-bit PWM output with the analogWrite() function.
SPI: on the ICSP header. These pins support SPI communication using the SPI library. Note that the SPI pins are not connected to any of the digital I/O pins as they are on the Uno, They are only available on the ICSP connector. This means that if you have a shield that uses SPI, but does NOT have a 6-pin ICSP connector that connects to the Leonardo's 6-pin ICSP header, the shield will not work.
LED: 13. There is a built-in LED connected to digital pin 13. When the pin is HIGH value, the LED is on, when the pin is LOW, it's off.
Analog Inputs: A0-A5, A6 - A11 (on digital pins 4, 6, 8, 9, 10, and 12). The Leonardo has 12 analog inputs, labeled A0 through A11, all of which can also be used as digital i/o. Pins A0-A5 appear in the same locations as on the Uno; inputs A6-A11 are on digital i/o pins 4, 6, 8, 9, 10, and 12 respectively. Each analog input provide 10 bits of resolution (i.e. 1024 different values). By default the analog inputs measure from ground to 5 volts, though is it possible to change the upper end of their range using the AREF pin and the analogReference() function.
There are a couple of other pins on the board:

AREF. Reference voltage for the analog inputs. Used with analogReference().
Reset. Bring this line LOW to reset the microcontroller. Typically used to add a reset button to shields which block the one on the board.
*/

// potentiometer wiper (middle terminal) connected to analog pin
//int input_array_pin[] = { A0,A1,A2,A3,A4 };
int input_array_pin[] = { 4,6,8,9,10 };
int out_pwm_pin        = 3;
int digi_start_pin      = 12;
int LED_PIN_DEMO      = 13;  /* use PWM, for control */

// 8 bit PWM
#define MAX_RESOLUTION_PWM  0xFF
// 16 bit PWM
// #define MAX_RESOLUTION_PWM  0xFFFF

 
typedef enum { // enum name task 
ST_WAIT         = 0,
ST_TIME_R2      = 1,
ST_TIME_R3      = 2,
ST_PWM_R4       = 3,
ST_TIME_R5      = 4,
}TE_STATE;

typedef enum {
TIMER_EXE       = 0,
TIMER_DISABLED  = 1,
TIMER_RUN       = 2,
}TE_TIMER;

 

typedef enum { // noedit, name ( mem data sarray )
R1 = 0,
R2 = 1,
R3 = 2,
R4 = 3,
R5 = 4,
} TE_IO_NAME;


#define BIT(x)        (1 << (x))
#define CHECKBIT(x,b)   (x&(b))
#define SETBIT(x,b)     x|=(b)
#define CLEARBIT(x,b)   x&=~(b)
#define TOGGLEBIT(x,b)  x^=(b)
#define count_element_array(x)  sizeof(x)/sizeof(x[0])

#define DEBUG
#define DEBUG_PWM


#define DEBOUNCE_TIME 100
#define TASK_PROCESS_TIME 10

 
// uncomment for disable debug info, or delete  line #define DEBUG
// #undef DEBUG

typedef struct {
 unsigned long    time_unit[5];  
 unsigned short   pwm_unit [5];  
 unsigned short   current_pwm;   // for 16bit pwm chip
 unsigned long    time_start_key_press;
 unsigned long    time_start_key_un_press;
 uint16_t       key_status;
 TE_STATE     state;  
 } td_system; 

typedef struct { // float not optimal, easy code
 float      pwm_start;  
 float      pwm_end;  
 float      pwm_delta;  
 unsigned long  count_step; 
} td_temp_falling; 

 td_system    system_demo_pwm; 
 td_temp_falling  temp_falling; 
 
 unsigned long get_value_from_percent ( unsigned long percent, unsigned long  max_value );
unsigned long get_percent_from_value ( unsigned long xxx, unsigned long  max_value );
void set_new_pwm  (  unsigned short data );
void prepare_new_state  ( TE_STATE new_state );
void decode_input_data ( void );
void manual_stop_system ( void );
TE_TIMER programm_count_down_uint16 ( unsigned short *timer , unsigned char shift );
TE_TIMER programm_count_down_uint32 ( unsigned long *timer , unsigned long shift );
TE_TIMER system_delay_uint32 ( unsigned long *timer , unsigned long shift );
void key_function ( void );
void event_task();
void get_analog_config_system (void);

 
// R1 - value PWM1                ( pwm_unit[0] )
// R2 - state1  time  ( 0..10 sec ), PWM1   ( pwm_unit[1] )
// R3 - state2  time  ( 0..10 sec )     ( pwm_unit[2] )
// R4 - state3  value PWM2          ( pwm_unit[3] )
// R5 - state4 time  ( 0..10 sec )      ( pwm_unit[4] )
//---------------------------------------------------
int in_r_value[count_element_array(input_array_pin)];           // variable to store the value read
//---------------------------------------------------
// funtion provide hw setup system demo pwm.
void setup()
{
 int foo;
 system_demo_pwm.time_start_key_press    = DEBOUNCE_TIME;
 system_demo_pwm.time_start_key_un_press  = DEBOUNCE_TIME;
 
 for ( foo = 0; foo < count_element_array(input_array_pin); foo ++ )
 {
  // set mode pin input 
 }

 pinMode     (out_pwm_pin, OUTPUT);   // sets the pin as output
 pinMode     (LED_PIN_DEMO, OUTPUT);   // sets the pin as output
 set_new_pwm ( 0 );   // disable pwm
 
 pinMode     (digi_start_pin, INPUT);   // sets the pin as input
 Serial.begin(9600);          //  setup serial

}

  
unsigned long get_value_from_percent ( unsigned long percent, unsigned long  max_value )
{
  unsigned long  ret;
  // max_value - 100 %
  //  x      percent
  ret = (unsigned long)((unsigned long)max_value*(unsigned long)percent)/(unsigned long)100;
  return  (ret);
}

unsigned long get_percent_from_value ( unsigned long xxx, unsigned long  max_value )
{
  unsigned long  ret;
  // max_value - 100 %
  //  xxx     percent
  ret = (unsigned long)((unsigned long)xxx*(unsigned long)100/(unsigned long)max_value);
  return  (ret);
}
 

void set_new_pwm  (  unsigned short data )
{
#ifdef DEBUG_PWM
 static  unsigned short old_pwm = 0xFFFF;
 
  if ( data != old_pwm )
  {
   Serial.print("pwm: "); Serial.println(data);
   data = old_pwm;
  }
#endif
  
  system_demo_pwm.current_pwm      = data;
  analogWrite ( out_pwm_pin,  data );
#ifdef DEBUG 
  analogWrite ( LED_PIN_DEMO,   data );
#endif
}
 
void prepare_new_state  ( TE_STATE new_state )
{

 #ifdef DEBUG 
  Serial.print("set new state "); Serial.println(new_state);
 #endif

 // system_demo_pwm.pwm_unit  [R1];
 // 
 
 system_demo_pwm.time_unit [R2];
 // system_demo_pwm.time_unit [R3];
 // system_demo_pwm.pwm_unit  [R4];
 // system_demo_pwm.time_unit [R5];
 switch ( new_state )
 {
  case  ST_WAIT : // disable all 
     set_new_pwm ( 0 );
  break;
  
  case  ST_TIME_R2 : // start 
     set_new_pwm          ( system_demo_pwm.pwm_unit[R1] );
     temp_falling.pwm_start       = system_demo_pwm.pwm_unit[R1];
     temp_falling.pwm_end       = system_demo_pwm.pwm_unit[R1];  
     temp_falling.pwm_delta     = 0;
     break;
   
  case  ST_TIME_R3 : // falling 
     set_new_pwm          ( system_demo_pwm.pwm_unit[R1] );
     temp_falling.count_step    = system_demo_pwm.time_unit[R3] / TASK_PROCESS_TIME; 
     temp_falling.pwm_start     = system_demo_pwm.pwm_unit[R1];
     temp_falling.pwm_end       = system_demo_pwm.pwm_unit[R4];
     temp_falling.pwm_delta     = (temp_falling.pwm_start - temp_falling.pwm_end ) / (float)temp_falling.count_step;
  break;  

  case  ST_PWM_R4: // line 
    set_new_pwm           ( system_demo_pwm.pwm_unit[R3] );
  break;  
  
  case ST_TIME_R5:
    set_new_pwm           ( system_demo_pwm.current_pwm );
    temp_falling.count_step     = system_demo_pwm.time_unit[R5] / TASK_PROCESS_TIME; 
    temp_falling.pwm_start      = system_demo_pwm.current_pwm;
    temp_falling.pwm_end      = 0;
    temp_falling.pwm_delta      = temp_falling.pwm_start / (float)temp_falling.count_step;
  break;  
  } 
  system_demo_pwm.state = new_state;
 }

//-------------------------------------------------------

void decode_input_data ( void )
{ 
 int foo;

//  R1 (0-1024) value PWM1 
 unsigned long  ui_temp;
 
 // get pwm1
 ui_temp      = get_percent_from_value( input_array_pin[0],1024 );
 system_demo_pwm.pwm_unit[R1] = get_value_from_percent( ui_temp, MAX_RESOLUTION_PWM        );
 
 // get time1   R2
 ui_temp      = get_percent_from_value( input_array_pin[1],1024 );
 system_demo_pwm.time_unit[R2] = get_value_from_percent( ui_temp,10000     ); // 10 sec
 
 // get time2   R3
 ui_temp      = get_percent_from_value( input_array_pin[2],1024 );
 system_demo_pwm.time_unit[R3] = get_value_from_percent( ui_temp,10000     ); // 10 sec

  // disable incorrect time setting  
 if ( (system_demo_pwm.time_unit[R2] + system_demo_pwm.time_unit[R3]) > 10000 )
 system_demo_pwm.time_unit[R3] = system_demo_pwm.time_unit[R3] / 2;

 // get pwm R4
 ui_temp      = get_percent_from_value( input_array_pin[3],1024 );
 system_demo_pwm.pwm_unit[R4] = get_value_from_percent( ui_temp,MAX_RESOLUTION_PWM   );

 // get time   R5
 ui_temp      = get_percent_from_value( input_array_pin[4],1024 );
 system_demo_pwm.time_unit[R5] = get_value_from_percent( ui_temp,10000     ); // 10 sec
 
 
#ifdef DEBUG
for ( foo = 0; foo < 4; foo ++ )
{
  Serial.print("time_unit[");  Serial.print(foo); Serial.print("] = ");
  Serial.println(system_demo_pwm.time_unit[foo]);
}

for ( foo = 0; foo < 4; foo ++ )
{
  Serial.print("pwm_unit[");  Serial.print(foo); Serial.print("] = ");
  Serial.println(system_demo_pwm.pwm_unit[foo]);
}
#endif 
}

void manual_stop_system ( void )
{

  prepare_new_state (ST_TIME_R5);

#ifdef DEBUG
  int foo = ST_TIME_R5;
  Serial.print("time_unit[");  Serial.print(foo); Serial.print("] = ");
  Serial.println(system_demo_pwm.time_unit[foo]);
  Serial.print("pwm_unit[");  Serial.print(foo); Serial.print("] = ");
  Serial.println(system_demo_pwm.pwm_unit[foo]);
#endif 

}


TE_TIMER programm_count_down_uint16 ( unsigned short *timer , unsigned char shift )
{
    if (*timer > 0 )
    {
      if (*timer > shift )
      {
        *timer -= shift;
        return TIMER_RUN;
      }
       else
      {
         *timer = 0;
         return TIMER_EXE;
      }
    }
  return TIMER_DISABLED;
}

TE_TIMER programm_count_down_uint32 ( unsigned long *timer , unsigned long shift )
{
    if (*timer > 0 )
    {
      if (*timer > shift )
      {
        *timer -= shift;
        return TIMER_RUN;
      }
       else
      {
         *timer = 0;
         return TIMER_EXE;
      }
    }
  return TIMER_DISABLED;
}


TE_TIMER system_delay_uint32 ( unsigned long *timer , unsigned long shift )
{
    if ( *timer > 0 )
    {
      if (*timer > shift )
      {
        *timer -= shift;
        return TIMER_RUN;
      }
       else
      { // save delta time
         *timer =  ( shift - *timer );
         return TIMER_EXE;
      }
    }
  return TIMER_DISABLED;
}


void key_function ( void )
{
   TE_TIMER  status; 
   
  if ( digitalRead(digi_start_pin))  
  {
   status = programm_count_down_uint32 (&system_demo_pwm.time_start_key_press, TASK_PROCESS_TIME);
   switch ( status )
   {
    case TIMER_EXE:
    case TIMER_DISABLED:
    system_demo_pwm.key_status = 1;
    break;
   }
  } else {
   
   system_demo_pwm.time_start_key_press = DEBOUNCE_TIME;
   status = programm_count_down_uint32 (&system_demo_pwm.time_start_key_un_press, TASK_PROCESS_TIME);

   switch ( status )
   {
    case TIMER_EXE:
      case TIMER_DISABLED:
    system_demo_pwm.key_status = 0;
    break;
   }
  }
}
 
 
void event_task()
{
   TE_TIMER  status; 
   key_function ();
   if ( system_demo_pwm.state == ST_WAIT  ) return;
   switch  ( system_demo_pwm.state )
   {
    //----------------------------------------
     case ST_TIME_R2:  
   status = programm_count_down_uint32 (&system_demo_pwm.time_unit[R2], TASK_PROCESS_TIME);
   switch ( status )
   {
    case TIMER_EXE:
    case TIMER_DISABLED:
      prepare_new_state(ST_TIME_R3);
    break;
    case TIMER_RUN:
     break;   
   }
   break;  
     //----------------------------------------
   case ST_TIME_R3: 
   status = programm_count_down_uint32 (&temp_falling.count_step, 1);
   switch ( status )
   {
    case TIMER_EXE:
    case TIMER_DISABLED:
      prepare_new_state(ST_PWM_R4);
    break;
    
    case TIMER_RUN:
      set_new_pwm ( system_demo_pwm.pwm_unit[1] );
      programm_count_down_uint16 (&system_demo_pwm.pwm_unit[1], temp_falling.pwm_delta);
     break;   
   }
   break;  
   //----------------------------------------
   case ST_PWM_R4: 
      // analogWrite(out_pwm_pin, system_demo_pwm.pwm_unit[R4])
   break;  
   //----------------------------------------
   case ST_TIME_R5: 
  
  status = programm_count_down_uint32 (&temp_falling.count_step, 1);
   switch ( status )
   {
    case TIMER_EXE:
    case TIMER_DISABLED:
      prepare_new_state(ST_WAIT);
    break;
    
    case TIMER_RUN:
      set_new_pwm ( system_demo_pwm.pwm_unit[4] );
      programm_count_down_uint16 (&system_demo_pwm.pwm_unit[4], temp_falling.pwm_delta);
     break;   
   }
  break;  
  //----------------------------------------
   }
 }

void get_analog_config_system (void)
{
 int foo;
 for ( foo = 0; foo < count_element_array(input_array_pin); foo ++ )
 { 
  in_r_value[foo] = analogRead ( input_array_pin[foo] );    // read the input pin
 }
}

void loop()
{
 static unsigned long  task_time; 
 TE_TIMER  status; 

 unsigned long  delta_task_time; 

 if (  system_demo_pwm.state  == ST_WAIT ) 
 {
   get_analog_config_system();
   if ( system_demo_pwm.key_status )  prepare_new_state (1);
 }
 else 
 {
   if (  system_demo_pwm.state != ST_TIME_R5 ) 
   if ( !system_demo_pwm.key_status )  manual_stop_system();
 }
 
 delta_task_time = millis();
 status = system_delay_uint32 ( task_time, delta_task_time );
 
 switch ( status )
 {
    case TIMER_EXE:
    case TIMER_DISABLED:
    task_time += DEBOUNCE_TIME; 
        event_task();
    break;
    
    case TIMER_RUN:
     break;   
 }
}

Форум arduino.ua

#1 2016-09-22 23:39:27

Управление PWM в определенном алгоритме

#2 2016-09-23 07:41:12

Re: Управление PWM в определенном алгоритме

#3 2016-09-23 08:47:33

Re: Управление PWM в определенном алгоритме

#4 2016-09-23 08:57:56

Re: Управление PWM в определенном алгоритме

#5 2016-09-23 09:11:29

Re: Управление PWM в определенном алгоритме

#6 2016-09-23 13:05:18

Re: Управление PWM в определенном алгоритме

#7 2016-09-23 13:12:09

Re: Управление PWM в определенном алгоритме

#8 2016-09-23 13:24:36

Re: Управление PWM в определенном алгоритме

#9 2016-09-23 13:31:15

Re: Управление PWM в определенном алгоритме

#10 2016-09-23 16:29:47

Re: Управление PWM в определенном алгоритме

#11 2016-09-23 17:26:09

Re: Управление PWM в определенном алгоритме

#12 2016-09-23 18:28:46

Re: Управление PWM в определенном алгоритме

#13 2016-09-23 20:22:57

Re: Управление PWM в определенном алгоритме

#14 2016-09-23 20:42:03

Re: Управление PWM в определенном алгоритме

#15 2016-09-23 21:03:41

Re: Управление PWM в определенном алгоритме

#16 2016-09-23 21:15:40

Re: Управление PWM в определенном алгоритме

#17 2016-09-23 21:43:16

Re: Управление PWM в определенном алгоритме

#18 2016-09-23 21:50:38

Re: Управление PWM в определенном алгоритме

#19 2016-09-23 22:04:53

Re: Управление PWM в определенном алгоритме

#20 2016-09-23 22:05:21

Re: Управление PWM в определенном алгоритме

#21 2016-09-23 22:14:04

Re: Управление PWM в определенном алгоритме

#22 2016-09-23 22:37:03

Re: Управление PWM в определенном алгоритме

#23 2016-09-24 13:34:13

Re: Управление PWM в определенном алгоритме

#24 2016-09-24 14:16:52

Re: Управление PWM в определенном алгоритме

#25 2016-09-24 17:10:33

Re: Управление PWM в определенном алгоритме

Швидке повідомлення

Підвал форуму