Помогите пожалуйста с кодом С#

[Demiurg]

Кстати, да. ТС, измените название топика. Типа, помогите конечный автомат.
Ivanoff-iv, сложный пример для ТС, я думаю. Ему бы что попроще.

[NStorm]

Demiurg, я никаких примеров не давал.

[Demiurg]

[uquote="NStorm",url="/forum/viewtopic.php?p=3874389#p3874389"]Demiurg, я никаких примеров не давал.[/uquote]
Извини, поправил.

[Ivanoff-iv]

Почему сложный? по мне так вполне подходящий...
1) как-раз под кодевижен (коим ТС пользуется) - меньше проблем с открытием
2) проект весь в комплекте, и компилится - как ТС и просил
3) я явно указал, где искать КА... и как его можно применить
плюс некоторые блоки (которые бы мешались) вынесены в отдельные файлы
4) вроде код неплохо комментирован...
согласен, что акцент сделан не на этом (в основном тут я делил время чтобы и датчик работал, и интерфейс не заедал, и экран не мерцал - к этому я очень притязателен) но и тема КА, считаю, раскрыта достаточно (если будет надо - пусть сам делает более разветвленные чепочки).

[Demiurg]

Ему меню сейчас как серпом по яйцам, нужно что-то легкое. На примере работы устройства, управления чем-либо. Лично я сейчас репу чешу, что выложить, либо коммерческие, либо сложные проекты...

[Ivanoff-iv]

мигание светодиодом на КА?

[Demiurg]

Спасибо! Точно! Моя реализация программных таймеров.

[Dimon456]

Demiurg, вот эту часть надо

после сработки одного из датчиков должно произойти определенное движение в лево или в право,каждый раз разное

нужен алгоритм смены направления движения

Двигатель - Стоп, Разгон, Работа, Торможение, Авария.

покажите пример реализации на конечных автоматах, если вам не трудно (два датчика, один двигатель).

[Demiurg]

[uquote="Dimon456",url="/forum/viewtopic.php?p=3874463#p3874463"]...[/uquote]
Я ждал вашего ответа. И недаром говорил. Скажите, что действительно вам нужно. Но, даже то, что вы просите, не так просто. Дребезг механических контактов учитываем? Что такое дребезг знаем? В программировании самое важное - это взаимодействие программных модулей. А автоматном программировании это краеугольный камень. Взаимодействие. Опрос входов, тем более, если есть дребезг. Дальше, как осуществляем взаимодействие? События, сообщения, флаги, переменные, переменные состояния других конечных автоматов.
Следите за этим сообщением, я сюда буду добавлять. Кстати, проекты пишу в IAR. Адаптировать для других компиляторов сами будете. В AVR-Studio ублюдочная реализация работы с FLASH и EEPROM. А у меня активное использование таблиц и так далее, которые расположены во FLASH.

Пример. Для ознакомления. Из проекта электрокара. Двигатель. Стоп, разгон, работа, торможение.

Спойлер

Код: Выделить всё

//==================
#include "proc_device.h"
//==================

//==================
static direction_t direction; // Режим стоп или направление

static direction_t direction_last;

static motor_mode_t motor_mode; // Режим двигателя.
static u16 speed; // Скорость.

//static bool stop_sensor_buf;
//==================

//==================
static proc_device_t _proc_device;

void proc_device (void)
{
//   proc_stop_sensor ();

   u08 event = Get_Event (EV_ID_KEYS_CHANGE);

   switch (_proc_device)
   {
      case PROC_DEVICE_INIT:
         set_proc_adc_on ();
         _proc_device = PROC_DEVICE_WAIT_RUN;
         break;

      case PROC_DEVICE_WAIT_RUN: // Ожидание запуска.
         if (event)
         {
            switch (GetKeyCode ())
            {
               case 1<<KEY_RIGHT: // Установка направления "Вправо".
                  led_right_on (); // Включение светодиода "Вправо"
                  direction = DIRECTION_RIGHT;
                  break;

               case 1<<KEY_LEFT: // Установка направления "Влево".
                  led_left_on (); // Включение светодиода "Влево"
                  direction = DIRECTION_LEFT;
                  break;

               default:
                  return;
            }

            Set_Proc_Motor_Acceleration_1 (); // то установка модуля мотора на режим разгона.

            direction_last = direction;
            _proc_device = PROC_DEVICE_RUN;
         }
         break;

      case PROC_DEVICE_RUN:
         if (event && GetKeyCode () == 0) // Если кнопка отжата.
         {
            Set_Proc_Motor_Braking (); // то установка модуля мотора на режим торможения и последующий стоп.
            _proc_device = PROC_DEVICE_WAIT_STOP;
         }
         break;

      case PROC_DEVICE_WAIT_STOP:
         if (motor_mode == MOTOR_STOP) // Если модуль двигателя встал в режим стоп, то
         {
            _proc_device = PROC_DEVICE_WAIT_RUN; // Установка на ожидание включения.
            return;
         }

         if (event) // Если нажата кнопка "Вправо или влево".
         {
            u08 a = DIRECTION_STOP;

            switch (GetKeyCode ())
            {
               case 1<<KEY_RIGHT: // Установка направления "Вправо".
                  a = DIRECTION_RIGHT;
                  break;

               case 1<<KEY_LEFT: // Установка направления "Влево".
                  a = DIRECTION_LEFT;
                  break;

               default:
                  return;
            }

            if (direction_last == a)
            {
               Set_Proc_Motor_Acceleration_2 (); // то установка модуля мотора на режим разгона.
               _proc_device = PROC_DEVICE_RUN;
            }
         }
         break;
   }

   proc_adc ();
   proc_motor ();
}
//==================

//==================
static proc_motor_t _proc_motor;

void Set_Proc_Motor_Acceleration_1 (void) // Установка модуля двигателя в режим разгона.
{
   _proc_motor = PROC_MOTOR_ACCELERATION_INIT_1;
}

void Set_Proc_Motor_Acceleration_2 (void) // Установка модуля двигателя в режим разгона.
{
   _proc_motor = PROC_MOTOR_ACCELERATION_INIT_2;
}

void Set_Proc_Motor_Braking (void) // Установка модуля двигателя в режим торможения.
{
   _proc_motor = PROC_MOTOR_BRAKING_INIT;
}

void Set_Proc_Motor_Stop (void)
{
   clr_bit (P_CH_RIGHT_DDR, P_CH_RIGHT);
   clr_bit (P_CH_RIGHT_PORT, P_CH_RIGHT);

   clr_bit (P_CH_LEFT_DDR, P_CH_LEFT);
   clr_bit (P_CH_LEFT_PORT, P_CH_LEFT);

   clr_bit (PWM_RIGHT_DDR, PWM_RIGHT);
   clr_bit (PWM_LEFT_DDR,  PWM_LEFT);

   clr_bit (TCCR1A, TMR_COM_RIGHT);
   TMR_OCR_RIGHT = 0;

   clr_bit (TCCR1A, TMR_COM_LEFT);
   TMR_OCR_LEFT = 0;

   all_leds_off ();
   direction = DIRECTION_STOP;
   direction_last = DIRECTION_STOP;
   motor_mode = MOTOR_STOP;
   _proc_motor = PROC_MOTOR_IDLE;
}

void proc_motor (void)
{
   static soft_timer ST_PROC_MOTOR;

   speed = get_adc_buf ();

   switch (_proc_motor)
   {
      case PROC_MOTOR_IDLE:
         break;

      case PROC_MOTOR_ACCELERATION_INIT_1: // Разгон. Инициализация.
         TCCR1A = ((1<<WGM11) | (1<<WGM10));
         TCNT1 =  0;
         TCCR1B = 1<<CS11;

         switch (direction)
         {
            case DIRECTION_RIGHT:
               set_bit (P_CH_RIGHT_DDR, P_CH_RIGHT);

            #if (PROJECT_MODE == WORK)
               set_bit (P_CH_RIGHT_PORT, P_CH_RIGHT);
            #endif
               set_bit (PWM_RIGHT_DDR, PWM_RIGHT);

               set_bit (TCCR1A, TMR_COM_RIGHT);
               TMR_OCR_RIGHT = 0;
               break;

            case DIRECTION_LEFT:
               set_bit (P_CH_LEFT_DDR, P_CH_LEFT);

            #if (PROJECT_MODE == WORK)
               set_bit (P_CH_LEFT_PORT, P_CH_LEFT);
            #endif
               set_bit (PWM_LEFT_DDR, PWM_LEFT);

               set_bit (TCCR1A, TMR_COM_LEFT);
               TMR_OCR_LEFT = 0;
               break;
         }

      case PROC_MOTOR_ACCELERATION_INIT_2: // Разгон. Инициализация.
         set_soft_timer (ST_PROC_MOTOR, STEP_SPEED, STEP_SPEED);

         motor_mode = MOTOR_ACCELERATION;
         _proc_motor = PROC_MOTOR_ACCELERATION;
         break;

      case PROC_MOTOR_ACCELERATION: // Разгон.
         if (handle_soft_timer (ST_PROC_MOTOR))
         {
            switch (direction)
            {
               case DIRECTION_RIGHT:
                  if (TMR_OCR_RIGHT < speed)
                     TMR_OCR_RIGHT++;
                  else
                     _proc_motor = PROC_MOTOR_RUN_INIT;
                  break;

               case DIRECTION_LEFT:
                  if (TMR_OCR_LEFT < speed)
                     TMR_OCR_LEFT++;
                  else
                     _proc_motor = PROC_MOTOR_RUN_INIT;
                  break;
            }
         }
         break;

      case PROC_MOTOR_RUN_INIT:
         set_soft_timer (ST_PROC_MOTOR, STEP_SPEED, 25);

         motor_mode = MOTOR_RUN;
         _proc_motor = PROC_MOTOR_RUN;
         break;

      case PROC_MOTOR_RUN:
         if (handle_soft_timer (ST_PROC_MOTOR))
         {
            switch (direction)
            {
               case DIRECTION_RIGHT:
                     TMR_OCR_RIGHT = speed;
                  break;

               case DIRECTION_LEFT:
                     TMR_OCR_LEFT = speed;
                  break;
            }
         }
         break;

      case PROC_MOTOR_BRAKING_INIT: // Торможение. Инициализация.
         set_soft_timer (ST_PROC_MOTOR, STEP_SPEED, STEP_SPEED);

         motor_mode = MOTOR_BRAKING;
         _proc_motor = PROC_MOTOR_BRAKING;
         break;

      case PROC_MOTOR_BRAKING: // Торможение.
         if (handle_soft_timer (ST_PROC_MOTOR))
         {
            switch (direction)
            {
               case DIRECTION_RIGHT:
                  if (TMR_OCR_RIGHT > 0)
                     TMR_OCR_RIGHT--;
                  else
                     Set_Proc_Motor_Stop ();
                  break;

               case DIRECTION_LEFT:
                  if (TMR_OCR_LEFT > 0)
                     TMR_OCR_LEFT--;
                  else
                     Set_Proc_Motor_Stop ();
                  break;
            }
         }
         break;
   }
}
//==================

/*
//==================
static u08 stop_sensor_prev;

void proc_stop_sensor (void)
{
   static proc_stop_sensor_t _proc_stop_sensor;

   static soft_timer ST_PROC_STOP_SENSOR;

   u08 a = 0;

   if (STOP_SENSOR_PIN & (1<<STOP_SENSOR))
      a |= (1<<0);

   switch (_proc_stop_sensor)
   {
      case PROC_STOP_SENSOR_INIT:
         stop_sensor_prev = a;

         if (a)
            stop_sensor_buf = true;
         else
            stop_sensor_buf = false;

         _proc_stop_sensor = PROC_STOP_SENSOR_NOT_CHANGE;
         break;

      case PROC_STOP_SENSOR_NOT_CHANGE:
         if (a != stop_sensor_prev)
         {
            stop_sensor_prev = a;
            set_soft_timer (ST_PROC_STOP_SENSOR, 40, 0);
            _proc_stop_sensor = PROC_STOP_SENSOR_CHANGE;
         }
         break;

      case PROC_STOP_SENSOR_CHANGE:
         if (handle_soft_timer (ST_PROC_STOP_SENSOR))
         {
            if (a == stop_sensor_prev)
            {
               if (a)
                  stop_sensor_buf = true;
               else
                  stop_sensor_buf = false;
            }

            stop_sensor_prev = a;

            _proc_stop_sensor = PROC_STOP_SENSOR_NOT_CHANGE;
         }
         break;
   }
}
//==================
*/

//==================
#pragma inline = forced
void led_right_on (void)
{
   set_bit (LED_RIGHT_DDR, LED_RIGHT);
   clr_bit (LED_LEFT_DDR,  LED_LEFT);
}

#pragma inline = forced
void led_right_off (void)
{
   clr_bit (LED_RIGHT_DDR, LED_RIGHT);
}

#pragma inline = forced
void led_left_on (void)
{
   set_bit (LED_LEFT_DDR,  LED_LEFT);
   clr_bit (LED_RIGHT_DDR, LED_RIGHT);
}

#pragma inline = forced
void led_left_off (void)
{
   clr_bit (LED_LEFT_DDR,  LED_LEFT);
}

#pragma inline = forced
void all_leds_off (void)
{
   led_right_off ();
   led_left_off ();
}
//==================

Добавлено after 5 hours 31 minute 6 seconds:
Пример с двумя датчиками. Алгоритм - Ждем нажатия кнопки Старт. Включается двигатель вперед. Когда доедет до датчика 2, реверс. Когда достигнет датчика 1, цикл начинается сначала. То есть ждем нажатия кнопки Старт. Проект написан в IAR, в папке файл для симуляции в AVR-Studio. Кнопка старт PB0. Датчик 1 PB1, Датчик 2 PB2. Двигатель вперед PD0, назад PD1.

[Dimon456]

Demiurg, пересобрал я ваш проект в winavr, вот видео

Спойлер

не стал разбираться с wdt, закомментировал эти строки.
По чему через DDRD идет управление двигателями или это какая-то особенность?

Я так полагаю что торможения тут нет

Спойлер

Код: Выделить всё

      case PROC_DEVICE_MOTOR_FORWARD:
//         if (Get_Sensors () & (1<<SENSOR_2_BIT))
         if (Check_Sensor_2_On ())
         {
            motor_forward_off ();
            motor_back_on ();
            _proc_device = PROC_DEVICE_MOTOR_BACK;
         }
         break;

Код: Выделить всё

            motor_forward_off ();
            motor_back_on ();

не есть хорошо для двигателя, а если еще и с редуктором...

Ну что я могу сказать: все обернуто в красивую оболочку, весь алгоритм в в функции proc_device(). Готовый проект, пример. Вот что и было нужно.

[Demiurg]

Разгон, торможение я дал вам в виде примера. Нет времени разбираться. Железа на руках нет. В протеусе не работаю.

Добавлено after 14 minutes 56 seconds:
Дело не в обертках. Инкапсуляция, минимизация правки. Все определено в одном месте. Писанины много, но это окупается в дальнейшем.

[shrus43]

Ребят вопрос количестао case может быть безграничным?и использование одной переменной?а то возникают проблемы,пишу кейс уже 35 и условие не применяется,приходится второй раз дублировать кейс и тогда норм,но это вроде как ге правильно,в железе кстати не правильно работает,лживый протеус получается?

[NStorm]

Не ограничено, не может такого быть. И протеус тут не причем. Он к языку C отношения не имеет. Где-то ошибку допускаете.

[shrus43]

В коде наплошал скорей всего да?если он не причем,то почему в нем программа работает?

[Demiurg]

Если много кейсов, код становится нечитабельным. В этом случае есть два способа.
Способ 1

Спойлер

Код: Выделить всё

//==================
void kbd_drv (void)
{
   keys_curr = scan_keys ();

   switch (_kbd_drv)
   {
      case KBD_DRV_INIT:        kbd_drv_init ();        break;
      case KBD_DRV_NOCHANGE:    kbd_drv_nochange ();    break;
      case KBD_DRV_CHANGE:      kbd_drv_change ();      break;
      case KBD_DRV_HOLD_REPEAT: kbd_drv_hold_repeat (); break;
   }
}
//==================

Способ 2. Индексный переход. Создается таблица с указателями на функции-обработчики состояний. Индексом служит переменная-состояние.

Спойлер

Код: Выделить всё

_proc_device.h

//************************************************************************
//************************ Главный автомат *******************************
//************************************************************************

//==================
STATE (PROC_DEVICE_INIT,             proc_device_init)
STATE (PROC_DEVICE_WEIGHT_MODE,      proc_device_weight_mode)
STATE (PROC_DEVICE_DOSER_IDLE_MODE,  proc_device_doser_idle_mode)
STATE (PROC_DEVICE_DOSER_MODE,       proc_device_doser_mode)
STATE (PROC_DEVICE_IDLE,             proc_device_idle)
STATE (PROC_DEVICE_EMERG_MODE,       proc_device_emerg_mode)
//==================

//==================
typedef enum _proc_device
{
#define STATE(name, func) name,
#include "_proc_device.h"
#undef STATE

PROC_DEVICE_STATES,
} proc_device_t;
//------------------------------------------------------------------------
void proc_device (void);
//------------------------------------------------------------------------
void proc_device_init (void);
//------------------------------------------------------------------------
void proc_device_weight_mode_init (void);
void proc_device_weight_mode (void);
//------------------------------------------------------------------------
void proc_device_doser_idle_mode_init (void);
void proc_device_doser_idle_mode (void);
//------------------------------------------------------------------------
void proc_device_doser_mode_init (void);
void rst_proc_device_doser_mode (void);
void proc_device_doser_mode (void);
//------------------------------------------------------------------------
void proc_device_idle_init (void);
void proc_device_idle (void);
//------------------------------------------------------------------------
void set_proc_device_emerg_mode (u08 err_id);
void proc_device_emerg_mode (void);
//==================

//==================
__flash FUNC proc_device_func [PROC_DEVICE_STATES] =
{
#define STATE(name, func) func,
#include "_proc_device.h"
#undef STATE
};
//------------------------------------------------------------------------
static proc_device_t _proc_device;
static u08 _proc_device_slave;
//------------------------------------------------------------------------
void proc_device (void)
{
//   proc_meter (); // Важно!!! Инициализация!

   proc_fsm_func (proc_device_func, _proc_device);
}
//==================

[Dimon456]

Demiurg, думаю и эту "технологию" можно освоить, вот видео

Спойлер

для наглядности 5 секунд поставил на остановку двигателя, дым-насос в котельной еще дольше останавливается.

[Demiurg]

Ты балуешься, или что то конкретное делаешь? Пришли проект. Посмотрю.

[shrus43]

Ребят тупенький вопрос от меня,как всегда,решил из кодвижена перейдти в авр студио,все таки он заточен под аврки и при переделке столкнулся с мелкими траблами,в кодвижене я пишу его диалектом: PORTC.0=1;PORTC.2=0;PORTC.3=0;PORTC.4=0; это я применяю как блокировку,требуемый в 1 другие пины в ноле,мало ли чего,как эта запись будет выглядеть на чистом си?побитовыми сдвигами или есть способы другие?покрасивше,в авр студио первый раз,на все мои дэфайны он ругается за что были удалены(((

[NStorm]

shrus43, побитовые сдвиги самое красивое )

Код: Выделить всё

#include <avr/io.h>
...
PORTC = (1 << PORTC0);

Ну макросы еще в avr-libc небольшие есть: https://www.nongnu.org/avr-libc/user-ma ... __sfr.html

Вообще погуглите. Столько раз это написано. А то еще объяснять про снятие/установку/переключение отдельных битов через чтение-модификацию-запись и логические операции в очередной раз - ну совсем букварь писать.

[Ivanoff-iv]

попробуй добавить дефайны:

Код: Выделить всё

#define (x).(y)=0 #asm("CBI x.y")
#define (x).(y)=1 #asm("SBI x.y")

не уверен, что написал грамматически правильно, но КВАВР эти команды трактует именно так (без чтение->модификация->запись, а за одно действие, по крайней мере там, где это возможно)