Счетчик бутылок на линии

0,042 секунды это всего 4 милисекунды.

 

А ну да, сорри, 42 миллисекунды. Но все равно не так уж много, учитывая что датчика 3 и 5 линий. Вот уже начинаю сомневаться что один МК за всем уследит.

 

Может быть так и надо сделать. Вообще датчики на каких нибудь мелких МК типа моих любимых tiny, а от них сигналы в головной блок.

 

Нету уарта, можно конечно придумать что то своё простое, думаю не проблема, а можно купить готовые платы, не намного дороже получится.

 

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

Сам бы остановился на варианте предложенным Megakoteyka.

Когда-то работал с фоторезистором, как уже упоминалось главное защитить фоторезистор от паразитной засветки. Мне так же не нравится варианты беспроводной передачи данных на производстве.

Фоторезистор лучше подключить к прерыванию, тем самым гарантировав отсутствие пропуска в подсчете. У Мини 2 прерывания, если планируется 3 фоторезистора, повесить на прерывание самый нижний фоторезистор, остальные просто опрашивать в loop.

Вариантов много, к примеру.

Ведущий (Нео) отправляет запрос подчиненному (Мини), по номеру (каждая Мини имеет свой номер) подчиненный понимает, что запрос ему. Отправляет данные о кол-ве бутылок ведущему (Нео).

В данном случае идет последовательный опрос Мини, для Вашей задачи не требуется одновременного сбора информации.

Если остановитесь на таком варианте + аппаратном UART или RS-485 поверх аппаратного UART на Си, пишите, есть почти готовая реализация от Multiwii. Вам нужно будет ее немного доработать, добавив номер Мини. И выбрать вариант использование таймера или micros для переключения RS-485 (если будет использоватся).

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

UART.h

Код (Text):

/******************************************************************************
     * File: UART.h
     * Description: Класс работы с UART
     * Created: 22 июня 2015
     * Last Modifiede: 06 августа 2015
******************************************************************************/

/******************************************************************************
     * Based on: Serial.h - https://code.google.com/p/multiwii/
******************************************************************************/

/******************************************************************************
     * CodeStyle: 3
******************************************************************************/

#ifndef UART_H_
#define UART_H_

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

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

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

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

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

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

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

/// <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);

#endif /* UART_H_ */
 

Protocol.h

Код (Text):

/******************************************************************************
    * File: Protocol.h
    * Description: Класс протокола передачи данных
    * Created: 22 июня 2015
    * Last Modifiede: 09 августа 2015
******************************************************************************/

/******************************************************************************
    * Based on: Protocol.h - https://code.google.com/p/multiwii/
******************************************************************************/

/******************************************************************************
    * CodeStyle: 3
******************************************************************************/

#ifndef PROTOCOL_H_
#define PROTOCOL_H_

void AllUartOpen(void);

void UARTWork(void);

void Serialize8(uint8_t a);

void Serialize16(int16_t a);

void Serialize32(uint32_t a);

void SerializeStruct(uint8_t *cb,uint8_t siz);

void HeadCmdSend(uint8_t err, uint8_t s, uint8_t c);

void TailCmdSend(void);

#ifdef UART_HARDWARE_DEBUG
  void WriteDebug(uint8_t c);

  void WriteDebug(const uint8_t *buffer, size_t size);

  inline void WriteDebug(unsigned long n);

  inline void WriteDebug(long n);

  inline void WriteDebug(unsigned int n);

  inline void WriteDebug(int n);

  void WriteDebug(const char *buffer, size_t size);

  void WriteDebug(const char *str);

  void PrintDebugNumber(unsigned long n, uint8_t base);

  void PrintDebugFloat(double number, uint8_t digits);

  void PrintDebug(const char str[]);

  void PrintDebug(char c);

  void PrintDebug(unsigned char b, int base);

  void PrintDebug(int n, int base);

  void PrintDebug(unsigned int n, int base);

  void PrintDebug(long n, int base);

  void PrintDebug(unsigned long n, int base);

  void PrintDebug(double n, int digits);
#endif

#endif /* PROTOCOL_H_ */
 

Файлы Protocol.cpp и UART.cpp не влазят, разместил в прищепке.

Чтение просто вызов UARTWork(), пример отправки.

Код (Text):

void rovSendAnswer(void)
{  
  HeadCmdSend(0, 1, 2);
     
  rovDataS.errore = 1;
               
  SerializeStruct((uint8_t*)&rovDataS, 1);

  TailCmdSend();
}

И типы в данных из примера
typedef struct
{
uint8_t bfirst,bsecond,statuswork;
uint16_t lx, ly, rx, ry;
} ps2Struct;

typedef struct
{
uint8_t errore;
} rovDataStruct;

Удачи.

 

При тактовой 16 МГц длительность такта составляет 62,5 нс. На 4,2 мс тогда получится 672000 тактов - за это время можно тысячи раз успеть опросить все датчики. А тактовую частоту до кучи можно увеличить до 20 МГц.

Один из приборов системы управления одного из модулей МКС тоже работает на контроллере с тактовой 16 МГц. Он на этой частоте делает гораздо больше, чем опрос 3-х датчиков

 

На С. Нормально написанный код на С по производительности очень мало уступает ассемблеру. Иногда приходится делать ассемблерные вставки в критичных участках кода, но таких участков обычно 1-2 на программу и они очень маленькие.

 

Если писать код левой ногой, то никакой компилятор из него конфетку не сделает. А если писать как надо, то даже без оптимизатора получается очень неплохой результат.

 

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

 

Со "временем" на датчики и обрабоьку разобрались. А как на счёт передачи данных по радио каналу через nRF24L01+? Кто нибудь пробовал, сколько времени создоется канал? Каждый раз его нужно создавать или можно держать открытыми четыри канала? В описании к устройству написанно, что скорость у него до 2Мб/с. И два байта (ИД + Количество) передать тоже займёт не много времени(0,0000076 сек. (Если я правильно считаю)).

 

Как показывает реальная практика, эти мегаскорости часто оказываются сферическим конем в вакууме. Не стоит забывать о возможных помехах в канале, которые приведут к повторным передачам со всеми отсюда вытекающими. Как мне кажется, если речь идет о передаче по радио, считать нужно на контроллере, к которому непосредственно физически проводами подключены датчики. А потребителю данные доставлять надо уже значительно реже и в несколько обобщенном виде, например, раз в 10 секунд выдавать общее количество зафиксированных за данный интервал времени бутылок.

 

Радиоканал хорош в домашней любительской электронике. В промышленных применениях лучше не полениться, протянуть кабель и поднять RS-485. Получите простую отладку и высокую надежность.
А если все же очень хочется радиоканал, изучайте эту тему и задавайте вопросы автору.

 

Не, начинаем изучать вот эту тему. И применять вот эту библиОтеку. Чет мне это кажется более перспективным. Скоро-скоро они ко мне приедут...

 

Попробую объяснить почему я так цепляюсь за "радио"

По полу провода не протянуть... Штробить мне не кто не даст. А между линиями ходят/носятся люди и нет нет заезжают кары/тачки/рохли. Тянуть до лотка (паутиной)... не хочется... Да еще одно схема будет расширятся. Пока в 3 раза, а там посмотрим.

 

Что мешает датчики подтянуть к вертикальным штангам ближе?