Вид для печати
Спасибо, круто.Цитата:
Сообщение от svofski
В таком варианте мне показалось, наилучшим соотношением 1mF/10K.
А что за резистор 1К, после 100nF ?
Его вроде нет в схемах.
Можно как-то в симуляторе его удалить, и посмотреть результат?
svofski, а что, этот циркуит триал только 24 часа?
С4 = С57 на схеме, там написана ёмкость 2,2н? Что-то показалось, что 2,2м... Не беда -- поправим. :-)Цитата:
Сообщение от svofski
- - - Добавлено - - -
А можно хоть пару скриншотов оттуда с результатами? А то ставить хром ради этого нет никакого желания...Цитата:
Сообщение от svofski
Вроде написано, что на Андроиде и на Яблоке будет работать...Цитата:
А можно хоть пару скриншотов оттуда с результатами? А то ставить хром ради этого нет никакого желания...
Посидел с осциллографом, посмотрел, что с сигналом при разных номиналах кондёров.
Использовал Вектор06Ц.02, там стоит 554СА3А, со схемой совпадает.
ROM-плеер просто гнал частоту 2КГц.
В выходной каскад со схемы zx-tapper-а вносил изменения.
R8 - поменял на переменник, вроде-как должен выполнять функцию регулировки "громкости".
Добавлял переменник R* (в итоге, по результатам убрал).
Добавленный R* - вносил искажения, при уменьшении сопротивления.
С13 изначально у меня стоял 120n, осциллограф показал, что при уменьшении "громкости" на выходе СА3 меняется скважность сигнала - увеличивается продолжительность положительного импульса, за счет отрицательного.
Поменял С13 на 10n - "громкость" практически перестала влиять на скважность.
С12 - пробовал менять в диапазоне от 0.47мкФ до 10мкФ, по результатам поставил планарный 4.7мкФ. Малые емкости давали "пилу" на выходе плеера.
По-моему, странное включение потенциометра R*. По идее сигнал хорошо бы снимать с его движка (средней точки), оставив крайние концы подключенными к сигналу и земле.
Я не понял, что это за резистор в схеме, которую эмулировал svofski в EveryCircuit, решил проверить его влияние на сигнал. А переменник, что-бы проверить его разные значения.Цитата:
Сообщение от tnt23
Резистор на землю я поставил потому что иначе в симуляции получался сигнал перекошенный относительно нуля. У меня тут серьезные вопросы к симуляторам, потому что похоже, что им всем тут сносит башню, причем всем по разному (а до более-менее порядочного в этих вопросах LTSpice мне не дойти, не расчистив предварительно пол). Без редактора выкинуть резистор нельзя, но можно сделать ему значение какое-нибудь огромное.
EveryCircuit я знаю только в качестве Андроидного приложения и хромную версию сам впервые увидел вчера, когда расшарил. Он забавный, если расценивать его как игру типа "собери мультивибратор" и наверное стоит своих монет, но верить ему в вопросах столь важных, как загрузка Вектора с магнитофона, я бы не стал.
Итак, вот что даёт схема на к554са3 с исправленным конденсатором: Вложение 64452
В архиве скриншоты тех же трёх вариантов, что и в сообщении #79 (картинки сюда не вставляю, т.к. нет особого смысла -- они всё равно будут сконвертированы до нечитабельного состояния).
В общем, на основе всего этого можно увидеть, что с компаратором схема явно работает лучше и выход rom-плеера можно сделать практически любым из предложенных ранее вариантов.
Такое подключение таит в себе опасность сделать короткое замыкание выхода на землю, если выкрутить его в крайнее положение...Цитата:
Сообщение от KTSerg
- - - Добавлено - - -
Работает, но пишет, что нужно смотреть только из хрома... :-(Цитата:
Сообщение от KTSerg
Не знаю, есть ли в нём "синхронизация", как в осциллографе, на бегущем графике не видно характеристик сигнала... длительность импульсов/скважность...Цитата:
Сообщение от svofski
Там с обоих сторон резистора стоят последовательно конденсаторы, не думаю, что сразу что-то сгорит... для входа значения не имеет, а выход через 10 Ом и "громкость", так-что не коротнуть...Цитата:
Такое подключение таит в себе опасность сделать короткое замыкание выхода на землю, если выкрутить его в крайнее положение...
С некоторых пор Spice стали включать в девелоперскую версию KiCad, чтобы не заставлять людей почем зря пол расчищать.Цитата:
Сообщение от svofski
tnt23, это тот же компьютер.
Разгреб пол и поиграл в LTSpice. Сколько я не бился, я не могу придумать, чтобы что-то объективно было бы лучше просто проводка от ардуины прямо в магнитофонный вход, безо всяких делителей и конденсаторов.
В симуляции в начале перекос скважности всегда, потому что переходный процесс в C47-(R41+R40). В жизни этот процесс устаканивается за долю секунды во время начального писка. Эта схема ведет себя не фонтан даже с идеальным источником на входе, так что я не представляю, что бы еще можно было улучшить.
На всякий случай мой .asc от LTSpice: https://pastebin.com/VTPqARzQ
Эти эксперименты сподвигли меня вчера провести свой -- я всё же попробовал подать цифровой сигнал с ардуины прямо на вход РС4 контроллера Д30 Вектора... То есть мимо всех конденсаторов, делителей, компараторов -- только цифра в чистом виде. И результат, скажу прямо, меня не порадовал: скорость передачи удалось поднять всего лишь на один шаг (8 мкс). А если к этому ещё прибавить опыт KTSerg, который собрал плеер на другой, более быстрой элементной базе, то можно сделать неутешительный вывод, что не так всё хорошо с выводом сигнала в rom-плеере. :-(Цитата:
Сообщение от svofski
Думаю, надо будет снять ещё одну wav-ку сигнала, но с частотой дискредитации 96кГц, плюс такую же с живого Вектора и сравнить циклы "под микроскопом"...
Ну, есть ещё вариант, интегрировать в ROM-плеер "турбозагрузчик".
Что-бы при выборе файла для загрузки, делался анализ размера файла.
Для "больших" файлов, сначала грузить в Вектор "турбозагрузчик", а потом сам файл (соответственно в формате турбозагрузчика, а не ROM).
Но думаю возникнет аналогичная проблема с пополнением буфера отправки и своевременным "подчитыванием" данных с SD-карты. Ведь скорость выгрузки из буфера будет выше, а времени на чтение SD-карты меньше (т.к. прерывания чаще).
А может я и не прав...
Можно пойти ещё дальше -- грузить свой загрузчик, который будет принимать данные по ПУ, о чём я уже упоминал тут, тогда можно будет раз в десять обогнать и турбо-загрузчик... :-) Вообще, думаю, пока не стоит играться с загрузчиками -- оставим эту идею на потом.Цитата:
Сообщение от KTSerg
Не, ардуина справится -- я тестировал с задержкой таймера в 64 мкс и опустошения буфера не было.Цитата:
Сообщение от KTSerg
Improver, ты кажется говорил, что в какой-то копировщик с твоей ардуины грузится лучше. Может быть у KTSerg другой загрузчик в ПЗУ, оттого и получается разогнать быстрее.
svofski, да, так и есть -- в стандартный копировщик "COPY v2.1" может грузиться с таймингом от 232 мкс, и в случае прямого подключения, как показал вчерашний эксперимент, от 224 мкс, но это далеко от тех 190-200 мкс у KTSerg, которые практически совпадают с расчётными величинами для скорости "21" (или 16h) Вектора.
Хакнул copy21. В VV теперь грузит на максимале, в emu без особых изменений. Как на реале - сложно сказать.
ivagor, а ты не хотел бы сделать новый 2к загрузчик, исправленный и дополненный?
Можно попробовать, но есть большой вопрос - что именно исправлять и дополнять? Думаю, что у каждого векториста есть свое представление, что должно быть в идеальном загрузчике и как это должно работать. Ну и возможности и знания (мои или другого человека, который соберется править загрузчик) ограничены. Хотя непонятные моменты можно просто скопипастить.
Вот. Основная идея не всех победить, а получить такой сборный загрузчик, который можно собрать себе по вкусу. Например, ценность загрузки по ЛВС или 0-момеду мне сейчас кажется нулевой, потому что я не собираю исторический (или мифический) КУВТ. А загрузчик, который бы понимал твой турбо-формат без предварительной загрузки загрузчика, иметь было бы ценно — особенно при том, что я в обозримом будущем предвижу какую-то низкоуровневую отладку на железе. Ну, или хотя бы загрузчик, который стабильно точно определяет временную постоянную так, что можно разогнать стандартный формат чуть шустрее. Или еще вариант: вместо существующих сейчас альтернативных способов загрузки сделать свой новый, который будет проще поддержать простенькой ардуиной ибо это то, что сейчас людям проще и ближе.
- - - Добавлено - - -
P.S. подумалось, что вообще надо делать плату эмулятора ПЗУ, которая будет ставиться в ту же колодку, но гибко позволять себя конфигурировать и грузить все на свете, в том числе из эфира. Разумеется, у меня все мысли сразу в сторону esp8266, видимо в упряжке с какой-то цплдовиной для сопряжения с шиной.
В качестве задачи первого этапа можно попробовать взять дизассемблирование и комментирование (хотя бы в важных местах) загрузчика Tim0xи (все же это самый современный вариант). В идеале загнать в условную компиляцию источники загрузки. Вполне подъемно, но не интересно (самый главный минус). Может займусь, или может еще кто захочет.
Но если ты сделаешь эмулятор ПЗУ, загружаемый из всего на свете, то смысл ковырять загрузчик вобще потеряется.
Эмулятор ПЗУ подразумевает два подхода.Цитата:
Сообщение от svofski
Первый - загрузка с эмулятора по протоколу ПЗУ небольшого БИОСа, и дальше грузить автоматом интерфейс для работы с файлами на эмуляторе уже по другому протоколу.
Второй - иметь очень быстрый доступ к файлу на эмуляторе что-бы успевать его заливать по стробам протокола ПЗУ, но иметь ограничение, что файл грузится только с адреса 0, и максимальный размер файла 32КБ.
При этом эмулятор контроллера ЛВС или 0-модема (протокол не смотрел, но думаю он должен быть гибче протокола ПЗУ) лишены этих недостатков. Поток синхронизируемый с ожиданием готовности данных, адрес загрузки указан в служебной части протокола, размер файла... сколько загрузчик позволит.
Так-что выбор в пользу протокола ПЗУ не так очевиден, по крайней мере для меня.
Посмотрел алгоритм ПУ-LPT.
Всё просто.
настройка портов Вектора: А,С - выход. В - вход.
Данные передаются полубайтами, сначала младший. Для данных используется младшие биты порта В. Один бит порта В (бит 5, "1"-данные готовы) на флаг готовности данных, один бит порта С (бит 4, "0"-данные приняты) на подтверждение приёма.
В потоке сначала передаются 55h, AAh, номер блока для загрузки, количество блоков. Далее сам файл. Контрольная сумма самого файла (которая вычисляется "исключающее ИЛИ" (XOR) контрольной суммы и принятого байта).
Одно смущает, мне показалось, что после приёма каждого байта файла, вызывается подпрограмма, которая рисует весь "квадратик" на сетке загрузки - типа принято 256Байт...
Можно будет в плеер добавить :)
Возвращаясь к rom-плееру... Вчера попробовал исследовать сигнал, за неимением осциллографа использовал аудиокарту ПК -- кривая сигнала получается "неописуемой красоты", все циклы чётко выдержаны, даже и не знаю, к чему там придраться... Единственное, что увидел, это то, что сигнал формируется в инверсном виде и, чисто теоретически, это может повлечь большее время обработки Вектором. Немного переделал скетч, но проверить на оборудовании его ещё не успел, хотя в тапире вав-ки для обоих вариантов выглядят хорошо.
Вот результаты, для иллюстрации проделанного: Вложение 64497
По-хорошему, надо бы ещё исследовать сигнал на выходе компаратора, но для этого, опять же, требуется осциллограф.
Итак, продолжаем... Снял wav-ку с Вектора на максимальной скорости вывода "copy v2.1", и, самое удивительное, напрямую с компа Вектор её грузит легко, в отличие от тех же сохранённых wav-ок с ардуины. Визуально они отличаются, вот картинка для сравнения (Вектор вверху):
Вложение 64528
Причём заметил, что кроме среза верхних частот, Вектор далеко не всегда чётко выдерживает интервалы, и это, как видно, для него не критично.
Попробовал воссоздать схему выхода Вектора, там всего три сопротивления и два конденсатора:
Скрытый текст
Вложение 64530[свернуть]
Правда, не нашёл конденсатор 0,068 мкФ, поставил вместо него в полтора раза больший 0,1 мкФ -- результат отрицательный, т.е. улучшений нет. Пробовал исправить эквалайзером одну из ранее полученных с ардуины wav-ок, игрался и так, и эдак, доводил её даже до состояния, близкого с чистой синусоиде -- Вектор понимает и такую, но, опять же, не на максимальной скорости. :-(
В общем, пока кроме поиска и установки правильного конденсатора, идей нет...
Вот wav-ка, полученная с Вектора, может, кто поймёт, в чём его секрет? :-)
Если вав записать с ардуины в компьютер и потом такую запись проиграть в Вектор? Если эту запись загрузить в эмулятор?
В эмулятор не пробовал, только на живой Вектор -- и с компа не грузится, даже после обработки записи фильтрами. Загружает только если снизить скорость воспроизведения до 75-80% от исходной, т.е. получается на тех же ~256 мкс.Цитата:
Сообщение от svofski
Игры с фильтрами/конденсаторами ничего не дают... Но заметил интересную особенность: сигнал с Вектора имеет небольшие задержки в передаче на границе каждого байта, примерно по 5 сэмплов на 96кГц, что равно ~50 мкс. Это можно заметить и на скриншоте, который я опубликовал выше, примерно в середине. Ардуина же напротив, чётко выдерживает все периоды. Вот, думаю, может в этом причина? Вот только надо придумать, как организовать такие задержки? Править задержку таймера на каждом байте?
- - - Добавлено - - -
О, да -- именно так и есть! Сейчас попробовал взять самый первый скетч и добавить туда задержку между байтами, и Вектор стал грузить на скоростях с полупериодом до 176 мкс, такой по скорости сигнал не давал ни один из копировщиков (речь идёт о стандартном формате ROM, не турбо). :v2_dizzy_punk:
Теперь вопрос, как сделать это на таймере1?...
Занятно, кто б мог подумать. В Векторе и тут отличились :)
Таймеру1 можно период менять на ходу. Увеличивать его перед границей байта, потом обратно.
Тут можно пойти от обратного...Цитата:
Сообщение от Improver
Вектор грузит и выгружает не по таймеру, а по алгоритму с задержками.
Соответственно, нужно расписать тайминги команд алгоритма чтения, и будет видно, где какие задержки должны быть для "оптимальной" по скорости загрузки.
На границе байта задержка нужна для записи принятого байта в память, а при приёме 32 байт ещё и на отрисовку принятой строчки блока (квадратика) на экране. А после приёма всего блока (256Байт) ещё и на проверку все ли строки блока приняты без ошибок. А это "не хухры-мухры", там идёт преобразование адреса принимаемой строки (32Байт в ОЗУ) в адрес на экране, довольно много вычислений. И когда возвращается к приёму следующего байта... а он уже проскочил...
Но можно нарваться и на то, что в разных загрузчиках, "стандартный формт" может отличаться "авторской оптимизацией"... и тайминги для одного загрузчика не подойдут к таймингам в другом...
Я так думаю...
А можно и не маяться и не считать тайминги алгоритма, а просто подключить логгер на сигнал "ЧТВУ" и магнитофонный вход ВВ55. И посмотреть на эти самые тайминги...
Посмотрел логером соотношение импульсов на магнитофонном входе и чтение порта.
При 50мкс задержке между байтами конечно стало лучше. Но при увеличении интервала между байтами до 60мкс, программа стабильно грузится на стандартном заводском загрузчике в Вектор 06Ц.02, при полупериоде таймера... барабанная дробь...в 112мкс...!!!
Правда для вычисления загрузчиком задержек, я отключаю изменение значения таймера на время меандра. Но вроде и без этого отключения работало.
Программа в 21КБ грузится за 59сек, и это стандартный загрузчик...
Да, почти тридцать лет прошло, а секреты у Вектора ещё остались. :-)Цитата:
Сообщение от svofski
Это хорошо, что так можно, иначе это было бы сложной проблемой... Так и сделал, и оно работает.Цитата:
Таймеру1 можно период менять на ходу. Увеличивать его перед границей байта, потом обратно.
Можно, при его наличии и если об этом знать заранее. А так, внимательного рассмотрения и измерения wav-ки оказалось достаточно.Цитата:
Сообщение от KTSerg
После нескольких экспериментов установил, что для стабильного считывания нужно, чтобы задержка между байтами была в сумме равна около 256 мкс, т.е. при полупериоде 200 мкс в начале байта нужно добавить 56 мкс, 192 мкс -- +64 мкс и т.п.Цитата:
Сообщение от KTSerg
По крайней мере, это на ардуино и моих конденсаторах, а сейчас у меня собрана не лучшая схема...
Фантастический результат! Мне такой на Векторе не ".02" не удалось достичь даже близко... Минимум у меня -- 176 мкс, и то в девяти из десяти случаях Вектор не успевает распознать начало записи (00h/55h...).Цитата:
программа стабильно грузится на стандартном заводском загрузчике в Вектор 06Ц.02, при полупериоде таймера... барабанная дробь...в 112мкс...!!!
У меня получилось загрузить тот же 40-ка килобайтный Киберноид за три минуты, таймер при этом был выставлен на 184 мкс. Тоже не плохо, я считаю.Цитата:
Программа в 21КБ грузится за 59сек, и это стандартный загрузчик...
- - - Добавлено - - -
Выкладываю улучшенную, по скорости вывода, версию:
ROM-player_3
Требования по библиотекам не изменились -- нужны TimerOne, SdFat и LiquidCrystal.Код:/*
SD-картридер подключяется к выводам ардуино:
* MOSI - D11
* MISO - D12
* CLK - D13
* CS - D10
Выход - D3
Подключение экрана 1602А (LCD Keypad Shield):
* LCD RS pin - D8
* LCD Enable pin - D9
* LCD D4 pin - D4
* LCD D5 pin - D5
* LCD D6 pin - D6
* LCD D7 pin - D7
* LCD R/W pin - GND
* LCD 5V pin - 5V
Кнопки подключаются на вывод A0 (схема LCD Keypad Shield)
*/
// include the library code:
#include <LiquidCrystal.h>
#include <SdFat.h>
#include <TimerOne.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
SdFat sd;
SdFile romFile;
#define filenameLength 100 // максимальная длина имени файла
char fileName[filenameLength + 1]; // имя текущего файла
char sfileName[13]; // короткое имя текущего файла
int currentFile = 1; // текущая позиция в директории
int maxFile = 0; // всего позиций в лиректории (файлов и поддиректорий)
byte isDir = 0; // признак того, что текущая позиция -- это директория
byte BLs = 0x01; // начальный блок
unsigned int Nbt; // размер файла, байт
volatile byte BUFF[256]; // буфер данных
volatile unsigned int CRB = 0; // индекс чтения из буфера
volatile byte bBit = 15; // индекс читаемого полубита
unsigned int CWB = 0; // индекс записи в буфер
unsigned int CRB_temp = 0; // временная переменная для CRB
// Заголовок
byte SB[27] = {
0x4E, 0x4F, 0x44, 0x49, 0x53, 0x43, 0x30, 0x30, // NODISK00
0x31, 0x34, 0x30, 0x32, 0x31, 0x38, // дата: 140218
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, // имя программы
0x20, 0x20, 0x20, 0x00, 0x00 };
volatile int Tpp = 200; // Начальная длительность задержки сигнала в микросекундах (один полупериод)
volatile int Tb = 64; // Дополнительная задержка сигнала на начало байта в микросекундах
const int p = 3; // номер пина, на который будет вывод сигнала
const int BT_none = 0; // константы -- коды нажатой кнопки
const int BT_right = 1;
const int BT_up = 2;
const int BT_down = 3;
const int BT_left = 4;
const int BT_select = 5;
void setup() {
pinMode(p, OUTPUT); // объявляем пин как выход
digitalWrite(p, LOW);
pinMode(10, OUTPUT); // CS для SD-картридера
lcd.begin(16, 2); // объявляем размер экрана 16 символов и 2 строки
Timer1.initialize(Tpp); // инициализировать timer1, и установить период Tpp мкс.
Timer1.attachInterrupt(SendHalfBit); // прикрепить SendHalfBit(), как обработчик прерывания по переполнению таймера
Timer1.stop();
while (!sd.begin(10,SPI_FULL_SPEED)){ // SD-карта готова?
printtext("SD-card failed!",0);
tone(p, 200, 100); // нет -- включаем на 200 Гц на 100 мс
delay(3000); // ждем 3 с
}
printtext("SD-card is OK.",0);
sd.chdir(); // устанавливаем корневую директорию SD
getMaxFile(); // получаем количество файлов в директории
seekFile(); // переходим к первому файлу в директории
}
void loop() {
lcd.setCursor(0, 1); // устанавливаем курсор в позицию 0 в строке 1
lcd.print(millis()/1000); // выводим количество секунд с момента влючения ардуины -- это для теста...
int button = getPressedButton(); // какая кнопка нажата?
switch (button)
{
case BT_right: // вход в директорию, или запуск файла на воспроизведение
if(isDir==1) { //Если это директория, то переход в неё
sd.chdir(fileName, true);
getMaxFile();
currentFile=1;
seekFile();
}
else { // если не директория -- пробуем воспроизвести файл
if(romFile.cwd()->exists(sfileName)) {
printtext("Not ROM-file",1);
if (Nbt != 0xFFFF) { // проверяем размер файла
for (int i=0;12;i++){ // цикл по имени файла
if (sfileName[i]=='.'){ // ищем точку в имени файла
if ((sfileName[i+1]|0x20)=='r') { // проверяем следующий символ (расширения) == 'r'|'R'
if (((sfileName[i+2]|0x20)=='o')|((sfileName[i+2]|0x20)=='0')) { // == 'o'|'O'|'0'
if ((sfileName[i+2]|0x20)!='0') { // проверка на вывод нулевого блока по расширению файла
BLs = 0x01; // с первого блока
}
else {
BLs = 0x00; // с нулевого блока
}
if ((sfileName[i+3]|0x20)=='m') { // == 'm'|'M'
printtext("Playing...",1);
int RCrom = PlayROM(sfileName, i);// Передаём короткое имя файла и позицию точки в качестве параметров
switch (RCrom) // Проверяем код возврата
{
case 0:
printtext("Done.",1); // Всё закончилось успешно.
break;
case 1:
printtext("Stopped",1); // Сообщение об остановке
while(getPressedButton()!=BT_none) { // Ждём, пока не будет отпущена кнопка
delay(50);
}
break;
default:
printtext("ERROR!",1); // Сообщение об ошибке
}
digitalWrite(p, LOW);
seekFile();
}
}
}
break;
}
}
}
else {
printtext("File is too big",1);
}
}
else {
printtext("No File Selected",1);
}
delay(1000); // ждем 1 с
printtext(" ",1); // очищаем строку 1
}
break;
case BT_left: // возврат в корневую директорию, ремарка ниже:
//SDFat has no easy way to move up a directory, so returning to root is the easiest way.
//each directory (except the root) must have a file called ROOT (no extension)
sd.chdir(true);
getMaxFile();
currentFile=1;
seekFile();
break;
case BT_up: // вверх по файлам в директории
currentFile--;
if(currentFile<1) {
getMaxFile();
currentFile = maxFile;
}
seekFile();
break;
case BT_down: // вниз по файлам в директории
currentFile++;
if(currentFile>maxFile) {
currentFile=1;
}
seekFile();
break;
case BT_select: // выход в настройки...
printtext("Period(mks):",0);
do {
while(getPressedButton()!=BT_none) { // Ждём, пока не будет отпущена кнопка
delay(50);
}
delay(200);
button = getPressedButton(); // какая кнопка нажата?
switch (button)
{
case BT_up:
if (Tpp<400) Tpp += 8;
break;
case BT_down:
if (Tpp>176) Tpp = Tpp - 8;
break;
}
if (Tpp <= 264) { // Выставляем значение задержки на начало байта Tb
Tb = 16; // для полупериода от 248 до 264
if (Tpp <= 240) Tb = 264 - Tpp; // для полупериода меньше или равном 240
}
else Tb = 0; // для полупериода больше 264
lcd.setCursor(12,0);
lcd.print(Tpp);
}
while(button!=BT_select); // Цикл пока не будет снова нажата кнопка select
seekFile();
break;
case BT_none: // ничего не нажато
break;
}
while(getPressedButton()!=BT_none) { // Ждём, пока не будет отпущена кнопка
delay(50);
}
}
//=================================================================
int getPressedButton() // функция проверки нажатой кнопки
{
int buttonValue = analogRead(0);
if (buttonValue < 100) return BT_right;
else if (buttonValue < 200) return BT_up;
else if (buttonValue < 400) return BT_down;
else if (buttonValue < 600) return BT_left;
else if (buttonValue < 800) return BT_select;
return BT_none;
}
void printtext(char* text, int l) { // Вывод текста на экран в строке l с очисткой строки
lcd.setCursor(0,l);
lcd.print(" ");
lcd.setCursor(0,l);
lcd.print(text);
}
void getMaxFile() { // считаем файлы в текущей директории и сохраняем в maxFile
romFile.cwd()->rewind();
maxFile=0;
while(romFile.openNext(romFile.cwd(),O_READ)) {
romFile.close();
maxFile++;
}
}
void seekFile() { // переход на позицию в директории, сохранение имени файла и показ его на экране
romFile.cwd()->rewind();
for(int i=1;i<currentFile;i++) { // читаем первые файлы до currentFile
romFile.openNext(romFile.cwd(),O_READ);
romFile.close();
}
romFile.openNext(romFile.cwd(),O_READ); // читаем данные текущего файла
romFile.getName(fileName,filenameLength);
romFile.getSFN(sfileName);
isDir = romFile.isDir();
if (romFile.fileSize()<=49152) { // проверка размера файла
Nbt = romFile.fileSize(); // размер файла ОК
}
else {
Nbt = 0xFFFF; // слишком большой для загрузки
}
romFile.close();
printtext(sfileName,0); // вывод имени текущего файла
if (isDir==1) lcd.print('>'); // если это директория, добавляем в конце символ '>'
}
int PlayROM(char FName[], int pnt) // функция вывода файла
{
delay(1000); // ждем 1 с
if (romFile.open(FName,O_READ)) { // открываем файл. Открылся?
byte BLe = Nbt/256; // всего блоков
byte BLt; // осталось блоков
byte Nst; // номер строки
byte St; // выводимый байт
byte CSz = 0x00; // контрольная сумма заголовка
byte CSs = 0x00; // контрольная сумма строки
byte i;
byte j;
if (Nbt%256 != 0) BLe++; // корректировка количества блоков, если размер файла не кратен 256
for (i=0; i<=7; i++){ // заносим в SB имя файла
if (i < pnt) { // имя ещё не закончилось?
if ((FName[i]>=0x61) && (FName[i]<=0x7A)) {
SB[i+14] = FName[i] - 0x20; // на заглавные буквы
}
else if (FName[i]!=0x7E) { // не тильда
SB[i+14] = FName[i];
}
else {
SB[i+14] = '_'; // меняем тильду на подчёркивание, иначе это будет русская "Ч"
}
}
else SB[i+14] = 0x20; // пробелы
}
for (i=1; i<=3; i++){ // заносим в SB расширение файла
if ((FName[pnt+i]>=0x61) && (FName[pnt+i]<=0x7A)) {
SB[i+21] = FName[pnt+i] - 0x20; // на заглавные буквы
}
else {
SB[i+21] = FName[pnt+i];
}
}
dir_t d;
romFile.dirEntry(&d); // Считываем дату файла
uint16_t AAA = FAT_DAY(d.lastWriteDate); // Сохраняем дату файла в заголовке -- день
SB[8] = (AAA%100)/10 + '0'; // перевод из целого в символ
SB[9] = AAA%10 + '0';
AAA = FAT_MONTH(d.lastWriteDate); // месяц
SB[10] = (AAA%100)/10 + '0';
SB[11] = AAA%10 + '0';
AAA = FAT_YEAR(d.lastWriteDate); // последние две цифры года
SB[12] = (AAA%100)/10 + '0';
SB[13] = AAA%10 + '0';
// Начинаем наполнять буфер
for (i=0; i<=3; i++){ // преамбула (4*(00H*25+55H*25))
for (j=0; j<=24; j++){
BUFF[lowByte(CWB)] = 0x00;
CWB++;
}
for (j=0; j<=24; j++){
BUFF[lowByte(CWB)] = 0x55;
CWB++;
}
}
Timer1.setPeriod(Tpp); // Выставляем период таймера
Timer1.start(); // Запускаем таймер............
for (BLt=BLe; BLt>=1; BLt--){ // Вывод блоков данных в цикле
CSz = BLs;
CSz += BLe;
CSz += BLt;
for (j=0; j<=15; j++) ToBUFF(0x00);// 00h*16
for (j=0; j<=3; j++) ToBUFF(0x55);// 55h*4
ToBUFF(0xE6); // E6h*1
for (j=0; j<=3; j++) ToBUFF(0x00);// 00h*4
for (j=0; j<=26; j++){ // заголовок блока
CSz += SB[j];
ToBUFF(SB[j]);
}
ToBUFF(BLs); // начальный блок
ToBUFF(BLe); // конечный блок
ToBUFF(BLt); // осталось блоков
lcd.setCursor(12, 1); // выводим на экран кол-во оставшихся блоков
lcd.print(BLt);
lcd.print(" ");
ToBUFF(CSz); // контр.сумма заголовка
for (Nst=0x80; Nst<=0x87; Nst++){ // вывод строк (8 шт.)
for (j=0; j<=3; j++) ToBUFF(0x00);// 00h*4
ToBUFF(0xE6); // E6h*1
CSs = Nst;
ToBUFF(Nst); // номер строки
CSs += CSz;
ToBUFF(CSz); // контр.сумма заголовка
// начинаем вывод строки данных
for (j=0; j<=31; j++){ // цикл на 32 байта
if (Nbt > 0){ // ещё есть данные?
St = romFile.read(); // читаем очередной байт из файла
Nbt--;
}
else { // нет -- дополняем нулями
St = 0x00;
}
ToBUFF(St); // передаём считанный байт
CSs += St;
if (getPressedButton()!=BT_none) { // кнопка нажата?
Timer1.stop(); // Останавливаем таймер
CRB = 0; // Сбрасываем индексы.
CWB = 0;
bBit = 15;
romFile.close(); // закрываем файл
return 1; // выход из ПП с ошибкой 1.
}
if (CRB_temp > CWB) { // проверка -- не обогнало ли чтение запись?
Timer1.stop(); // Останавливаем таймер
CRB = 0; // Сбрасываем индексы.
CWB = 0;
bBit = 15;
romFile.close(); // закрываем файл
return 2; // выход из ПП с ошибкой 2.
}
}
ToBUFF(CSs); // контр.сумма строки
}
}
romFile.close(); // закрываем файл
for (j=0; j<=31; j++) ToBUFF(0x00);// 00h*32 -- завершение вывода программы (?)
}
else tone(p, 200, 300); // нет файла -- включаем на 200 Гц на 300 мс
do{ // Ждём опустошения буфера
delay(Tpp/64); // задержка на вывод 1 байта (~Tpp*16/1000)
noInterrupts(); // запрет прерываний
CRB_temp = CRB; // сохраняем CRB во временную переменную
interrupts(); // разрешение прерываний
}
while (CRB_temp < CWB);
Timer1.stop(); // Останавливаем таймер............
CRB = 0; // Сбрасываем индексы.
CWB = 0;
bBit = 15;
return 0; // выход из ПП с кодом 0.
}
void ToBUFF(byte SBb){ // Подпрограмма записи байта в буфер
noInterrupts(); // запрет прерываний
CRB_temp = CRB; // сохраняем CRB во временную переменную
interrupts(); // разрешение прерываний
if (CWB > (CRB_temp + 255)) { // Если позиция записи больше, чем позиция чтения + размер буфера - 1
delay(Tpp); // Задержка (Tpp*1000 мкс = Tpp мс = 125 байт)
}
BUFF[lowByte(CWB)] = SBb;
CWB++;
}
void SendHalfBit() { // Подпрограмма вывода полубита по циклу таймера
byte Pd=PORTD;
if (bBit & 1){ // проверка индекса полубитов на чётность
if (( (Pd >> p)^( BUFF[lowByte(CRB)] >> (bBit >> 1) ))&1){ // Если состояние порта и выводимый бит разные
Pd ^= (1 << p); // инвертируем бит в позиции p
}
}
else{ // чётный -- просто инвертируем порт
Pd ^= (1 << p); // инвертируем бит в позиции p(=3)
}
PORTD = Pd; // вывод в порт p
if (bBit > 0) { // правим счётчики полубитов и байтов
bBit--;
if (bBit == 14) Timer1.setPeriod(Tpp); // Выставляем период таймера (биты)
}
else{
bBit = 15;
CRB++;
if (CRB > 200) Timer1.setPeriod(Tpp+Tb); // Выставляем увеличенный период таймера (начало байта)
}
}
[свернуть]
Изменения:
- сделана дополнительная задержка между байтами при передаче данных, что позволило существенно повысить скорость чтения Вектором.
Примечание: для увеличения стабильности определения Вектором начала передачи и расчёта скорости, добавление задержек в начальный заголовок передаваемых данных не делается.
Исходники с библиотеками в одном архиве: Вложение 64571
До такого я не допетрил, но заметил, что длительность полупериода должна быть кратной 16. Т.е. на 112, 128, 156, 172 ... таймингах нормально грузит, а на значениях между ними, даже с разницей 1-2 единицы от указанных величин, либо вообще не подхватывает, либо быстро ошибку ловит...Цитата:
... После нескольких экспериментов установил, что для стабильного считывания нужно, чтобы задержка между байтами была в сумме равна около 256 мкс, т.е. при полупериоде 200 мкс в начале байта нужно добавить 56 мкс, 192 мкс -- +64 мкс и т.п. ...
Наконец получилось с помощью объединённого ROM-плеера/SD-ROM картриджа считать заводской загрузчик, на SD-карту, не прибегая ни к каким припаиваниям, замыканиям, и прочим аппаратным ухищрениям. Просто загрузил программку, которая слила загрузчик на SD-карту.
Сравню с имеющимися загрузчиками, может есть отличия...
От загрузчика kish2 отличается.
Как минимум автостарт же надо было реализовать, чтобы пзу не отключилось (типа как в ROM-REAPER/TURBO-COPY), или как?Цитата:
Сообщение от KTSerg
Не, нужно было не заставить ПЗУ включиться, а обмануть загрузчик и перехватить управление ДО выключения ПЗУ (до сброса).Цитата:
Сообщение от ivagor
Я тупанул, пошел по прямой дорожке, и потратил почти целый день на войну с загрузчиком, пытаясь перехватить у него управление.
Не мог понять почему читаю сплошные "00", даже схему изучал, думал, что прочитать инфу, из программы за пределами области памяти загрузчика, нельзя (ошибочное предположение, но другое в голову не приходило). Оказалось, что перед передачей управления моей (загруженной) программе, загрузчик успевал щелкнуть рэлюхой (её управление заведено на схему "сброса"), и ПЗУ отключалось.
Мог за пол часа, в эмуляторе сделать скриншот загрузочной сетки Вектора, вырезать из него экранную область, дорисовать квадратики в загрузочной сетке, поправить стек в адресах 0xDExxh, прикрепить полученное к своей программе ... и получить результат.
Насколько я знаю, чисто программно заставить ПЗУ включиться нельзя.Цитата:
Сообщение от KTSerg
ROM-REAPER/TURBO-COPY как раз автостартуют, т.е. перехватывают управление до отключения ПЗУ.
Может я его с чем-то путаю, но в картотеке есть описание выгружалки ПЗУ, там нужно в схему Вектора кнопку и диод допаять.Цитата:
Сообщение от ivagor
С кнопкой это ROM-DUMPER
А чисто программный - ROM-REAPER