Arduino.ru

Добрый день!

Не совсем понятно задание. Из описания - все просто (даже элементарно), тем более у вас есть программа. В чем подвох?

Дело в том, что катастрофически не хватает времени на изучение программирования. И так хотел запустить аппарат летом 2014, но загвоздка в программе была, хотел сам изучить, но дальше азов не продвинулся. Программа может пока легкая, только будет обрастать доп. Функциями. Подвоха нет, просто нужна помощь человеку-железячнику в программировании.

При нажатии на ссылку она не открывается. Чтобы открыть, необходимо стереть в конце ссылки 1 пробел.

Добрый вечер.
Искал ответ по синхронизации передачи данных по RS485 и случайно увидел Ваше сообщение. Сам сейчас с другом делаем наброски по аналогичному проекту - проект подводного телеуправляемого аппарата. Приятно видеть, что не только нам лавры Кусто не дают уснуть:).

Тоже делаю на RS485 передачу управления, делаю в свободное время.

По коду

Начнем с UART (Serial), лучше делать отправку и получение на прерываниях + передача байтами + кольцевой буфер, это уменьшит размер кода и сделает его более эффективным, без лишних задержек.

Более рациональное использование ресурсов позволит в будущем иметь запас по расширению, к примеру, для стабилизации при течении (акселерометр, гироскоп) и т.д. Тем более

Примерное описание, данной реализации с неплохим пояснением.

Крайне не желательно использовать delay в loop.

Вы являетесь заказчиком, рекомендовал бы изменить требования к коду для разработчика.

Проект как я понял, почти закончен. Но возможно, будет полезно использование Playstation joystick, вместо кнопок. Более подробно тут.

Будут вопросы, пишите.

Artur1985, а с вашими набросками можно познакомиться?

Отчасти, увы нет времени их публиковать. Сейчас проходят тесты отдельные модули, работы еще много, в том числе и кодинга. 

Я пишу коды и разбераюсь с электроникой, мой друг механикой и корпусом.

Вот пару фото

Габариты 164*156*202мм.

Меня, как волонтера, именно кодовая часть интересует.

Тут все очень сильно зависит от конкретного Rov. К примеру, для классического Rov, данные идут с береговой станции на Rov, а телеметрия отображается на видео сигнале. К примеру на той же MAX7456. 

Я не стал изобретать велосипед и воспользовался проектом Multiwii, там хорошая схема передачи данных, простой протокол + проверенный IMU. Сейчас подпиливаю под собственные нужды протокол и думаю над синхронизации RS-485. У меня не классический Rov, данные идут в обе стороны. 
 

Готового решения у меня пока нет, делается в свободное время. 
Мое решение, без доработки использовать не получится. Да можно будет взять саму передачу данных, но протокол придется переписывать. Так как он будет заточен, под особенности моего Rov.

Добрался до рабочего компа, как я говорил, лучше если Вы посмотрите код оригинала.
Вот мой код, по сути код от MultiWii, лишь изменена стилистика.
Так же начал вставлять комментарии.

UART.cpp
 

/**********************************  Библиотеки  **************************************/
#include "Arduino.h"

#include "UART.h"

#include "Def.h"

#include "Config.h"
/**********************************  /Библиотеки  *************************************/

/**************************************************************************************/
/*****************             Класс работы с UART               **********************/
/**************************************************************************************/

// SerialHeadRX - буфер RX для хранения "головы масива"
// SerialTailRX - буфер RX для хранения "хвоста масива"
static volatile uint8_t SerialHeadRX[UARTNumber],SerialTailRX[UARTNumber];

// SerialBufferRX - буфер RX для хранения данных
static uint8_t SerialBufferRX[RXBufferSize][UARTNumber];

// SerialHeadTX - буфер TX для хранения "головы масива"
// SerialTailTX - буфер TX для хранения "хвоста масива"
static volatile uint8_t SerialHeadTX[UARTNumber],SerialTailTX[UARTNumber];

// SerialBufferTX - буфер X для хранения данных
static uint8_t SerialBufferTX[TXBufferSize][UARTNumber];

/// <summary>
// Инициализируем и открываем UART порт 
/// </summary>
/// <param name="port">Номер порта</param>
/// <param name="baud">Скорость работы порта</param>
void UARTOpen(uint8_t port, uint32_t baud) 
{
  // U2X - Удвоение скорости обмена. Если этот разряд установлен в «1», коэффициент деления предделителя контроллера скорости передачи уменьшается с 16 до 8, удваивая тем самым скорость асинхронного обмена по последовательному каналу. В USART разряд U2X используется только при асинхронном режиме работы. В синхронном режиме он должен быть сброшен.
  // UBRRL  и UBRRH - регистры скорости передачи   
  // RXEN - Разрешение приема. При установке этого разряда в «1» разрешается работа приемника USART/UART и переопределяется функционирование вывода RXD.
  // TXEN - Разрешение передачи. При установке этого разряда в «1» разрешается работа передатчика UART и переопределяется функционирование вывода TXD
  // RXCIE - Разрешение прерывания по завершению приема. Если данный разряд установлен в «1», то при установке флага RXC регистра UCSRA генерируется прерывание.
  
  uint8_t h = ((F_CPU  / 4 / baud -1) / 2) >> 8;
  uint8_t l = ((F_CPU  / 4 / baud -1) / 2);
  switch (port) 
  {
    #if defined(ArduinoProMini)
      case 0: UCSR0A  = (1<<U2X0); UBRR0H = h; UBRR0L = l; UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0); break;
    #endif
    #if defined(ArduinoProMicro)
      case 1: UCSR1A  = (1<<U2X1); UBRR1H = h; UBRR1L = l; UCSR1B |= (1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1); break;
    #endif
    #if defined(ArduinoMega)
      case 0: UCSR0A  = (1<<U2X0); UBRR0H = h; UBRR0L = l; UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0); break;
      case 1: UCSR1A  = (1<<U2X1); UBRR1H = h; UBRR1L = l; UCSR1B |= (1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1); break;
      case 2: UCSR2A  = (1<<U2X2); UBRR2H = h; UBRR2L = l; UCSR2B |= (1<<RXEN2)|(1<<TXEN2)|(1<<RXCIE2); break;
      case 3: UCSR3A  = (1<<U2X3); UBRR3H = h; UBRR3L = l; UCSR3B |= (1<<RXEN3)|(1<<TXEN3)|(1<<RXCIE3); break;
    #endif
  }
}

/// <summary>
// Сохраняем полученный байт в буфер RX для хранения данных 
/// </summary>
/// <param name="data">Полученный байт</param>
/// <param name="port">Номер порта</param>
void StoreUartInBuf(uint8_t data, uint8_t portnum) 
{
  // Получаем номер "головы масива" RX
  uint8_t h = SerialHeadRX[portnum];
  // Проверяем, увеличиваем номер "головы масива" RX головы на 1 и если номер "головы масива", станет равным или больше размера буфера, обнуляем переменную h в 0  
  if (++h >= RXBufferSize) 
  {
    h = 0;
  }
  
  // Убрал для отладки
  // Проверяем номер "головы масива" RX и номер "хвоста масива" RX если равен, это ошибка
  if (h == SerialTailRX[portnum]) 
  {
    return; 
  }
  
  // Сохраняем полученный байт в буфер RX для хранения данных
  SerialBufferRX[SerialHeadRX[portnum]][portnum] = data;  
  
  // Сохраняем новый номер "головы масива" RX
  SerialHeadRX[portnum] = h;
}

// Обработчик завершение приема по каналу USART
#if defined(ArduinoProMini)
  ISR(USART_RX_vect)  { StoreUartInBuf(UDR0, 0); }
#endif
#if defined(ArduinoProMicro)
  ISR(USART1_RX_vect)  { StoreUartInBuf(UDR1, 1); }
#endif
#if defined(ArduinoMega)
  ISR(USART0_RX_vect)  { StoreUartInBuf(UDR0, 0); }
  ISR(USART1_RX_vect)  { StoreUartInBuf(UDR1, 1); }
  ISR(USART2_RX_vect)  { StoreUartInBuf(UDR2, 2); }
  ISR(USART3_RX_vect)  { StoreUartInBuf(UDR3, 3); }
#endif

// Обработчик прерывания по опустошению буффера UART
#if defined(ArduinoProMini) || defined(ArduinoMega)
  #if defined(ArduinoProMini)
  ISR(USART_UDRE_vect) 
  {  
  #endif
  #if defined(ArduinoMega)
  ISR(USART0_UDRE_vect) 
  { 
  #endif
    uint8_t t = SerialTailTX[0];
    if (SerialHeadTX[0] != t) 
    {
      if (++t >= TXBufferSize) 
      {
        t = 0;
      }
      UDR0 = SerialBufferTX[t][0];  
      SerialTailTX[0] = t;
    }
    
    if (t == SerialHeadTX[0]) 
    {
      UCSR0B &= ~(1<<UDRIE0);
    } 
  }
#endif
#if defined(ArduinoMega) || defined(ArduinoProMicro)
  ISR(USART1_UDRE_vect) 
  { 
    uint8_t t = SerialTailTX[1];
    if (SerialHeadTX[1] != t) 
    {
      if (++t >= TXBufferSize) 
      {
        t = 0;
      }
      UDR1 = SerialBufferTX[t][1];  
      SerialTailTX[1] = t;
    }
    if (t == SerialHeadTX[1]) 
    {
      UCSR1B &= ~(1<<UDRIE1);
    }
  }
#endif
#if defined(ArduinoMega)
  ISR(USART2_UDRE_vect) 
  {
    uint8_t t = SerialTailTX[2];
    if (SerialHeadTX[2] != t) 
    {
      if (++t >= TXBufferSize) t = 0;
      UDR2 = SerialBufferTX[t][2];
      SerialTailTX[2] = t;
    }
    if (t == SerialHeadTX[2]) 
    {
      UCSR2B &= ~(1<<UDRIE2);
    }
  }
  ISR(USART3_UDRE_vect) 
  { 
    uint8_t t = SerialTailTX[3];
    if (SerialHeadTX[3] != t) 
    {
      if (++t >= TXBufferSize) 
      {
        t = 0;
      }
      UDR3 = SerialBufferTX[t][3];
      SerialTailTX[3] = t;
    }
    if (t == SerialHeadTX[3]) 
    {
      UCSR3B &= ~(1<<UDRIE3);
    }
  }
#endif

/// <summary>
// Сохраняем отправляемый байт в буфер TX для хранения данных
/// </summary>
/// <param name="port">Номер порта</param>
/// <param name="a">Отправляемый байт</param>
void UARTSerialize(uint8_t port, uint8_t a) 
{
  uint8_t t = SerialHeadTX[port];
  if (++t >= TXBufferSize)
  {
    t = 0;
  }
  SerialBufferTX[t][port] = a;
  SerialHeadTX[port] = t;
}

/// <summary>
// Отправляем данные по UART, включаем прерывание по опустошению буффера UART
/// </summary> 
/// <param name="port">Номер порта</param>
void UARTSendData(uint8_t port) 
{
  #if defined(ArduinoProMini)
    UCSR0B |= (1<<UDRIE0);
  #endif
  #if defined(ArduinoProMicro)
    switch (port) 
    {
      case 1: UCSR1B |= (1<<UDRIE1); break;
    }
  #endif
  #if defined(ArduinoMega)
    switch (port) 
    {
      case 0: UCSR0B |= (1<<UDRIE0); break;
      case 1: UCSR1B |= (1<<UDRIE1); break;
      case 2: UCSR2B |= (1<<UDRIE2); break;
      case 3: UCSR3B |= (1<<UDRIE3); break;
    }
  #endif
}

/// <summary>
// Сохраняем отправляемый байт в буфер TX для хранения данных и отправляем данные по UART, включаем прерывание по опустошению буффера UART
/// </summary> 
/// <param name="port">Номер порта</param>
/// <param name="c">Отправляемый байт</param>
void UARTWrite(uint8_t port, uint8_t c)
{
  UARTSerialize(port,c);UARTSendData(port);
}

/// <summary>
// Получает количество байт доступных для чтения из буфера RX
/// </summary> 
/// <param name="port">Номер порта</param>
uint8_t UARTAvailable(uint8_t port) 
{
  return ((uint8_t)(SerialHeadRX[port] - SerialTailRX[port]))%RXBufferSize;
}

/// <summary>
// Читаем данные из буфера RX для хранения данных
/// </summary> 
/// <param name="port">Номер порта</param>
uint8_t UARTRead(uint8_t port) 
{
  // Получаем номер "хвоста масива" RX
  uint8_t t = SerialTailRX[port];
  // Получаем байт по номеру "хвоста масива" RX
  uint8_t c = SerialBufferRX[t][port];
  
  // Проверяем номер "головы масива" RX и номер "хвоста масива" RX если не равен
  if (SerialHeadRX[port] != t) 
  {
     // Проверяем, увеличиваем номер "хвоста масива" RX хвоста на 1 и если номер "хвоста масива", станет равным или больше размера буфера, обнуляем переменную t в 0  
    if (++t >= RXBufferSize) 
    {
      t = 0;
    }
    // Сохраняем новый номер "хвоста масива" RX
    SerialTailRX[port] = t;
  }
  return c;
}

/// <summary>
// Закрываем UART порт
/// </summary> 
/// <param name="port">Номер порта</param>
void UARTClose(uint8_t port) 
{
  switch (port) 
  {
    #if defined(ArduinoProMini)
      case 0: UCSR0B &= ~((1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(1<<UDRIE0)); break;
    #endif
    #if defined(ArduinoProMicro)
      case 1: UCSR1B &= ~((1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1)|(1<<UDRIE1)); break;
    #endif
    #if defined(ArduinoMega)
      case 0: UCSR0B &= ~((1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(1<<UDRIE0)); break;
      case 1: UCSR1B &= ~((1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1)|(1<<UDRIE1)); break;
      case 2: UCSR2B &= ~((1<<RXEN2)|(1<<TXEN2)|(1<<RXCIE2)|(1<<UDRIE2)); break;
      case 3: UCSR3B &= ~((1<<RXEN3)|(1<<TXEN3)|(1<<RXCIE3)|(1<<UDRIE3)); break;
    #endif
  }
}

 UART.h
 

#ifndef UART_H_
#define UART_H_

/**************************************************************************************/
/*****************             Класс работы с UART               **********************/
/**************************************************************************************/

// Определяем кол-во UART-тов в зависимости от платы
#if defined(ArduinoMega)
  // Если ArduinoMega
  #define UARTNumber 4
#elif defined(ArduinoProMicro)
  // Если ArduinoProMicro
  #define UARTNumber 1
#else
  // Иначе предполагается ArduinoProMini
  #define UARTNumber 1
#endif

// Размер буфера RX
#define RXBufferSize 128

// Размер буфера TX
#define TXBufferSize 128

/// <summary>
// Инициализируем и открываем UART порт 
/// </summary>
/// <param name="port">Номер порта</param>
/// <param name="baud">Скорость работы порта</param>
void UARTOpen(uint8_t port, uint32_t baud);

/// <summary>
// // Сохраняем отправляемый байт в буфер TX для хранения данных
/// </summary>
/// <param name="port">Номер порта</param>
/// <param name="a">Отправляемый байт</param>
void UARTSerialize(uint8_t port, uint8_t a);

/// <summary>
// Отправляем данные по UART, включаем прерывание по опустошению буффера UART
/// </summary> 
/// <param name="port">Номер порта</param>
void UARTSendData(uint8_t port);

/// <summary>
// Сохраняем отправляемый байт в буфер TX для хранения данных и отправляем данные по UART, включаем прерывание по опустошению буффера UART
/// </summary> 
/// <param name="port">Номер порта</param>
/// <param name="c">Отправляемый байт</param>
void UARTWrite(uint8_t port, uint8_t c);

/// <summary>
// Получает количество байт доступных для чтения из буфера RX
/// </summary> 
/// <param name="port">Номер порта</param>
uint8_t UARTAvailable(uint8_t port);

/// <summary>
// Читаем данные из буфера RX для хранения данных
/// </summary> 
/// <param name="port">Номер порта</param>
uint8_t UARTRead(uint8_t port); 

/// <summary>
// Закрываем UART порт
/// </summary> 
/// <param name="port">Номер порта</param>
void UARTClose(uint8_t port);

#endif /* UART_H_ */

Config.h
 

#ifndef CONFIG_H_
#define CONFIG_H_

/**************************************************************************************/
/********************             Класс настроек                ***********************/
/**************************************************************************************/

/********************************  Настройки UART  ************************************/
#define UARTPort              0                    // Порт UART
#define UARTSpeed             115200UL             // Скорость порта UART
/*******************************  /Настройки UART  ************************************/

/*******************************  Настройки Debug  ************************************/
//#define IS_DEBUG_LOOP_SPEED                        // Включение проверки максимального времени прохождения loop
/*******************************  /Настройки Debug  ***********************************/

#endif /* CONFIG_H_ */

Def.h

#ifndef DEF_H_
#define DEF_H_

/**************************************************************************************/
/******************             Класс определений                **********************/
/**************************************************************************************/

/*****************************  Определяем тип ардуины  *******************************/
#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega2560__)
    
  #define F_CPU 16000000UL                             // Частота процессора

  // Определяем тип ардуины
  #if defined(__AVR_ATmega328P__)
    // Если ArduinoProMini
    #define ArduinoProMini
  #endif
  #if defined(__AVR_ATmega32U4__)
    // Если ArduinoProMicro
    #define ArduinoProMicro
  #endif
  #if defined(__AVR_ATmega2560__)
    // Если ArduinoMega
    #define ArduinoMega
  #endif
#endif
/****************************  /Определяем тип ардуины  *******************************/

#endif /* DEF_H_ */

Protocol.cpp

/**********************************  Библиотеки  **************************************/
#include "Arduino.h"

#include "Config.h"

#include "UART.h"
/**********************************  /Библиотеки  *************************************/

/**************************************************************************************/
/**************          Класс протокола передачи данных           ********************/
/**************************************************************************************/

void Serialize8(uint8_t a) 
{
  UARTSerialize(UARTPort,a);
}

void Serialize16(int16_t a) 
{
  Serialize8((a   ) & 0xFF);
  Serialize8((a>>8) & 0xFF);
}

void Serialize32(uint32_t a) 
{
  Serialize8((a    ) & 0xFF);
  Serialize8((a>> 8) & 0xFF);
  Serialize8((a>>16) & 0xFF);
  Serialize8((a>>24) & 0xFF);
}

Protocol.h

#ifndef PROTOCOL_H_
#define PROTOCOL_H_

/**************************************************************************************/
/**************          Класс протокола передачи данных           ********************/
/**************************************************************************************/

void Serialize8(uint8_t a);

void Serialize16(int16_t a);

void Serialize32(uint32_t a);

#endif /* PROTOCOL_H_ */

.ino
 

/**************************************************************************************/
/********************             Основной файл               *************************/
/**************************************************************************************/

/**********************************  Библиотеки  **************************************/
#include "Arduino.h"

#include "Config.h"

#include "Def.h"

#include "UART.h"

#include "Protocol.h"
/**********************************  /Библиотеки  *************************************/

/******************************** Основные функции ************************************/
/// <summary>
/// Настройка при запуске arduino
/// </summary>
void setup()
{
  UARTOpen(UARTPort, UARTSpeed);
}

int i = 0;

/// <summary>
/// Основной цикл
/// </summary>
void loop() 
{  
  if (i == 0)
  {
    // Отправка данных
    Serialize8('H');
    Serialize8('e');
    Serialize8('l');
    Serialize8('l');
    Serialize8('o');
    Serialize8('!');
    Serialize8('\n');
    UARTSendData(UARTPort);
    i = 1;
  }
  
  if (UARTAvailable(UARTPort) > 0)
  {
    uint8_t c = UARTRead(UARTPort);
    
    Serialize8(c);
    UARTSendData(UARTPort);
  }
}
/******************************** /Основные функции ***********************************/

Удачи!

Да чуть не забыл, у меня пока нет рабочего протокола, смотрите MultiWii, там пример протокола. Отправка и получение, вставленны лишь для проверки. 
 

Спасибо!

Не за что, тут все помогают друг другу по мере сил.

Здравствуйте Artur1985 и Gippopotam. Телеметрия у меня будет выводиться именно на MAX7456. Первоначальный код действительно не самый удачный, как я посмотрю. О нем, если нужно, можно благополучно забыть. 

День добрый wenom86.

Тоже пока остановился на этой микросхеме. Если Вы покупали модуль, не подскажите где?

Ни РФ, ни в Китае не нашел отдельного модуля, есть платы OSD, но они совмещены с контролером, а как к ним подключится еще тот вопрос.

Доставка из США пока для меня не доступна.

А что с этими не так?

http://www.ebay.com/itm/170934217208?_trksid=p2059210.m2749.l2649&ssPage...

MAX7456 заказывал летом с алиэкспреса. за 2 штуки вместе вышло около 11 баксов. Но это только 2 голые микрушки (обвес там, как я посмотрел, копеечный, у нас в радиомагазине все докупил)

Artur1985. Можете скинуть мне свою электронку? или напишите мне на wenom86@mail.ru  Думаю нам есть о чем пообщаться.

Андрей, а чем тебя не устроила обычная система управления "штатная" для RC ? с многоканальным же передатчиком/приемником. тебе и нужно всего ничего, исключить ВЧ составляющую и подавать PPM напрямую (с тренерского разьема например) через физический интерфейс типа 485 или что то подобное прямо двумя проводами, на дешифратор-приемника, дальше все "родное". дешифраторов там же обсуждалось в нескольких местах.

С wenom86 моя связь оборвалась, хотел сделать реализацию под его задачи (строители Rov, должны помогать друг другу, нас осталось мало:)), но так как точно не вижу задачи, не рискну делать.

Мой код передачи данных можно увидеть тут. Будут вопросы, буду стараться отвечать по мере сил.

Сейчас прервался в написании кода, конструирую винты, редуктора, подбираю моторы (пока не рискну делать сам). Да и на работе дел прибавилось.