Ардуино - запись звука

Ivanoff-iv

[uquote="Morroc",url="/forum/viewtopic.php?p=4239675#p4239675"]а мы это успеем между отсчетами ADC ? это надо практически проверять, все остальное вполне возможно[/uquote] делал плейер на меге8 (за основу взял плеер на тини2313 с гетчипа - главный недостаток того - недопустимость фрагментации т.к. чтение было побайтным, буфера не было и искать следующий блок было некогда) сделал буфер на 512, но затыки были, пришлось сделать 2 функции чтения, первая инициировала чтение и считывала первые 128 байт, вторая считывала остаток, вызывались они поочереди, при воспроизведении соответственно 128го и 0го байтов буфера. (цифры точно не помню - давно это было... помню, что буфер был разделен на неравные части)

Реклама

Morroc

[uquote="olegue",url="/forum/viewtopic.php?p=4239681#p4239681"]мне не нравиться эта "программная перезагрузка". Не срывает ли она следующий за ней сброс данных на карту?[/uquote]
не срывает, просто добавляет паузу перед следующим стартом записи. если залить программатором без загрузчика, то будет незаметно, думаю

[uquote="olegue",url="/forum/viewtopic.php?p=4239681#p4239681"]Morroc уже отмечат, что это какая-то дичь. Может и правда эта перезагрузка не нужна[/uquote]
И перезагрузка дичь и указанная причина тоже какая то дичь, но не исключаю, что какой то глюк она устраняет

Реклама

olegue

Еще очень нужная вещь это увеличиение количества файлов , сейчас файлы нумеруются от 0 до 255 , т.е используется типа BYTE

хочу перейти к int и увеличить до 32000

счас у меня вот так

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

 
byte RecordNumber; /* Номер записи - храним в EEPROM. в диапазоне 0..255. */
..................
 /* Записываем в RecordNumber, значение из ячейки №0 EEPROM, и прибавляем 1. */
    RecordNumber = EEPROM.read(0) + 1;
    /* Записываем в ячейку №0 EEPROM, увеличенное значение RecordNumber. */
    EEPROM.write(0, RecordNumber);

вычитал тут http://codius.ru/articles/Arduino_EEPRO ... 1%8C%D1%8E

что теперь нужно использовать put и get

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

 
int RecordNumber; /* Номер записи - храним в EEPROM. в диапазоне 0..32767. */
..................
void loo(){
.............
 /* Записываем в RecordNumber, значение из ячейки №0 EEPROM, и прибавляем 1. */
     EEPROM.get(0,RecordNumber+ 1) ;
    /* Записываем в ячейку №0 EEPROM, увеличенное значение RecordNumber. */
    EEPROM.put(0, RecordNumber);

так пойдет?

Добавлено after 37 minutes 40 seconds:
часы таки придется пристраивать. Как имея информацию с часов записать файл с правильным временем?

roman.com

Morroc писал(а):а мы это успеем между отсчетами ADC ? это надо практически проверять, все остальное вполне возможно

а давайте посчитаем ! )) а лучше измерим))

когда я что-то делаю... я первым делом всё проверяю в Протеусе...

-когда я пишу на Си я считаю тайминги с точностью до 1 микросекунды))

тайминги.jpg: (150.85 КБ) 83 скачивания

-когда я пишу на Ассемблере я считаю тайминги с точностью до 1-го машинного такта процессора))

Ethernet-Atmega8-тр.jpg: (200.93 КБ) 79 скачиваний

и с Ардуино я делаю тоже самое))

ILI9341-ардуино.jpg: (145.77 КБ) 90 скачиваний

ааа... !!! я чуть не попал в секту свидетелей Ардуино))

поэтому мы взяли код для TFT экрана из Ардуино..

ILI9341-ардуино-переделанный.jpg: (132.9 КБ) 77 скачиваний

и переписывали код Ардуино на нормальный и понятный всем человеческий язык СИ ))
а затем уже нормальный переделанный код на понятном всем человеческом языке СИ мы залили в AVR...

ILI9341-ATmega128.jpg: (105.28 КБ) 82 скачивания

всё работает))

Реклама

Morroc

а куда смотреть то ? где время ?

Реклама

roman.com

roman.com писал(а):
Morroc писал(а):а мы это успеем между отсчетами ADC ? это надо практически проверять, все остальное вполне возможно
а давайте посчитаем ! )) а лучше измерим))

берём код ADC...

ATmega8-ADC.c: (2.76 КБ) 88 скачиваний

закидываем в Протеус и смотрим))

ADC.jpg: (97.71 КБ) 86 скачиваний

одно преобразование ADC занимает 57 микросекунд... при условии // 8 МГц/32=250.000 Hz
и это с фильтром шума ADC ))

а какая у нас частота wav потока ?
допустим 8000 семплов / секунду... это при минимальном качество звука))
значит мы должны запускать преобразование ADC каждые 1/8000 = 0,000125 секунд.
проверяем))

тайминг_ADC_0.jpg: (105.6 КБ) 81 скачивание

67 микросекунд - время преобразования ADC
58 микросекунд - свободное процессорное время))

оптимизируем))
отключим режим стабилизации ADC...
отключим фильтр шума ADC...
для записи wav они нам не нужны))

тайминг_ADC_1.jpg: (95.87 КБ) 82 скачивания

57 микросекунд - время преобразования ADC
68 микросекунд - свободное процессорное время))

ещё оптимизируем))
будем брать не 10 бит преобразования ADC... а будем брать младшие 8 бит преобразования ADC... чтоб был ровно один байт ))

ADC_55_us.jpg: (100.34 КБ) 80 скачиваний

55 микросекунд - время преобразования ADC
70 микросекунд - свободное процессорное время))

Итого:
мы получили 70 микросекунд - свободное процессорное время))

Но пока мы так и не ответили на простой вопрос:
успеем ли мы за 70 микросекунд из буфера ATmega8 размером 512 байт передать 512 байт в буфер флешки SRAM на 512 байт ?

На самом деле 70 микросекунд - это вагон времени !!! ))

Реклама

olegue

[uquote="Martian",url="/forum/viewtopic.php?p=4239815#p4239815"]

olegue писал(а):так пойдет?

да, тем более, что теперь можно записывать туда сразу сформированное имя, а не только int (если это понадобится)[/uquote]

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

if (digitalRead(btnStart) == LOW && recPressed == 0) {
    /* Записываем в RecordNumber, значение из ячейки №0 EEPROM, и прибавляем 1. */
    /*RecordNumber = EEPROM.read(0) + 1;*/
     if (RecordNumber == 32767)RecordNumber = 0;

       EEPROM.get(0,RecordNumber) ;
       /* Записываем в ячейку №0 EEPROM, увеличенное значение RecordNumber. */
    /*EEPROM.write(0, RecordNumber);*/
    EEPROM.put(0, RecordNumber+1);

да, все получилось

roman.com писал(а):берём код ADC...

я смотрю тут Роман атмегу8 параллельно заряжает...

roman.com

olegue писал(а):я смотрю тут Роман атмегу8 параллельно заряжает...

угу))

далее...
а сколько времени занимает запись данных из ADC в буфер ?

ADC_bufer.jpg: (92.71 КБ) 80 скачиваний

~1 микросекунда )) зависит от настройки... int... chart... и т.д.

а сколько времени занимает запись буфера 512 байт ATmega8 ?
считаем:
запускаем преобразование ADC каждые 1/8000 = 0,000125 секунд * 512 байт = 0,064 секунд.
проверяем...

ADC_bufer_512.jpg: (95.53 КБ) 84 скачивания

всё сходится))

Итого:
55 микросекунд - время преобразования ADC.
1 микросекунда - время записи ADC в буфер 512 байт ATmega8.
69 микросекунд - свободное процессорное время))

значит мы должны записывать сектора на флешку каждые 0,064 секунды.
Или по другому - скорость записи флешки - 15,625 секторов в секунду))

И осталось ответить на последний вопрос:
успеем ли мы за 69 микросекунд из буфера ATmega8 размером 512 байт передать 512 байт в буфер флешки SRAM на 512 байт ?

На самом деле 69 микросекунд - это вагон времени !!! ))

Добавлено after 19 minutes 16 seconds:
далее..
подключаем флешку к ATmega8 по SPI...

Отступление ))
В представленном коде...

microSD.c: (12.24 КБ) 84 скачивания

мы подключили флешку к ATmega8 по программному SPI...

////////////////////////////////////////// программный SPI3/4МГц/0.000.060 microSD:
void SPI3(void)
{
rx3=0; // сброс RX
mask3=0b10000000;
do {
if (tx3 & mask3) PORTD.7 = 1;// выход MOSI
else PORTD.7 = 0;// выход MOSI
delay_us(2);
PORTD.6=1; // выход SCK
if (PIND.5) rx3 |= mask3; // вход MISO
PORTD.6=0; // выход SCK
mask3=(mask3>>1);
}
while (mask3);
delay_us(2);
PORTD.7 = 0; // сброс MOSI
}

а в каких случаях используется программный SPI ?
например в случае отсутствия апаратного SPI в МК )) мы же пишем универсальный код... для любых МК ))

проблема в том что программный SPI работает медленно... ~ 100 кбит/с... в 69 микросекунд не уложимся))

значит будем подключать флешку по апаратному SPI...
////////////////////////////////// SPI:
void SPI(void)
{
SPDR=tx; while(!(SPSR & (1<<7))); rx=SPDR;
}

Скорость работы апаратного SPI = 8 МГц/4 = 2 МГц -режим мастер
С учётом накладных расходов... можно рассчитывать на ~ 1 Мбит/с.

Ivanoff-iv

ну... можно же кварц пошустрей поставить, или сэмплрейт снизить... (на случай отсутствия аппаратного SPI)

olegue

[uquote="Martian",url="/forum/viewtopic.php?p=4239857#p4239857"]

olegue писал(а): if (RecordNumber == 32767)RecordNumber = 0;

32767 не очень красиво, наверняка в ардуино есть константа типа INT_MAX, и тогда запись if (RecordNumber == INT_MAX) RecordNumber = 0; более универсальна - вдруг завтра int станет 4-разрядным... Но это так, мелочь и несущественно.[/uquote]

а что если вместо INT объявить unsignet INT - это же беззнаковое целое , до 65 000. При этом можно ж до этой цифры файлы гнать?

Добавлено after 1 minute 17 seconds:
roman.com, в Атмеге8 есть аппаратный SPI?

Добавлено after 26 minutes 48 seconds:
[uquote="Morroc",url="/forum/viewtopic.php?p=4239803#p4239803"]а куда смотреть то ? где время ?[/uquote]

Подключаю часы по i2c, но на А5 (SCL) висит вход звука. Поэтому буду его перености на А0

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

void Setup_ADC() {

  ADMUX = 0x65; // set ADC to read pin A5, ADLAR to 1 (left adjust)
  cbi(ADCSRA, ADPS2); // set prescaler to 8 / ADC clock = 2MHz
  sbi(ADCSRA, ADPS1);
  sbi(ADCSRA, ADPS0);

имею ADMUX=0x65 это в двоичной 0b0110 0101 где 0101 и есть А5, а мне надо А0 т.е 0000
получаю 0b0110 0000 , перевожу в хекс - ADMUX=0x60

Годится?

VNS · Сообщение **VNS** » Ср июн 01, 2022 17:01:45

[uquote="olegue",url="/forum/viewtopic.php?p=4239875#p4239875"]в Атмеге8 есть аппаратный SPI?[/uquote]
Да.

1.png: (12.44 КБ) 85 скачиваний

2.png: (67.24 КБ) 79 скачиваний

roman.com

далее...
[uquote="Ivanoff-iv",url="/forum/viewtopic.php?p=4239871#p4239871"]ну... можно же кварц пошустрей поставить, или сэмплрейт снизить... (на случай отсутствия аппаратного SPI)[/uquote]
1. кварц мы пока ставить не будем.
2. семплерт снижать уже некуда)) и так уже минимальное качество звука - 8000 семплов/с.

далее...

Скорость работы апаратного SPI = 8 МГц/4 = 2 МГц -режим мастер
С учётом накладных расходов... можно рассчитывать на ~ 1 Мбит/с.

сколько по времени передать из буфера ATmega8 размером 512 байт передать 512 байт в буфер флешки SRAM на 512 байт ?
считаем...
~ 1 Мбит/с / 8 = 125000 байт/c.
1 байт будем передавать... 0,000008 с.
проверяем...

SPI_1.jpg: (96.71 КБ) 88 скачиваний

всё сходится))

а нам надо передать 512 байт...
0,000008 с * 512 = 0,004096.
проверяем...

SPI_0.jpg: (94.14 КБ) 82 скачивания

всё сходится))

а сколько у нас свободного процессорного времени ? 0,000069 c....
Не сходится !

а я предупреждал... ))

1. за 0,000069 c.... мы можем передать только 8 байт... а это 512/8 = 64 раза меньше чем нужно ))
а что делать ?

2. самое простое - это переключить SPI в режим удвоенной скорости )) x2 )) так мы уже делали в прошлом проекте...
за 0,000069 c.... SPI будет передавать по 16 байт... всё равно мало))

3. переключить тактовый генератор с 8 МГц на 16 МГц (как в Ардуино). так мы уже делали в прошлом проекте...
за 0,000069 c.... SPI будет передавать по 32 байт... всё равно мало))
максимальная рабочая тактовая частота ATmega8 до 25 МГц... всё равно мало)) так мы уже делали в прошлом проекте...
как ни крути... поднимать частоту бессмысленно))

4. нужно изменить алгоритм работы... Если за один раз передать не получается, то будем передавать частями)) точно!))
так мы уже делали в прошлом проекте...

Novice user

[uquote="Morroc",url="/forum/viewtopic.php?p=4239580#p4239580"][uquote="Novice user",url="/forum/viewtopic.php?p=4239571#p4239571"]если данные АЦП писать сразу на флешку,когда сектор заполнится переходим в след сектор-получится?[/uquote]
каждый байт что ли ? кроме того, что это изнасилование флэшки (она побайтно не умеет и будет переписывать сектор), так еще и долго

понаберут восьмых мег на 20р дешевле, потом мозг ломают себе и окружающим

[/uquote]
Читайте первый пост данной темы-автор темы хочет переделать на атмега8 а не я

Добавлено after 4 minutes 46 seconds:
4. вот именно это я и имел ввиду,но думал писать побайтно
И причем тут "(она побайтно не умеет и будет переписывать сектор)",я и пишу что пишем сектор,просто самы байты пишем не со скоростью несколько миллионов в секунду,а после каждого преобразования АЦП,то есть если АЦП работает на частоте 8 кГц то и передаем байты с такой же скоростью,дошли до конца сектора-переключились на следующий и дальше пишем

roman.com

4. мы можем передавать буфер частями... по 1... 2... 3... 4... 5... 6... 7... 8... байт
тогда нам нужно 512 / 8 = 64 транзакции))

5. мы вообще можем не использовать буфер ATmega8... а измерять ADC и сразу передавать по SPI...

ADC_SPI.jpg: (93.89 КБ) 82 скачивания

Итого:
55 микросекунд - время преобразования ADC.
8 микросекунд - время передачи по SPI.
62 микросекунд - свободное процессорное время))
так совсем хорошо))

//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////// TX_microSD:
void TX_microSD(unsigned long x)
{
/////////////////////// crc bufer_microSD[512]:
crc=0xFFFF;
for (b=0;b<510;b=b+2) {
bcrc=bufer_microSD; bcrc=(bcrc<<8)|bufer_microSD[b+1]; fcrc();
};
bufer_microSD[510]=(crc>>8); // crc
bufer_microSD[511]=crc; // crc
///////////////////////////////////////////////
PORTB.0=0; // SS microSD
/////////////////////// запись Data:
tx3=0x58; SPI3(); // 01xx xxxx + Номер команды - CMD24
tx3=(x>>24); SPI3(); // адрес
tx3=(x>>16); SPI3(); // адрес
tx3=(x>>8); SPI3(); // адрес
tx3=x; SPI3(); // адрес
tx3=0x00; SPI3(); // 0000 0000. CRC - 0
// ответ R1: 0000 0000 - команда microSD принята
tx3=0xFF; SPI3(); // задержка 1 байт 0xFF
tx3=0xFF; SPI3(); // STATUS R1 0000 0000
//////////////////////////////////////////////////////////////////////////////// метка:
tx3=0xFE; SPI3(); // 0xFE метка для команды - CMD24
//////////////////////
for (a=0; a<512; a++) {
tx3=ADC; SPI3(); // ADC > microSD
};
////////////////////
tx3=0x00; SPI3(); // CRC - 0
tx3=0x00; SPI3(); // CRC - 0
/////////////////////////////////////////////////////////// ответ - данные приняты 0xE5:
tx3=0xFF; SPI3(); // SPI пустой
/////////////////////////////////////////////////// ждём окончания записи... OUT = 0xFF:
while ( (x1 != 0xFF) && (tm_microSD != 255) ) {
tx3=0xFF; SPI3(); x1=rx3; // MOSI 0x00 > MOSI 0xFF // -цикл 34...53
tm_microSD++;
};
//////////////
if (tm_microSD == 255) { // таймаут microSD:
error_microSD_EEPROM |= 0b00010000; // 0001 0000 - error microSD_TX
};
tm_microSD = 0; // сброс таймаут tm_microSD.
////////////////////////////////////////////////////////////////
PORTB.0=1; // SS microSD
////////////////////////////////////////////////////////////////////////////////////////
// microSD - ток = 0 mA.

надо выкинуть отсюда всё лишнее ))

Novice user

Я об этом и писал...

roman.com

первым делом выкидываем контрольные суммы... CRC-16 ))

4. мы можем передавать буфер частями... по 1... 2... 3... 4... 5... 6... 7... 8... байт
тогда нам нужно 512 / 8 = 64 транзакции))

5. мы вообще можем не использовать буфер ATmega8... а измерять ADC и сразу передавать по SPI...

ADC_SPI.jpg: (93.89 КБ) 96 скачиваний

Итого:
55 микросекунд - время преобразования ADC.
8 микросекунд - время передачи по SPI.
62 микросекунд - свободное процессорное время))
так совсем хорошо))

//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////// TX_microSD:
void TX_microSD(unsigned long x)
{
/////////////////////// crc bufer_microSD[512]:
crc=0xFFFF;
for (b=0;b<510;b=b+2) {
bcrc=bufer_microSD; bcrc=(bcrc<<8)|bufer_microSD[b+1]; fcrc();
};
bufer_microSD[510]=(crc>>8); // crc
bufer_microSD[511]=crc; // crc
///////////////////////////////////////////////

ещё внутри флешки есть подсчёт контрольной суммы CRC-7 ))
по умолчанию CRC-7 внутри самой флешки включена. И после заполнения буфера флешки, флешка проверяет контрольную сумму CRC-7..
Это просто тупизм како-то )) кто вообще придумал считать контрольные суммы CRC-7 ))
все контрольные суммы внутри флешки мы отключили ещё на стадии инициализации...
все эти контрольные суммы... у нас это нет процессорного времени...))

мы сможем писать и читать флешку... но проверить целостность данных мы больше не сможем...

//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////// TX_microSD:
void TX_microSD(unsigned long x)
{
///////////////////////////////////////////////
PORTB.0=0; // SS microSD
/////////////////////// запись Data:
tx3=0x58; SPI3(); // 01xx xxxx + Номер команды - CMD24
tx3=(x>>24); SPI3(); // адрес
tx3=(x>>16); SPI3(); // адрес
tx3=(x>>8); SPI3(); // адрес
tx3=x; SPI3(); // адрес
tx3=0x00; SPI3(); // 0000 0000. CRC - 0
// ответ R1: 0000 0000 - команда microSD принята
tx3=0xFF; SPI3(); // задержка 1 байт 0xFF
tx3=0xFF; SPI3(); // STATUS R1 0000 0000
//////////////////////////////////////////////////////////////////////////////// метка:
tx3=0xFE; SPI3(); // 0xFE метка для команды - CMD24
//////////////////////
for (a=0; a<512; a++) {
tx3=ADC; SPI3(); // ADC > microSD
};
////////////////////
tx3=0x00; SPI3(); // CRC - 0
tx3=0x00; SPI3(); // CRC - 0
/////////////////////////////////////////////////////////// ответ - данные приняты 0xE5:
tx3=0xFF; SPI3(); // SPI пустой
/////////////////////////////////////////////////// ждём окончания записи... OUT = 0xFF:
while ( (x1 != 0xFF) && (tm_microSD != 255) ) {
tx3=0xFF; SPI3(); x1=rx3; // MOSI 0x00 > MOSI 0xFF // -цикл 34...53
tm_microSD++;
};
//////////////
if (tm_microSD == 255) { // таймаут microSD:
error_microSD_EEPROM |= 0b00010000; // 0001 0000 - error microSD_TX
};
tm_microSD = 0; // сброс таймаут tm_microSD.
////////////////////////////////////////////////////////////////
PORTB.0=1; // SS microSD
////////////////////////////////////////////////////////////////////////////////////////

Добавлено after 2 minutes 33 seconds:
и ждать окончания записи... у нас на это тоже нет времени))

код будет примерно такой...
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////// TX_microSD:
void TX_microSD(unsigned long x)
{
///////////////////////////////////////////////
PORTB.0=0; // SS microSD
/////////////////////// запись Data:
tx3=0x58; SPI3(); // 01xx xxxx + Номер команды - CMD24
tx3=(x>>24); SPI3(); // адрес
tx3=(x>>16); SPI3(); // адрес
tx3=(x>>8); SPI3(); // адрес
tx3=x; SPI3(); // адрес
tx3=0x00; SPI3(); // 0000 0000. CRC - 0
// ответ R1: 0000 0000 - команда microSD принята
tx3=0xFF; SPI3(); // задержка 1 байт 0xFF
tx3=0xFF; SPI3(); // STATUS R1 0000 0000
//////////////////////////////////////////////////////////////////////////////// метка:
tx3=0xFE; SPI3(); // 0xFE метка для команды - CMD24
//////////////////////
for (a=0; a<512; a++) {
tx3=ADC; SPI3(); // ADC > microSD
};
////////////////////
tx3=0x00; SPI3(); // CRC - 0
tx3=0x00; SPI3(); // CRC - 0
/////////////////////////////////////////////////////////// ответ - данные приняты 0xE5:
tx3=0xFF; SPI3(); // SPI пустой
////////////////////////////////////////////////////////////////
PORTB.0=1; // SS microSD
////////////////////////////////////////////////////////////////////////////////////////

Добавлено after 1 minute 40 seconds:
и тактовую надо поднять в два раза...
и возможно ещё переключить SPI на удвоенную скорость... а может и не надо))
тогда должно работать нормально))

Добавлено after 4 minutes 23 seconds:
ну и остался последний вопрос...

Как происходит запись на флешку ?

1.
при записи на флешку все данные сначала записываются в буфер SRAM на 512 байт.
2.
после команды "запись" флешка перезаписывает все данные из буфера SRAM на 512 байт в память ROM на 4 Гбайт.

можем ли мы не дожидаясь окончания записи предыдущего сектора сразу писать следующий сектор ?
если да, то проблем нет))
фактически у нас уже готовый диктофон )) ещё добавить кнопочки... но это уже молочи))

осталось всё собрать и протестировать в железе...

Novice user

И разместить новую статью!!!
Ждемс...

Карбофос

[uquote="roman.com",url="/forum/viewtopic.php?p=4239933#p4239933"]первым делом ...[/uquote]
Ну, будет не "ее", а "е".
И чо?
Чел что-то делает, а ты долобоёб.

roman.com

мда... не перевелись ещё дебилы)) ну да ладно.

далее...
проверим вместе с командами записи...

ADC_SPI_1.jpg: (103.8 КБ) 88 скачиваний

вышли за лимит)) всё дело в этом...

tx3=(x>>24); SPI3(); // адрес
tx3=(x>>16); SPI3(); // адрес
tx3=(x>>8); SPI3(); // адрес
tx3=x; SPI3(); // адрес

переменные long слишком долго обрабатываются)) вообще чтоб программа работала быстрей все переменные должны быть char
сделаем адрес через массив...
TX_int[]={0,0,0,0};
tx=TX_int[0]; SPI(); //адрес
tx=TX_int[1]; SPI(); //адрес
tx=TX_int[2]; SPI(); //адрес
tx=TX_int[3]; SPI(); //адрес

ADC_SPI_2.jpg: (108.51 КБ) 100 скачиваний

уже лучше... но мало)) можно поднять тактовую с 8 МГц до 16 МГц... и всё встанет в норму)) но пойдём другим путём - удвоим скорость SPI... ))

ATmega8-SPI.c: (3.76 КБ) 89 скачиваний

SPI на двойной скорости... 3 микросекунды вместо 8 микросекунд...

SPI_2X.jpg: (92.2 КБ) 99 скачиваний

теперь всё в норме))

ADC_SPI_поток.jpg: (108.16 КБ) 100 скачиваний

замечательно))

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

понятно что это тестовая программа... в реальности надо всё сделать на таймере... тактируемого от кварцевого генератора... а запуск преобразования и передача байт по SPI должна происходить в прерываниях таймера... с кварцевой точностью...
тогда всё будет хорошо))

Карбофос

[uquote="roman.com",url="/forum/viewtopic.php?p=4240009#p4240009"]мда... не перевелись ещё дебилы)) ну да ладно[/uquote]
Вот-жеж ты умный.
Прога работает, а ты доказываешь, что она работать не может! ))))
Ты просто долбоЁб.