Самодельный передатчик (часть 2)
…Я своим киндерам сделал “бюджетатор” для контроля времени работы за компьютером. Дивайс определяет пользователя по таблетке Touch Memory (DS1990); пока таблетка в считывателе и если баланс положительный - разрешает включить блок питания компьютера и списывает время в балансе. Питается оно от дежурки компьютера, часики (DS1307) на бекапе CR2032.
Так вот, чтобы мое жулье не пыталось пороть остаток бюджета варварскими методами (выдергивая вилку компьютера из розетки) я внешний БОД (4,7В) повесил за входным фильтром, и отсюда же питается ЖКИ и прочая индикация. После этой точки идет шоттка, за ней - кондюк на 3000 мкф. И питается с этого кондюка один только контроллер. Внутренний БОД (4,2В) висит на питании контроллера. Сигнал с внешнего БОДа запускает внешнее прерывание. По этому прерыванию экстренно сохраняется EEPROM и запускается процедура выключения.
Пока не слетало…
Зачем EEPROM при наличии 1307 и CR2032 ? 😃
А где же на каждого бюджетируемого члена семьи хранить размер ежедневного бюджета, остаток бюджета “на сегодня”, штраф (за “аварийное” отключение компьютера), да и само понятие “сегодня”?
Можно было бы в таблетке, но у нашего домофона таблетки склеротичные (DS1990).
Чего-то тема в сторону домофонов поехала…
У кого-нибудь есть опыт питания кодера от 3.3 Вольт?
С модулем радиоканала на 2.4 ГГц вроде логично питать все усройство от 1S
DS1307 имеет 56 байт ОЗУ, питаемого от батарейки, не говоря уже о встроенном календаре.
… А Mega8535 имеет 512 байт EEPROM. Что же его, ножовкой отпиливать, раз DS1307 в схеме есть? 😁
К тому же мои террористы уже дважды на дивайс покушались: первый раз с перемычками, второй раз - с кусачками. Насмотрелись боевиков, понимаешь. 😅
А если ты про количество циклов перезаписи, так 100.000 раз мне более чем достаточно. Страниц 5…10 назад на эту тему уже один холивар вели; КМК, второй не нужен.
У кого-нибудь есть опыт питания кодера от 3.3 Вольт?
С модулем радиоканала на 2.4 ГГц вроде логично питать все устройство от 1S
Если делать по уму, то надо:
- либо перепихивать его на низковольтный контроллер, работающий на 12МГЦ;
- либо ставить преобразователь StepUp, раскачивать 1S до 5V и питать им штатную Atmega128;
- либо брать 2S/3S и ставить преобразователь StepDown;
- либо брать ATMega 128L и надеяться, что при питании 3,3В она вытянет 12МГц (но вот это уже не по уму, КМК!).
Себестоимость решения с преобразователями - от 50 рублей (1 канал на MC34063) до… ну, скажем, 400 рублей (два канала на LM2674).
Лично я предпочитаю вариант №3. Доводы:
- В любом поле аккумуляторы 2S и 3S найдутся. 1S - не факт;
- Можно питаться хоть от борта грузовика (24В);
- “Тренер-Ученик”. Интерфейс у апп где-то что-то в районе 8…10 вольт. Ты уверен, что “Ученик” поймет 3,3В?
- Имея 9 вольт (с аккумулятора) и 5 вольт (со стабилизатора), ты можешь добавлять в аппу практически что угодно. Имея 4,3В…3,3В - КМК, существенно меньше.
Отстал немного 😃. К посту 2160. Не самый лучший вариант, не по инженерному. Эпоксидка, не самый лучший клей для “китайской” пластмассы, слишком хрупкий. С “заду” кнопки лучше было бы приклеить упор, или надфилем проточить углубление под корпус кнопки а потом вклеить на циакрин.
Я думал и про первое, и про второе.
И решил пока не делать.
Кнопка триммера - не самое ответственное место; даже если она и отвалится, то большой беды случиться не должно. А сделать с проточками или упором можно и в процессе ремонта.
С другой стороны:
- Кнопка довольно плоская, собственно толкатель у кнопки - узкий. Заглубить кнопку - и он будет контактировать с приводом уже не всей толщиной, а половиной.
- Фото было сделано после того, как эпоксидка нанесена в один слой. После его затвердевания (где-то через час-полтора после нанесения) было капнуто дополнительно сзаду и с боков, так что своеобразный упор сделан. Отлит из эпоксидки. Надеюсь, что этого хватит. Разница в плечах рычага незначительная, разница в усилиях на пальце и на кнопках небольшие. Причем палец трет накатку на триммере “на сдвиг”.
а я упоры делал вертикальные из куска спицы, мертво получается, просто сверлил дырочки в основе чуть меньше диаметра спицы, там до куда должна доходить подвижная часть и вставлял в них, в натяг, маленкие кусочки тонкой вязальной спицы, а потом приклеевал кнопки, так чтобы на них не было как бы лишнего усилия
Можно (и полезно, и нужно) контролировать содержимое EEPROM подсчитывая код CRC. Как этого можно сделать написал Nick_Shl там же.
Могу написать ещё раз 😃. Сначала скачиваем файл с функциями расчёта CRC. Затем добавляем следующий кусок кода туда, где происходит модификация EEPROM:
// *****************************************************************************
// *** Мусорная переменная - нулевая ячейка подвержена самопорче ***********
// *****************************************************************************
static eeprom unsigned char EEPROM_TRASH @(0x0000);
// *****************************************************************************
// *** Переменная для хранения CRC, размещена в конце EEPROM ***************
// *****************************************************************************
static eeprom unsigned short EEPROM_CRC @(0x1000 - sizeof(unsigned short));
// *****************************************************************************
// *** Определения для удобства ********************************************
// *****************************************************************************
// Адрес начала области EEPROM по которой будет считатся CRC
// Равен нулевому адресу EEPROM(0) + размер мусорной переменной
#define EEPROM_CRC_START ((unsigned char eeprom *)(0x0000 + sizeof(EEPROM_TRASH)))
// Размер области EEPROM по которой будет считатся CRC
// Равен размеру EEPROM - размер мусорной переменной - размер переменной с CRC
#define EEPROM_CRC_SIZE (0x1000 - sizeof(EEPROM_TRASH) - sizeof(EEPROM_CRC))
// *****************************************************************************
// *** Подсчет CRC EEPROM и его записть ************************************
// *****************************************************************************
static inline void Recalc_EEPROM_CRC(void)
{
// Считаем новый EEPROM CRC и записываем его в EEPROM
EEPROM_CRC = Crc16_eeprom(EEPROM_CRC_START, EEPROM_CRC_SIZE);
}
// *****************************************************************************
// *** Подсчет CRC EEPROM **************************************************
// *****************************************************************************
inline unsigned short Get_EEPROM_CRC(void)
{
// Считаем EEPROM CRC
return(Crc16_eeprom(EEPROM_CRC_START, EEPROM_CRC_SIZE));
}
// *****************************************************************************
// *** Проверка корректности CRC EEPROM ************************************
// *****************************************************************************
inline unsigned char Is_EEPROM_CRC_Correct(void)
{
// Считаем EEPROM CRC и сравниваем с записанным
// Если совпадает - возвращаем ИСТИНУ
if(EEPROM_CRC == Crc16_eeprom(EEPROM_CRC_START, EEPROM_CRC_SIZE)) return(TRUE);
// Иначе - ЛОЖ
else return(FALSE);
}
После каждой записи в EEPROM нужно вызывать функцию Recalc_EEPROM_CRC(). Поэтому часто записи лучше не делать 😃. Это относится к триммерам.
При запуске делаем что-нибудь вроде этого:
if(Is_EEPROM_CRC_Correct() == FALSE)
{
// Выводим запрос подтверждения сброса
MsgBoxF("EEPROM CRC ERROR\nReset to factory\ndefaults ?", &Font_6x8, "ERROR", NULL);
// Ждем отпускания кнопок, если были нажаты
while(HB_ENTER || HB_BACK);
// Ждем нажатия кнопок
while(!HB_ENTER && !HB_BACK);
// Eсли нажали ВВОД - сбрасываем
if(HB_ENTER) TX_Reset();
}
либо брать ATMega 128L и надеяться, что при питании 3,3В она вытянет 12МГц (но вот это уже не по уму, КМК!).
По уму было бы запустить не на 12, а на 8 МГц. Вот только во всех версиях что я видел это сложновато 😃. На этот счёт я тоже уже высказывался. Сначала делаем определения:
// *****************************************************************************
// *** Общие определения ***************************************************
// *****************************************************************************
#define AVR_Clock_Freq 16000000 // Частота работы МК
#define Main_Timer_Clock (AVR_Clock_Freq/8) // Частота работы таймера
А затем в математике используем так:
// Длительность импульса:
// значение канала(+-0,5 мс) + центральное положение(1,5 мс)
output[CH] = output[CH] + (int)(Main_Timer_Clock/666.666);
// приведение к int нужно для оптимизации: вычисленное на этапе компиляции число использовать как int
// забавно получилось: 1,5 мс это как раз 1/666,6(6) секунды...
// Если получившийся импульс меньше 0,9 мс (1/1111 сек) - ограничиваем
if(output[CH] < Main_Timer_Clock/1111) output[CH] = Main_Timer_Clock/1111;
// Если получившийся импульс больше 2,1 мс (1/476 сек) - ограничиваем
if(output[CH] > Main_Timer_Clock/476) output[CH] = Main_Timer_Clock/476;
В случае изменения частоты работы достаточно изменить одно определение. В случае изменения делителя таймера - другое 😃. Боятся за падение производительности не стоит - компилятор все константные выражения вычисляет в момент компиляции.
С модулем радиоканала на 2.4 ГГц вроде логично питать все усройство от 1S
А модуль какой? Если для “апгрейда” 35/72 МГц, то он рассчитан на большое напряжение и у него внутри стоит линейный стабилизатор. Если вы ему дадите 3.3 В - думаю он вообще не запустится…
Продолжаем. В личку поступил вопрос:
Если есть возможность, поделитесь плз куском по созданию иерархического меню(или ссылками).
Отвечаю.
Заголовок “движка”(не весь, только то, что относится к главной функции меню):
/*******************************************************************************
* UI_Engine.h
*
* Радиоуправление: Движок пользовательского интерфейса, заголовок
*
* Copyright (c) 2009 Nick Shl
* All rights reserved.
*
*
* Изменения:
*
* Mar 25, 2009 Nick_Shl Первоначальная версия
*
*/// ***************************************************************************
// *****************************************************************************
// *** Описание пункта меню ************************************************
// *****************************************************************************
typedef flash struct typeMenuButton
{
flash char * str; // Название пункта меню
void (*fun) (char AddParam); // Функция вызываемая при нажатии ВВОД
char * (*GetStr) (char * Buf, char AddParam); // Функция вывода дополнительной информации
char AddParam; // Дополнительный параметр, передаваемый в функции
} MenuButton;
// *****************************************************************************
// *** Описание меню *******************************************************
// *****************************************************************************
typedef struct typeMenuPad
{
flash char * CaptionStr; // Название меню, выводимое в заголовке
FontProfile * CaptionFont; // Указатель на профайл шрифта заголовка
FontProfile * MenuFont; // Указатель на профайл шрифта пунктов меню
flash MenuButton * Buttons; // Указатель на массив описания пунктов
char ButtonsNum; // Количество пунктов меню
char CurrentPos; // Выбранный пункт
void (*Before) (void); // Функция вызываемая перед отображением меню
void (*After) (void); // Функция вызываемая перед отображением меню
} MenuPad;
// *****************************************************************************
// *** Главный цикл меню ***************************************************
// *****************************************************************************
void MenuCycle(MenuPad * Menu);
А это сама главная функция движка меню:
/*******************************************************************************
* UI_Engine.c
*
* Радиоуправление: Движок пользовательского интерфейса
*
* Copyright (c) 2009 Nick Shl
* All rights reserved.
*
*
* Изменения:
*
* Mar 25, 2009 Nick_Shl Первоначальная версия
*
*/// ***************************************************************************
#include "UI_Engine.h"
// *****************************************************************************
// *** Главный цикл меню ***************************************************
// *****************************************************************************
void MenuCycle(MenuPad * Menu)
{
int i;
unsigned char Color;
unsigned char MenuHeaderH = 0;
unsigned char StartPos = 0;
unsigned char MenuCount = 0;
unsigned char Kbd = 0;
unsigned char ScrollHeight = 0;
unsigned char ScrollBarHeight = 0;
unsigned char ScrollBarWidth = 0;
unsigned char ScrollBarStart = 0;
unsigned char strLen;
unsigned char bufLen;
FontProfile * CaptionFont = Menu->CaptionFont;
FontProfile * MenuFont = Menu->MenuFont;
#ifdef DEBUG
printf("MenuCycle();\r");
delay_ms(1);
#endif
// Проверки
if(Menu == NULL) return; // Если не передали основную структуру - выходим
if(Menu->Buttons == NULL) return; // Если не передали структуру кнопок - выходим
if(Menu->ButtonsNum == 0) return; // Если количество пунктов меню равно 0 - выходим
if(CaptionFont == NULL) CaptionFont = &Font_8x12; // Если не передали шрифт заголовка - устанавливаем по умолчанию
if(MenuFont == NULL) MenuFont = &Font_6x8; // Если не передали шрифт пунктов - устанавливаем по умолчанию
MenuHeaderH = Font_8x8.H + CaptionFont->H;
// Подсчет количества пунктов меню, помещающихся на экране
MenuCount = (HeightS - MenuHeaderH - 3) / MenuFont->H;
// Если на экране помещается больше чем есть в меню - ограничиваем
if(MenuCount > Menu->ButtonsNum) MenuCount = Menu->ButtonsNum;
// Высота полосы прокрутки: высота экрана - высота заголовка меню
ScrollHeight = HeightS - (MenuHeaderH + 2 + 2);
// Высота индикатора полосы прокрутки:
// (количество отображаемых пунктов меню * количество доступных точек) / количество пунктов меню
ScrollBarHeight = ((unsigned int)MenuCount * ScrollHeight) / Menu->ButtonsNum;
// Если размер индикатора больше половины полосы прокрутки - приравниваем к половине
if(ScrollBarHeight > ScrollHeight/2)
{
ScrollBarHeight = ScrollHeight/2;
}
// Ширина индикатора полосы прокрутки:
ScrollBarWidth = 4;//MenuFont->W - 2;
do{
// Очищаем экран
gfx_ClearBuf();
// Отрисовываем заголовок меню
gfx_SetXY(0, Font_8x8.H);
gfx_PutFlashStr(Menu->CaptionStr, 0xFF, CaptionFont);
gfx_DashLine(0, MenuHeaderH, WidthS, MenuHeaderH);
// Если вызывающему нужно что либо выполнить какие-либо действия - вызываем
if(Menu->Before != NULL) Menu->Before();
do
{
// Очищаем место под заголовок с номером модели, иконкой и режимом
gfx_FillRect(0, 0, WidthS - 1, Font_8x8.H, 0x00);
gfx_SetXY(0, 0);
// Номер модели
sprintf(tmpBuf, "%d", Settings.ModelNum + 1);
gfx_PutStr(tmpBuf, 0xFF, &Font_8x8);
// Сдвигаем позицию рисования на 4 точки
gfx_ChangeXY(3, 0);
// Значек верта
if(CurModel.type == TYPE_HELI)
{
gfx_Char(125, 0xFF, &Font_8x8);
gfx_Char(126, 0xFF, &Font_8x8);
}
// Значек самолета
if(CurModel.type == TYPE_PLANE)
{
gfx_Char(127, 0xFF, &Font_8x8);
gfx_Char(128, 0xFF, &Font_8x8);
}
// Сдвигаем позицию рисования на 4 точки
gfx_ChangeXY(3, 0);
// Название режима
gfx_PutStr(CurModel.Mode[FLY_MODE].name, 0xFF, &Font_6x8);
// Стартовая позиция индикатора полосы прокрутки:
// высота заголовка меню + (текущяя позицию в меню * количество доступных точек для индикатора) / количество пунктов меню
ScrollBarStart = MenuHeaderH + 2 + 1 + (Menu->CurrentPos * (unsigned int)(ScrollHeight - ScrollBarHeight)) / (Menu->ButtonsNum - 1);
// Если выбран последний пункт меню устанавливаем индикатор в самый низ,
// т.к. при подсчете может потерятся точность и появится дырка
if(Menu->CurrentPos == Menu->ButtonsNum - 1)
{
ScrollBarStart = ScrollHeight - ScrollBarHeight + MenuHeaderH + 2 + 1;
}
// Очищаем место под полосу прокрутки
gfx_FillRect(0, MenuHeaderH + 2, ScrollBarWidth - 1, HeightS - 1, 0x00);
// Отрисовываем полосу прокрутки
gfx_Rectangle(0, MenuHeaderH + 2, ScrollBarWidth - 1, HeightS - 1, 0xFF);
// Отрисовываем индикатор полосы прокрутки
gfx_FillRect(0, ScrollBarStart, ScrollBarWidth - 1, ScrollBarStart + ScrollBarHeight, 0xFF);
// Отрисовываем пункты меню
for(i = StartPos; i < StartPos + MenuCount; i++)
{
// Количество символов в строке меню
strLen = (WidthS - (ScrollBarWidth + 2)) / MenuFont->W;
// Заполняем временный буфер пробелами
memset(tmpStr, ' ', sizeof(tmpStr));
// Если установлена функция возврата доп. информации
if(Menu->Buttons[i].GetStr != NULL)
{
// Получаем доп. информацию в буфер
Menu->Buttons[i].GetStr(tmpBuf, Menu->Buttons[i].AddParam);
// Считаем её размер
bufLen = strlen(tmpBuf);
// Если её размер больше количества символов в строке меню - ограничиваем
if(bufLen > strLen) bufLen = strLen;
// Копируем доп. информацию в строку меню, с выравниванием по правому краю
strcpy(tmpStr + (strLen - bufLen), tmpBuf);
}
// Копируем название пункта меню из флеша в временный буфер
strcpyf(tmpStr, Menu->Buttons[i].str);
// Если длинна названия меньше длинны строки помещающейся на экране - ставим пробел склеивая строчки
if(strlen(tmpStr) < strLen) tmpStr[strlen(tmpStr)] = ' ';
// Обрезаем строку на границе экрана(защита на случай превышения названием количества символов в строке меню)
tmpStr[strLen] = '\0';
// Устанавливаем место рисования
gfx_SetXY(ScrollBarWidth + 2, MenuFont->H * (i - StartPos) + MenuHeaderH + 2);
// Задаем цвет - нужно для выбранного пункта
if(Menu->CurrentPos == i) Color = 0x00;
else Color = 0xFF;
// Рисуем строчку
gfx_PutStr(tmpStr, Color, MenuFont);
}
// Обновляем экран
gfx_Refresh();
// Ждем отпускания кнопок
WaitEmptyButtons(0);
// Ждем нажатия кнопок
Kbd = WaitButtonPress(0);
// Изменяем позицию курсора, если нажато ВВЕРХ или ВНИЗ
if((Kbd & B_UP) && (Menu->CurrentPos > 0)) Menu->CurrentPos--;
if((Kbd & B_DOWN) && (Menu->CurrentPos < Menu->ButtonsNum - 1)) Menu->CurrentPos++;
// Если курсор вышел за границы экрана - сдигаем меню на один пункт
if(Menu->CurrentPos < StartPos) StartPos--;
if(Menu->CurrentPos > StartPos + MenuCount - 1) StartPos++;
}
while(!(Kbd & (B_BACK | B_ENTER)));
// Если вызывающему нужно что либо выполнить какие-либо действия - вызываем
if(Menu->After != NULL) Menu->After();
// Если нажали ВВОД и у выбранного пункта установлен обработчик
if((Kbd & B_ENTER) && (Menu->Buttons[Menu->CurrentPos].fun != NULL))
{
// Ждем отпускания кнопок
WaitEmptyButtons(0);
// И вызываем обработчик
Menu->Buttons[Menu->CurrentPos].fun(Menu->Buttons[Menu->CurrentPos].AddParam);
}
}
while(!(Kbd & B_BACK));
// Ждем отпускания кнопок
WaitEmptyButtons(0);
}
А теперь пример использования. Главное меню:
// *****************************************************************************
// *** Главное Меню ********************************************************
// *****************************************************************************
// *** Пункты меню *********************************************************
flash MenuButton TestMenuButtons[] =
{{"Model", ModelMenu, NULL},
{"Controls", ControlsMenu, NULL},
{"Channels", ChannelsMenu, NULL},
{"Timer", TimerMenu, NULL},
{"Options", OptionsMenu, NULL},
{"IO Test", IO_Test_AP, NULL},
{"Demo", Demo_AP, NULL}};
// *** Функция меню ********************************************************
void MainMenu(void)
{
// Формируем структуру меню
MenuPad Pad = {"Main Menu", &Font_8x12, &Font_6x8, TestMenuButtons, NumberOf(TestMenuButtons), 0, NULL, NULL};
// Вызываем обработчик меню
MenuCycle(&Pad);
}
Это просто. А теперь пример поинтереснее: реализация на этом движке микшера. Используется дополнительный параметр из структуры:
// *****************************************************************************
// *** Меню каналов(микшера) ***********************************************
// *****************************************************************************
// *** Текущий настраиваемый канал ******************************************
static char MixerCurrentChannel;
// *** Изменение настройки микшера ******************************************
void MixerChangeSetting(char AddParam)
{
// Вызываем окно изменения значения
EditNumDlg(&CurModel.Mode[FLY_MODE].Chanels[MixerCurrentChannel][AddParam], PTR_CHAR, -100, 100, 4, "Mixer");
}
// *** Получение строки настройки микшера **********************************
char * MixerGetStr(char * Buf, char AddParam)
{
// Формируем в буфере текущее значение
sprintf(Buf, "%d", CurModel.Mode[FLY_MODE].Chanels[MixerCurrentChannel][AddParam]);
// Возвращаем указатель на переданный буфер
return(Buf);
}
// *** Список пунктов настройки микшера для канала *************************
flash MenuButton MixerMenuButtons[] =
{{"Ailerons", MixerChangeSetting, MixerGetStr, CTRL_AIL},
{"Elevator", MixerChangeSetting, MixerGetStr, CTRL_ELE},
{"Throttle", MixerChangeSetting, MixerGetStr, CTRL_THR},
{"Rudder", MixerChangeSetting, MixerGetStr, CTRL_RUD},
{"SW 1", MixerChangeSetting, MixerGetStr, CTRL_SW1},
{"SW 2", MixerChangeSetting, MixerGetStr, CTRL_SW2},
{"SW 3", MixerChangeSetting, MixerGetStr, CTRL_SW3},
{"Aux 1", MixerChangeSetting, MixerGetStr, CTRL_AUX1},
{"Virtual 1", MixerChangeSetting, MixerGetStr, CTRL_V1},
{"Virtual 2", MixerChangeSetting, MixerGetStr, CTRL_V2},
{"Trim", MixerChangeSetting, MixerGetStr, CTRL_TRIM}};
// *** Меню настройки микшера для канала ***********************************
void ChannelsMixerMenu(char AddParam)
{
// Формируем структуру меню
MenuPad Pad = {"Mixer", &Font_8x12, &Font_6x8, MixerMenuButtons, NumberOf(MixerMenuButtons), 0, NULL, NULL};
// Запоминаем номер текущего управляющего элемента
MixerCurrentChannel = AddParam;
// Вызываем обработчик меню
MenuCycle(&Pad);
}
// *** Список каналов для настройки микшера ********************************
flash MenuButton ChannelsMenuButtons[] =
{{"CH 1", ChannelsMixerMenu, NULL, 0},
{"CH 2", ChannelsMixerMenu, NULL, 1},
{"CH 3", ChannelsMixerMenu, NULL, 2},
{"CH 4", ChannelsMixerMenu, NULL, 3},
{"CH 5", ChannelsMixerMenu, NULL, 4},
{"CH 6", ChannelsMixerMenu, NULL, 5},
{"CH 7", ChannelsMixerMenu, NULL, 6},
{"CH 8", ChannelsMixerMenu, NULL, 7}};
// *** Меню выбора каналов для настройки микшера ***************************
void ChannelsMenu(char AddParam)
{
// Формируем структуру меню
MenuPad Pad = {"Channels", &Font_8x12, &Font_6x8, ChannelsMenuButtons, NumberOf(ChannelsMenuButtons), 0, NULL, NULL};
// Если количество каналов модели меньше чем максимальное количество - устанавливаем их,
// что бы не отображать отсутствующие у модели каналы
if(Pad.ButtonsNum > CurModel.num_ch) Pad.ButtonsNum = CurModel.num_ch;
// Вызываем обработчик меню
MenuCycle(&Pad);
}
Где-то так…
Вопросы, обсуждения реализации и конструктивная критика приветствуется.
Хотя на данный момент я передатчиком не занимаюсь и не использую(потому что не летаю). Считаю, что он достиг своего предела - во-первых исковеркан внешне, во-вторых нет апгейдабельности - сменных модулей. Прикрутить конечно, можно но вот зачем? Мне бы хотелось сделать новый передатчик на основе Hitec Optic 6, использовать экран TIC, плату по возможности подогнать под существующую, что бы проводку не менять… Только вот донора нет…
Николай, посмотри в сторону ДХ5. 40 баксов за корпус с модулем и антеной - весьма неполохо. Места в нем достаточно (у дх6 корпус практически такой же), сносные джойстики и готовые кнопки триммеров.
2 Aleksey_Gorelikov, подскажите где посмотреть по какой схеме и как подключаетса выключатель питания, на дополнительном ключе!
Обсуждали тут, наверное еще год-2 года назад, вместе с Женей (fokus)
Или, как здесь уже советовалось, пристально посмотреть на Тургнигу-“тушку”. Единственный вопрос, который нуждается в прояснении - что там за дисплей. Думаю, что ребята из той ветки не откажутся ответить…
Я разъемчиками закупился для кодера (взял из серии MW/MU, ключеванные с защелками, шаг 2мм, и высота маленькая). Так примерно $15 одни разъемы встали. (Хобби, блин… “Охота пуще неволи”…)Там же вся тушка $70.
P.S. Но ить пока что получается так, что душа поет. 😃 Сегодня пачку булавок купил - крепления дисплея делать. Позже фото выложу.
P.P.S. +$3 за пачку булавок… 😃
Про дисплейчик надо не в той ветке искать, а где-то тут, в самодельной аппе (там паралельная шина на дисплее, лень искать тип контроллера). Месяц-2 назад назад выяснили, что за дисплей в ней стоит (была тут отдельная ветка типа “что за дисплей в турниджи”). Лень смотреть. Только проц там мега64. Надо будет в корне графику перерабатывать. С тем подходом как у фокуса\мсв - экранный буфер много ОЗУ съедает.
Кто хочет помоделировать в протеусе - велкам.
Джойстики расставил по привычной мне “Моде 2”. От увиденного при калибровке окосел… 😵
Не менял: если кто-то так сделал - значит это кому-нибудь нужно?Все как живое - пищщалкой пищщит, по менюшкам ходит, свитчи видит, потенциометры при калибровке - тоже. Калибровку не проходит - прошуршал джойстиками, дополнительным каналом, кнопаю “вправо” - получаю “not correct”.
Наверное что-то в методологии у меня не так.И PPM не PPMит (вернее, синхроимпульс идет, но управления не видно). Из-за косой калибровки?
P.S. Ах, да! Вот еще что… Почему-то сразу после изготовления проекта модель дисплея не запустилась - экран оставался мертвым. Потребовалось отдельно запустить распаковать и запустить модель из поста #2119, после чего все волшебным образом заработало. Впрочем, с протеусом и не такое бывает… 😉
Калибровка работает нормально. Необходимо на второй странице в схеме Proteus привести каналы в соответствии с реальной схемой. Или править программу в соответствии с Вашей схемой.
PS У себя исправил.
Николай, спасибо за ответ по меню. Интересна была прежде всего реализация динамического легко маштабируемого меню. Т.к ответ пришел чуть позже:) успел набросать свою версию. Прежде всего не стал использовать структуры с указателями, а использовал статическую таблицу переходов(на мой взгляд получилоссь достаточно наглядно) которая дает представление об иерархии всего меню.
Если будет интересно- скину куски.
А основная идея управления пульта- отказ от кнопок и использование энкодера.
В качестве такового используется колесо мыши:).
Пока отлаживаю в протеусе- жду VG400 за 10 евро:)
По поводу проверки еепром в сообщения выше- реализовал проверку срс при загрузке соотв модели(в структуру модели при записи пишется вычисленное значение).
Также планируется использование програмного отключения передатчика, что позволит однократно читать модель при включении, внесенные изменения держать в рам и записывать еепром при выключении или через меню.
В общем идей масса- посмотрим как реализуется в железе.
( отдельное спс родоначальникам данной ветки, т. к. многие вещи были использованы методом контрол+с) 😃
А основная идея управления пульта- отказ от кнопок и использование энкодера.
Энкодер- это здорово! Сделал возможность менять параметры резистором доп. аналогового канала. Очень удобно кажется. Чуть позже выложу обновление, где в тч. контроль CRC EPROM сделан, ну и еще кое-что, по мелочи…
Люди добрые, помогите… Уж очень хочется нормально отлаживаться в протеусе (7.5 SP3), а он, зараза, не хочет адресовать больше 256 байт епрома. Уж и бинарник размером 4К ему подкладывал и ручками пытался MODDATA править, один фиг страшие разряды адреса игнорирует… Это конкретный косяк модели или как-то лечится??
Энкодер-это здорово! Сделал возможность менять параметры резистором доп. аналогового канала. Очень удобно кажется.
Это бы весьма кстати… А то у меня никак кнопки меню в конструктив не вписываются так, чтобы нравилось. Пока на плате спроектировал контактные площадки для установки платы кнопок меню “бутербродом”, ну и разъем менюшный тоже оставил (потому как еще есть мысль поставить джойстик от мобильника).
А вот так у меня дисплей встал в корпус. Стекло (из “нулевой” коробочки от CD просто вложено; сверху к нему две пружинки из булавок прижимают плату с дисплеем TIC154). Так что даже если по дисплею что-то пнет (с умеренной силой и не очень резко) дисплей целым (надеюсь…) останется.
На плате оставлены места для впайки в цепь питания подсветки корпуса 0805, 1206 и SMB в параллель - яркость регулировать. Что-нибудь точно подберется. И еще на плате есть местечко, так что можно двухуровневую по яркости подсветку замастрячить, типа “день-вечер”.
Люди добрые, помогите… Уж очень хочется нормально отлаживаться в протеусе (7.5 SP3), а он, зараза, не хочет адресовать больше 256 байт епрома. Уж и бинарник размером 4К ему подкладывал и ручками пытался MODDATA править, один фиг страшие разряды адреса игнорирует… Это конкретный косяк модели или как-то лечится??
Похожая проблема и у меня. Модели представлені массивом структур в еепром. Так вот при симуляции структура пишется всегда по нулевому адресу. Тож думал косяк в программе, но в студио еепром заполняется без ошибок. И еще- в протеусе файл служит для начальной инициализации еепром. При последующей симуляции данные еепром сохраняются во вспомогательном файле симуляции. Могут быть сброшены через меню дебаг.
ЗЫ: хотел отправить архив с моделю в протеусе но стоит ограничение на тип файлов(только графика)\справку читал:)\
Хочу уточнить, изменение параметров резистором доп. ан. каналом- не будет полноценная замена кнопок “вверх-вниз”. Просто при изменении параметра от-100 до +100 это гораздо удобнее сделать одним движением пота. И Хотя почти всё (ключ. слово - “почти”) можно сделать без этих кнопок, но отазываться совсем от них наверное не стоит…
Ох… погорячился я минутами на реализацию проверки CRC EEPROM… Уже второй вечер пытаюсь понять, почему после “больший” изменений, CRC получается правильной только на второй раз…
А вот код для проверки eeprom в протеусе:
#define SIZEOF_EEPROM 4*1024
void testeeprom(void)
{
unsigned int i;
eeprom unsigned char *p;
p=0;
for(i=0; i<SIZEOF_EEPROM; i++, p++)
{
*p=0xaa;
}
}
После этой функции помотреть дамп eeprom в протеусе…