Решений сего кейса масса, начиная от приобретения и подключения микросхем EEPROM и заканчивая коннектом стандартной USB флешки к аппаратному USB хосту камня (если таковой имеется, конечно). Ну, а для хэнд-майд проектов, отличным вариантом будет самая, что ни на есть классическая SD’шная карта памяти. Они бывают разного типа, имеют различные механизмы инициализации и передачи данных и подключаются к хосту через различные интерфейсы (их, правда, только три, но об этом позже). Более того, многие современные микроконтроллеры имеют на своем борту аппаратные модули этих интерфейсов, и работа разработчика сводится лишь к их конфигу и посылу карточке нужных команд в соответствии с протоколом. Ну и еще карты памяти имеют приятное свойство элементарно покупаться на каждом шагу.

О Secure Digital (SD) картах

Формат SD был основан компаниями Panasonic, SanDisk и Toshiba на основе MMC карт. Позже эти компании создали организацию SD Card Association, в настоящее время занимающуюся разработкой и продвижением технологии SD. Основной документ, в котором досконально описан интерфейс, протокол, команды, регистры карточек - Physical Layer Simplified Specification (Copyright 2001-2006 SD Group (Panasonic, SanDisk, Toshiba) and SD Card Association). Именно эту информацию используют всякие R&D центры при разработки аппаратного и программного обеспечения своих будущих девайсов. Сам файлик благополучно лежит в свободном доступе в инете, и скачать его не предоставляется никаких сложностей. Так вот, в соответствии с этим документом, существуют следующие типы карт памяти:
SD карты (или еще SDSC (Secure Digital Standard Capacity)) – первое поколение карт памяти. Ограничение по объему – 2 Гб. Минимальный размер адресуемого пространства – 1 байт.
SDHC карты (Secure Digital High Capacity) – карты памяти повышенной емкости (до 32 Гб). Имеют существенное отличие от первого типа, а именно, адресация происходит блоками по 512 байт и никто в этом мире не может изменить это значение. Иными словами, нельзя просто так взять и записать, к примеру, 71 байт информации: минимальный размер пачки, повторюсь, 512 байт. Особо не копал, почему так, но есть личное мнение, что это из-за используемого 32-битного адресного пространства контроллера и из-за того, что карты памяти обычно форматируются под ту или иную файловую систему, размер кластера которой удобно сочетается с такими блоками. Еще у SDHC карт дугой процесс инициализации, о котором поговорим чутка по позже.
SDXC (Secure Digital eXtended Capacity) – карты памяти расширенной емкости – теоретически аж до 2Tб памяти. Адресация тоже по 512 байт. Вот оно и получается при 32-битном пространстве: (2^32)*512 = 2 Тб.

На каждое поколение карт существуют спецификации, и при этом в каждом документе на более новое поколение описывается инфа о старых – то есть они «толстеют» с каждым обновлением продукта. Так что скачиваем Physical Layer Simplified Specification самой последней версии и находим там все, что надо для работы со всеми поколениями карт. Кроме этого, карты памяти делятся на несколько классов по скорости чтения/записи данных. Ну, а что касается всяких там mini-, microSD, microSDXC и т.д. – это всего лишь другой размер корпуса и распиновка – никаких внутренних отличий от карточек стандартных габарит.

А теперь важно: ВНЕ зависимости от типа карты, емкости, ее производителя, типа корпуса, цвета и магазина, где вы ее купили – все Security Digital карты имеют одинаковые интерфейсы взаимодействия с внешним миром. Команды, механизмы инициализации – разные, да, но интерфейсы – ОДИНАКОВЫЕ. Именно это позволяет напофиг воткнуть в фотик как SD, так и SDHC карту памяти. Ну, вот и пришел момент обсудить язык карточки, а точнее аж три: SD и UHS-II (нэйтив спикер) и «язык универсальной микропроцессорной коммуникации, который сейчас знает каждая нерезаная собака микроконтроллер» - SPI .

Интерфейс карты памяти

Так что же такое SD протокол и с чем его едят? Ключевых понятий тут три:
команда – последовательность битов, воспринимаемых контроллером карточки и призывающих его к тому или иному действию;
отклик – ответ контроллера карты на команду. Он может содержать как общую информацию (статус карты, текущее состояние различных внутренних модулей и т.д.), так и, собственно, ожидаемую хостом информацию (запросили в команде идентификатор карты – получили его в отклике);
данные – ну тут без комментариев.

Но прежде, чем посмотрим на логику протокола, обратимся к физике интерфейса (очень обзорно).

Pin 4 – питание карточки;
Pin 3, 6 – земля;
Pin 5 – тактовый сигнал;
Pin 2 – линия команд и откликов;
Pin 1, 7, 8, 9 – линии 4-битной шины данных.

Все посылки карточке и обратно есть последовательности битов, строго синхронизированные с тактовым сигналом, передаваемым по линии CLK . Рекомендуемые частоты описаны в спецификации на карту и имеют различное значение, в зависимости от ее типа и класса скорости. Отмечу только, что для любой карты инициализация проходит на очень малой (по сравнению с передачей данных) частоте. Шина данных может быть 1-битной (работает только D0) или 4-битной – это конфигурируется при инициализации. Важно, что для SD карт со стороны хоста линии данных и команд должны быть Push-Pull и быть подтянуты к питанию через резисторы 4.5 – 10 кОм. Тактовую шину тоже нужно подтянуть к питанию.

Ну, а теперь к протоколу!

1) Команды без данных.
Все команды делятся на требующие и не требующие отклик .

Как видно из рисунка, если нам (хосту) нужно послать команду, не требующую отклика – просто шлем ее. Если же, команда подразумевает некий ответ, шлем, а затем ждем ответа. Почти все команды и отклики проверяются контрольной суммой, как со стороны хоста, так и со стороны карты. Ну, посмотрим на формат команды:

Кадр состоит из 48 бит. Первый – старт бит – всегда нуль. Затем, говорим, что данные направляются от хоста к карте и посылаем команду с аргументом. Да, да, команда состоит из индекса и аргумента. После команды обязательно шлем 7-битную контрольную сумму, вычисляемую по алгоритму циклически избыточного кода (CRC) и завершаем посылку стоп битом. Команды бывают двух типов: CMD (базовые команды) и ACMD (Application-Specific Command) . Они могут быть с аргументом и без, иметь отклик и не иметь. Всего существует порядка 80 команд (не считал точно, может и больше) и каждая из них подробно описана в спецификации. Мы остановимся лишь на некоторых, необходимых для основной работы с карточкой (инициализация, чтение, запись). Индекс команды – это та цифра, которая идет после символов CMD или ACMD. Под него отведено 6 бит и 32 бита аргумента команды, если таковой требуется.

Важное пояснение по поводу ACMD : пространство их индексов пересекается с индексами CMD команд, поэтому, чтобы контроллер воспринял команду именно, как Application-Specific, ей должна предшествовать CMD55 !

Отклик (если требуется) – тоже целая тема, хотя бы, потому что их пять типов.

R1 (normal response command) – длина 48 бит. Пожалуй, самый популярный отклик.


Содержит в себе старт бит, бит направления передачи (от карты к хосту), 6 битов индекса команды, побудившей на генерацию отклика, статус карты и, конечно же, контрольную сумму со стоп битом. Всю информацию в отклике этого типа несет 32 битное поле статуса карты . В спецификации тщательно и добросовестно расписано, что означает каждый бит этого статуса (карта занята/свободна, блокирована/разблокирована, текущее состояние автомата передачи данных, готовность к тому или иному действию и многое другое).

R1b – такой же формат, как и в случае R1 отклика, только передает еще флаг занятости (busy) по линии данных.

R2 (CID, CSD register) – длинной в 136 бит отклик передает хосту содержимое CID и CSD регистров контроллера карточки.


Здесь вся полезная информация содержится в 127 битном поле, в которое помещается либо содержимое CID (в случае, если это отклик на CMD2 или CMD10 команду), либо содержимое CSD регистра (в случает посыла CMD9 команды). Так что же это за регистры такие, что под них специальные команды придуманы, да еще и с таким длинным откликом?
CID (Card identification data) – как видно из названия, содержит всю идентификационную информацию о карте (серийный номер, производитель, дата изготовления и др…). CSD (Card-specific data) – вся техническая информация о карте (объем памяти, размер блоков чтения/записи, максимальные скоростные характеристики, максимальные характеристики по потребляемому току в различных режимах и многое другое). Именно эту информацию использует хост мобилы или камеры для получения всей информации о вставленной карточке.

R3 – длиной в 48 бит, приходит как ответ на команду ACMD41 и несет в себе информацию о содержимом OCR (Operation Conditions Register) регистра карты.


ACMD41 – команда инициализации карты. После ее посыла необходимо ожидать данного отклика, который будет говорить об успешном завершении процесса инициализации и сообщать содержимое регистра OCR (доступный диапазон напряжений, тип карты памяти, и флаг занятости).

R6 (Published RCA response) – содержит в себе RCA (Relative card address) карты и некоторые статус биты.


Шина предполагает подключение нескольких карт к одному хосту. Поэтому очень важно такое понятие, как собственный адрес карты на шине. Это и есть содержимое RCA регистра.

R7 (Card interface condition) – 48 битовый отклик на команду CMD8.


Карта оперирует определенным напряжением, ни больше не меньше. До инициализации необходимо это валидировать (об этом позже). В ответе карта посылает само напряжение (точнее значение, соответствующее этому диапазону) и некий чек паттерн (об это тоже позже).

2) Данные.
Напомню (это было сказано давно…), мы рассмотрели посыл команд и получение отклика от карты. Теперь самое время разобраться с тем, как же слать, собственно, данные. Повторюсь, делается это блоками по 512 байт (для SDHC карт) - все адресное пространство карты разбито на 512 байтовый ячейки . Посылке данных всегда должна предшествовать специальная команда, говорящая контроллеру карты о том, что данные вот-вот уже пойдут. А идут они, как я уже говорил – по 1- или 4-битной шине. Посмотрим на формат посылки данных к хосту от карты (чтение).

Возможны два режима передачи данных: одним блоком (block read operation) и несколькими блоками сразу (multiple block read operation). В любом случае, старт передачи и ее завершение происходят по специальной команде, обратите внимание, с откликом.

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

Инициализация SD Карты памяти

ВАЖНО : инициализация проводится на низко скоростном режиме! Частота клока карты не более 400 кГц!!!

Шлем CMD0 , обратим внимание, без аргумента и не ждем ничего в отклике. В результате все карты на линии передут в холостой режим.

Помните, я говорил, что напряжение нужно валидировать? Правильно! Нужно сказать карте, на каком вольтаже мы работаем и выслушать от нее все по этому поводу. Шлем CMD8 с аргументом, в котором биты 11:8 означают напряжение хоста и биты 7:0 – check pattern (проверочный шаблон) – любой, спецификация рекомендует слать 10101010 . Биты напряжения ставятся в соответствии с таблицей:

Ну, у нас все очень даже определено и далеко не Low Voltage Range. Stm32f4 выдает как раз напряжение в диапазоне 2.7 – 3.6 V, так что ставим 1 на восьмом бите аргумента. Итого, имеем команду с аргументом 110101010 . Отправили. Прочекали, что все отправилось хорошо и ждем ответа, он не заставит нас делать это долго. В спецификации увидели, что ответ на эту команду – R7 типа.
Если мы его так и не дождались, то дальнейшая команда ACMD41 решит, как именно нас надули – подсунули карту версии 1.X стандартной емкости или вообще не SD карту. Правда есть вероятность, что мы просто что-то не так делаем. Но не будем о грустном, и предположим, что флешка все таки ответила. Если с напряжением все хорошо, карта довольна, мы довольны, ответ будет содержать в себе все то, что мы отправили в аргументе, то есть 110101010 . Это называется valid esponse . Если так, переходим к дальнейшему шагу, иначе – опять же – либо надули, либо где-то косяк.

Дождались 110101010 , и пришло время непосредственной инициализации – команды ACMD41 . И тут вспоминаем ВАЖНОСТЬ : чтобы сказать карточке, что команда не простая, а ACMD, отправим сперва CMD55 . В аргументе обязательно указываем, адрес той карты, для которой эта команда предназначена. Но стоп, у нас, ведь, пока нет адреса, мы его не знаем. Ничего, узнаем … но по позже, а пока пишем нули и шлем. Получив ответ типа R1 удостоверяемся, что карта готова принимать ACMD и только после этого шлем 41 индекс! Команда идет с аргументом, в котором на месте 30-ого бита указываем 1, что говорит о поддерживаемости хостом SDHC карт и напряжения хоста на месте 23:0 битов (см. содержимое OCR регистра). Ответ ждем R3 типа. Здесь нам важно получить 1 на месте 31ого бита в пачке ответа, несущей содержимое OCR регистра карты (флаг busy). Это будет говорить о том, что карта завершила процесс инициализации. Виду того, что этот процесс длится долго (гораздо дольше, чем тактовый цикл микроконтроллера), необходимо слать ACMD41 в цикле до тех пор, пока не получим ответ со снятым флагом занятости. Как только это случилось, чекам 30 бит, и, если он единица, то имеем карту повышенной емкости SDHC или SDXC, и карту стандартной емкости SD в противном случае. Если же мы ждали, ждали, а флаг бизи все висит и висит, то, как и в описанном выше случае – либо неподходящая карта, либо (скорее всего) наш косяк.

Далее шлем CMD2 - без аргумента и смотрим на ответ R2 . В этом случае он будет нести информацию о содержимом CID регистра, и мы сможем вычитать ID производителя, серийный номер карты и прочую информацию.

И, наконец, заключительный шаг – получение адреса карты (RCA - relative
address ). Как оно уже упоминалось, к одной шине может быть подключено несколько карт, поэтому каждая должна иметь свой уникальный локальный адрес. Шлем CMD3 и получаем ответ типа R6 , в котором в младших 16 битах содержится статус карты, а в старших – новый RCA адрес. Отныне, для доступа к нашей карточке, мы должны будем звать ее по имени, то есть по RCA адресу.

Опциональный пункт. По умолчанию карта работает с 1-битной шиной данных, что, ясное дело, медленнее, чем с 4-х битной. Если мы хотим достичь максимального быстродействия – шлем ACMD6 , с предшествующей CMD55 , конечно же. Но прежде, нужно перевести карту в состояние Transfer State (см. ниже) командой CMD7 с RCA в качестве аргумента. В аргументе ACMD6 на месте самого первого бита пишем 1 – если хотим включить 4-битный мод и 0 – для отключение. Ответ R1 скажет об успешном проведении операции.

Пример инициализации SDHC карты

Char SDHC_card_initialization(unsigned int *RCA) { char result; unsigned int RESP; result = SDIO_send_command(0, 0, 0, RESP); //Посылаем CMD0, дабы обнулить карты if (result != 0) return result; //Чекаем на успех result = SDIO_send_command(8, 0x1AA, 1, RESP); //Посылаем CMD8 с аргументом 110101010 if ((result != 0) || (RESP != 0x1AA)) return 4; //Чекаем на успех while(!(RESP&(1<<31))) //Ждем, пока флаг бизи не слезет { result = SDIO_send_command(55, 0, 1, RESP); //Шлем CMD55, тем самым, говоря, что потом будет ACMD if (result != 0) return result; result = SDIO_send_command(0x29, 0x40020000, 1, RESP); //Шлем ACMD41 if (result != 0) return result; } result = SDIO_send_command(2, 0, 3, RESP); //Шлем CMD2 и получаем инфу о карте if (result != 0) return result; result = SDIO_send_command(3, 0, 1, RESP); //Шлем CMD3 и получаем RCA номер if (result != 0) return result; SDIO->CLKCR = (0x02<<0)|(1<<11)|(1<<8)|(1<<14); //Наращиваем клок (в части 2 - подробнее) *RCA = (RESP & (0xFFFF0000)); //Маскируем отклик и получаем RCA result = SDIO_send_command(7, *RCA, 1, RESP); //Выбираем нашу карту if (result != 0) return result; result = SDIO_send_command(55, *RCA, 1, RESP); //Шлем CMD55, тем самым, говоря, что потом будет ACMD if (result != 0) return result; result = SDIO_send_command(6, 0x02, 1, RESP); //Шлем ACMD6 c аргументом 0x02, установив 4-битный режим if (result != 0) return result; if (RESP != 0x920) return 1; else return 0; //Убеждаемся, что карта находится в готовности работать с трансфером return 0; }
Запускаем код, убеждаемся, что в ответе пришел НУЛЬ и завершаем инициализацию. Все, можем работать с памятью и писать/считывать информацию.

Обмен данными

Запись данных на карту

Чтение данных

Не буду приводить в этой статье листинг программы чтения/записи, так как он, в отличии от подпрограммы инициализации слишком сильно завязан на железе SDIO модуля микроконтроллера Stm32f4, а это – тема второй части статьи.

Урок 33

Часть 1

SPI. Карта SD. FAT

Сегодня мы продолжим нашу любимую тему по интерфейсу SPI. Закончили мы с данной шиной друг к другу контроллеров Atmega8a и ATTtiny2313. А сегодня мы по данному интерфейсу попробуем подключить к микроконтроллеру по данной шине карту памяти SD (Secure Digital) .

Данная карта может подключаться также по интерфейсу SDIO, но так как такой интерфейс не поддерживается аппаратно нашим контроллером, то в рамках данного занятия мы его касаться не будем. Нам интересен именно тип подключения по шине SPI , так как у нас уже есть неплохие накопленные знания по данной теме, а также аппаратная поддержка в контроллере, который мы программируем.

Тем не менее мы посмотрим распиновку ножек карты по обоим типам

Ну, так как нас интересует второй тип, с ним и будем разбираться.

А разбираться тут особо не в чем. Все эти аббревиатуры нам известны. Здесь все стандартные ножки интерфейса SPI и ничего тут лишнего нет.

Теперь вообще про карту. Данная карта нам позволяет хранить данные, тип памяти у неё FLASH, который по сравнению с памятью типа EEPROM также является энергонезависимым, то есть при отключении питания данные никуда не пропадают, а остаются храниться. Также данная память имеет отличия, мы с ними познакомимся в процессе программирования. Одно из главных отличий то, что мы уже как в память EEPROM в данную память не можем записать один байт. Теоретически то конечно можем, но только запишутся туда либо только единички из нашего байта либо только нули в зависимости от типа FLASH — NOR или NAND. То есть прежде чем писать байт, нужно его стереть, а в силу организации данной памяти, стирать мы можем только блоками, вот и писать следовательно также только блоками. Но зато есть величайшее отличие от EEPROM — это цена. Она в разы дешевле, даже порой на порядки за одну хранящуюся единицу инфорамции (за мегабайт, за гигабайт). Поэтому у памяти FLASH как правило всегда гораздо больший объём информации.

Существуют 4 типа SD, но это мы изучим немного позднее.

Подключим данную карту пока в протеусе

Здесь всё просто. На самом деле не совсем так. Нужны ещё резисторы

Данные резисторы нужны для того, чтобы обеспечить соответствующие уровни, так как карта питается от 3,3 вольт. Вообще по технической документации от 2,7 до 3,6 вольт.

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

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

Также у нас подключен дисплей, как и на по расширению функционала библиотеки дисплея.

Вот так у нас всё выглядит в практической схеме

Вот так вот выглядит модуль с держателем

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

Также на модуле установлены все делители для уровней, то есть данный модуль рассчитан именно на подключение к 5-вольтовым устройствам.

А флеш-карту для тестов я откопал на 32 мегабайта, именно мегабайта а не гигабайта

Данная флеш-карта была подарена вместе с каким-то фотоаппаратом и она нам лучше всего подойдёт для наших тестов, по крайней мере мы не будем думать, что тот или иной глюк у нас из-за слишком большого размера памяти на карте.

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

Удалим ненужные строки, в main() у нас останется только во это

int main ( void )

unsigned int i ;

Port_ini ();

LCD_ini (); //инициализируем дисплей

Clearlcd (); //очистим дисплей

Setpos (0,0);

Str_lcd ( "String 1" );

Setpos (2,1);

Str_lcd ( "String 2" );

Setpos (4,2);

Str_lcd ( "String 3" );

Setpos (6,3);

Str_lcd ( "String 4" );

Delay_ms (2000);

// for (i=0;i<=22;i++) {str80_lcd(buffer2+i*20);_delay_ms(1000);}

While (1)

Так как мы посимвольно не будем выводить текст, то можно будет в переменной обойтись типом char

unsigned char i ;

Теперь ещё один нюанс.

Чтобы нам работать с SD-картой в протеусе, нам мало добавить сам держатель с картой, необходимо также в его свойствах прикрепить файл образа флеш-карты.

Создать его не сложно. Одним из способов является создание с помощью программы WinImage.

Мы в ней стандартно создаём новый файл с помощью пункта меню File — > New. Выбираем в диалоге самый последний пункт и жмём "OK"

Для теста в протеусе нам вполне хватит размера 4 мегабайта, поэтому поменяем в следующем диалоге поле с номером секторов, а также выберем формат FAT12/16, потому что с 32-битной файловой системой немного другая специфика работы, и также нажмём "OK"

Вообще мы конечно можем оставить и FAT32, так как мы с файловой системой пока не работает, но в дальнейших частях занятия будет работа с файловой системой и мы будем именно работать с 12/16.

Затем мы сохраняем наш созданный файл с помощью пункта меню File -> Save As. И сохраняем мы его в ту папку, где у нас находится сохранённый проект протеуса. Назовём файл и нажмём "Сохранить"

Также затем нужно будет убедиться, что данный файл у нас получился не с аттрибутом "только для чтения" и после этого мы уже сможем его подключить в протеусе. Надо будет вручную вписать имя файла, так как протеус требует какой-то свой формат и наш файл будет просто не виден

Путь нам никакой не нужен, так как файл у нас находится в папке с проектом. Жмём "ОК".

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

Добавим макроподстановки для ножек порта

#include "main.h"

#define MOSI 3

#define MISO 4

#define SCK 5

#define SS 2

Добавим код для инициализации ножек в функцию инициализации портов

void port_ini ( void )

PORTD =0x00;

DDRD =0xFF;

PORTB |=(1<< SS )|(1<< MISO )|(1<< MOSI );

DDRB |=(1<< SS )|(1<< MOSI )|(1<< SCK );

Мы оставляем на вход ножку MISO, так как по умолчанию все биты в регистре равны нулю, и мы его просто не трогает. Также мы включаем сразу высокий уровень в MOSI и SS, а к MISO подтягиваем резистор.

Напишем функцию передачи байта по шине SPI

void SPI_SendByte ( unsigned char byte )

{

}

Добавим переменную для цикла и сам цикл

void SPI_SendByte ( unsigned char byte )

unsigned char i ;

for ( i =0; i <8; i ++) //движемся по битам байта

{

}

Я думаю, понятно почем мы считаем до 8, так как битов мы передаём именно 8.

Ну и начнём их передавать потихоньку.

Проверим сначала самый левый бит, выделив его из всего байта маскированием, и, если он у нас равен 1, то выставим 1 и на шине MOSI, а если 0 — то не трогаем шину

for ( i =0; i <8; i ++) //движемся по битам байта

В большинстве проектов с Ардуино необходимо устанавливать вспомогательное хранилище для медиафайлов, будь это видео или аудио. Если возникает необходимость хранить и обрабатывать информацию, а стоковой флеш-памяти плат вам не хватает, то есть несколько решений.

Можно докупить специальную плату, обеспечивающую быстрый доступ к данным, но и стоящую не малых денег. Если же у вас нет желания тратиться, то расширить стоковую память платы можно и с arduino card SD, дабы не было проблем с записью и стиранием стоковых утилит с чипов. Однако далеко не все новички знают, как правильно подключать флешку к чипу и что для этого нужно. Давайте разберёмся во всех нюансах и узнаем, какие подводные камни такого решения вас поджидают.

Что необходимо знать при подключении SD card к Arduino

Прежде чем подсоединять что-либо, следует изучить нюансы, которые будут подстерегать вас на каждом шагу. Первое, с чем вам придётся столкнуться, это вольтаж карт памяти, ведь они рассчитаны на 3.3 В, что является стандартом.

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

Чтобы не сжечь всю плату, достаточно прикупить преобразователи переменного и постоянного тока, лучше всего подойдут приборы под HEF4050 и 74FHC125 базу.

1. SPI. Универсален, и подойдёт для любого микроконтроллера, а подключение требует всего четыре пина.
2. SDIO. Хороший выбор, если необходима высокая скорость передачи информации, но с arduino microsd реализуется крайне тяжело.

Учитывайте и формат карты, он не влияет ровным счётом ни на что, кроме размера вашей конечной поделки. Если необходимо серьёзно урезать габариты, то хорошим выбором станет microSD.

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

Большинство устройств на сегодняшний день пользуются форматами NTFS, FAT32 и FAT16. Но чем сложнее система, тем больше памяти для работы arduino SD придётся выделить, что чревато последствиями в виде подлагиваний и плохой скорости отклика.

Схема подключения SD card к Arduino

Предварительно отформатировав карту памяти, приступайте к её подключению.

Платы расширений облегчат задачу, ведь они позволят урегулировать напряжение до необходимых нам 3.3 В, а контроллеры уровня преобразуют питание логики в подходящие для флешки.

Плата расширений потребуется под микроконтроллеры до 5 В, учитывайте это при её выборе. Главное достоинство Ардуино – простота, и подключение вспомогательных модулей не стало исключением. Лучшим выбором станет именно структура запуска через hardware SPI пины, дабы не усложнять новичкам жизнь. Нам потребуются 13, 12 и 11 цифровые пины, а также четвёртые, чтобы наладить «chip\slave select» цепь. Под это, зачастую, берётся 10 пин, но если вы знаете, что делаете, можете выбрать и более подходящий.

Обратите внимание на то, что в зависимости от форм-фактора и типа платы Ардуино, точки подключения могут варьироваться. Например, для меги необходимо соединить цепь с 50, 51, 52 и 53 слотом.

В последующие разы вы можете поэкспериментировать с последними пинами на обеих картах, но поначалу лучше выбрать именно те, что указаны выше. Так вы сможете отработать код, избавившись от нежелательных поломок и осечек, что значительно упростит задачу в будущем. Оставшиеся 5 В и GND подсоединяйте к соответствующим портам, здесь никаких особых инструкций нет.

Еще один вариант наглядной схемы:

В конце процедуры необходимо замкнуть CD в заземление, так система не сможет инициализировать карту памяти. Но, в случае необходимости, всегда можно применить резисторы в 10 кОм и вспомогательные порты, однако мы не будем останавливаться на этом пине, так как сейчас он нам не нужен.

Загрузка библиотек и запуск SD card на Arduino

Чтобы подсоединиться к SD карте и свободно передавать на неё данные, потребуется написать немало кода, однако здесь нам поможет встроенная библиотека SD.

Библиотеку по работе с картами памяти можно найти на официальном сайте производителя микроконтроллера: https://www.arduino.cc/en/Reference/SD

Открыв подменю «образцов», найдите заготовку «cardinfo», именно её мы не будем использовать в качестве прописной функции при загрузке информации. Скетч пригодится лишь для проверки, опознаётся ли дополнительная память на устройстве. Проверяйте chipSelect, учитывая, что подключение идёт через 10 пин.

#include const int chipSelect = 4; void setup() { Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. } Serial.print(“Initializing SD card…”); pinMode(10, OUTPUT); //iniot SD card if (!SD.begin(chipSelect)) { Serial.println(“Card failed, or not present”); return; } Serial.println(“card initialized.”); } void loop() { String dataString = “”; // read three sensors and append to the string for (int analogPin = 0; analogPin < 3; analogPin++) { int sensor = analogRead(analogPin); dataString += String(sensor); if (analogPin < 2) { dataString += “,”; } } // open the file. File dataFile = SD.open(“data.txt”, FILE_WRITE); // if the file is available, write to it: if (dataFile) { dataFile.println(dataString); dataFile.close(); } // if the file isn’t open else { Serial.println(“error opening data.txt”); } }

Если всё прошло удачно, то на экран выведется информация о типе файловой системы и объёме вашей SD-карты. Если же производитель подсунул вам не лучший продукт, могут возникнуть ошибки. Здесь проще купить новую флешку, чем бороться с ошибками файловой системы, изначально заложенными в девайс.

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

Заключение

SD-карта – необходимый элемент любой системы, в которой вы собираетесь использовать медиафайлы. Это будет хорошим решением как для приборов под «умный дом», так и для самодельных плееров. Однако не забывайте, что качество конечного продукта приравнивается к качеству его худшего компонента, и не стоит экономить на SD-картах.

Обновлено18.12.15. Всем привет. Сегодня мы продолжим разработку контроллера сбора данных, а именно сохранение информации непосредственно на карту SD . В прошлой статье была налажена работа термометра. Теперь эту информацию по времени, при подключении в дальнейшем часов реального времени(статья №29 ), мы будем заносить на карту памяти, получив своеобразную базу данных. А также в дальнейшем перенесем эту информацию на ПК (статья №42), в базу данных под управлением MySQL (статья №48), через небольшое приложение на Java (статья №44). Но сперва разберемся что такое SD – карта и как с ней работать. Начнем с краткого обзора истории. Предшественником Flash-памяти является одна из энергонезависимых видов памяти , типа , которая зарекомендовала себя и используется в микроконтроллерах. Flash-память возникла в ходе потребности увеличения емкости и изменения технологии стирания (в случае с памятью EPROM). Поэтому в 1984 году инженер компании Toshiba Фудзио Масуокой изменил технологию стирания, что в свою очередь решил недостатки предшественников Flash-памяти. Хочется добавить, что далее данная память начала делится по внутреннему устройству соединения ячеек в массив и алгоритмами чтения-записи – это NOR- и NAND-технология. А также различие по количеству хранимых битов в элементарной ячейке. Это SLC-устройства (single-levelcell), т.е. однобитовые ячейки различают только два уровня заряда на плавающем затворе. И MLC- устройства (multi–levelcell) — многобитовые ячейки различают больше уровней заряда. Второй тип приборов дешевле и более ёмкий, чем SLC-приборы, однако с большим временем доступа и меньшим максимальным количеством перезаписей (около 10 тыс. и 100 тыс. — SLC).

Вообще устройства технологии NOR — это двумерная матрица проводников, что позволяет получить более быстрый доступ к каждой ячейки памяти, но при этом площадь ячейки считается большой, поэтому данная технология используется для памяти программ микропроцессоров и для хранения небольших вспомогательных данных, сюда же можно включить и специализированные микросхемы начальной загрузки компьютеров (POST и BIOS), процессоров ЦОС и программируемой логики.Типовые объёмы - от 1 кбайта до 1 Мбайта.
Второй тип устройства — NAND-технология — трехмерный массив имеет малую площадь ячейки, но относительно длительный доступ сразу к большой группе ячеек. Используется для больших объемов памяти. Вот с этой памятью мы и будем работать.
Но перед этим хочется сказать об недостатке. Как и у всего есть свой срок использования, так и у памяти есть ресурс износа. Производители в гонке за емкостью и лидерством на рынке, всегда упускают такой показатель как качество, т.к. он не совместим с высокой ценой. Так возвращаясь к износу хочется отметить что срок хранения информации при использовании MLC-устройств составляет примерно 5 лет, что связанно с накоплением необратимых изменений при изменении заряда. Если брать память NAND c SLC-устройства, то они являются более качественными, и соответственно дорогими. Стоит отметить что срок хранения информации очень во многом зависит от температуры, гамма-радиации и частиц высокой энергии.
Выше было сказано, что недостаток карты это ограниченное количество циклов перезаписей. Когда мы будем использовать файловую систему для управления файлами, то должны знать что такие системы записывают данные в одно место, естественно расходую ресурс выделенной области в итоге вывода ее из строя и соответственно уменьшая емкость. Для этого типа памяти используется NAND-контроллер, который должен равномерно распределять износ. Однако для удешевления устройств контроллер может и не использоваться, а его работу будет выполнять программный NAND-драйвер в операционной системе. После этого открытия, многие компании занялись разработкой своих стандартов портативных карт.

Далее перейдем непосредственно к рассмотрению карты.
Secure Digital Memory Card (SD) - формат карт памяти, разработанный для использования в основном в портативных устройствах. Чтобы разобраться в ее работе мы будем использовать спецификацию, которая описывает данный стандарт и называется SD Specifications ver3.01.
Первое что нам необходимо, так это разобраться как работать с этой картой, как подключить и прочее. Сначала выберем карту. Для экспериментов я взял microSD емкостью 2Гб, стандарт емкости SDSC. Шина карты может работать по двум протоколам SD и SPI. Хочется отметить что данная карта это своего рода модификация карты MMC, где (в карте SD) основное внимание было уделено системе безопасности. Поэтому алгоритм работы по протоколу SPI такой же, ну и конечно же они односторонне совместимы. Т.е мы можем в слот SD карты вставить MMC, но не наоборот.

На рисунке ниже представлена схема подключения карты SD по протоколу SPI .
Данный интерфейс позволяет обмениваться данными на высокой скорости, задействовав при этом минимальное количество выводов микроконтроллера, которые оснащены модулем SPI. С этого момента начнем использовать спецификацию. Первое что нас интересует- выбор режима. Разберемся в тонкостях на рис. ниже из раздела 6.4.1.1 представлена диаграмма напряжения питания и последовательность посылки команды. Здесь четко видно что после включения карты необходимо выждать несколько миллисекунд (1мс + от 0.1 до 35 мс(нарастание)) на стабилизацию. В течении этого времени на CS, MOSI линии должна быть подана 1. Далее происходит задержка инициализации максимум 1 мс, при подаче на вход CLK 74 импульсов (тактов), после чего должна идти команда CMD0. Перейдем к главе 7 где четко описана последовательность действий.

Диаграмма напряжения питания

SPI протокол выбирается после включения питания и подачи команды сброса CMD0. Сама по себе карта SD работает в режиме SD. Вход в режим осуществляется если сигнал SC при подаче команды CMD0 будет 0. При переходе в режим SPI карта ответит форматом R1 (рисунок ниже). Формат ответа представляет собой байт (зависит от команды см. таблицу 7.3 в спецификации) с флагами определяющие состояние карты. Правильные ответы для нас это будет 1 (в случае команды CMD0) и 0 во всех других случаях.
1-й бит – режим ожидания
2-й – ошибка стирания
3- й – неизвестная команда
4-й – ошибка команды
5-й – ошибка в последовательности стирания
6-й –ошибка адреса
7-й – ошибка аргуента

В процессе сброса, карта должна ответить 0×01, что соответствует первому биту.

В спецификации есть четкая последовательность инициализации для SPI. Для чего используется команда CMD8 для проверки рабочего состояния карты, где происходит довольно не простой алгоритм проверки. Далее команда CMD58 для определения типа карты SDSD или SDHC и SDXC. А также команда CMD41 для запуска и проверки инициализации. Довольно не простой процесс инициализации с проверками, но я думаю что для простой записи данных можно использовать более упрощенный процесс. В разделе 7.2.7. говорится, что в режиме ожидания единственно допустимые команды для карточки CMD41, CMD8, CMD58, CMD59 , а также для карт (толстых 2.1мм) памяти SD CMD1, который идентичен команде CMD41. В стандарте эта команда считается запрещенной для инициализации, и используется исключительно для различия карт 1,4мм и 2,1мм.
Пойдем более простым путем и используем команду CMD1. Все выше описанное отобразим в коде в функции инициализации, но перед этим рассмотрим формат команды. Каждая команда или блок данных состоят из восьми битных байтов, которые выравниваются по сигналу CLK. Т.е. каждая команда выравнивается по границе 8 тактов. Сообщения SPI состоят из команды, ответа и данных. Вся связь контролируется микроконтроллером. Все команды имеют длину 6 байт. Передача начинается с первого левого бита.

На рисунке ниже представлен формат команды.

Старт бит – с 0 начинается любая команда. Передаваемый бит – тоже всегда равна 1.

Индекс – непосредственно передаваемая команда.

Аргумент- для каждой команды аргумент указан в таблице спецификации.

CRC – проверка избыточности кода. По умолчанию в режиме SPI она отключена. Поэтому мы ее используем только для команды CMD0, которая посылается до входа в режим и имеет значение CRC 0×95.

Стоп бит - конец передаваемой команды.

Что ж приступим к написанию кода.

Начнем с необходимых 2-х функций: передача и прием байта.

1. Передача байта карте.

void trans_byte_sd (unsigned char data)// передаем массив битов

{

for (unsigned char i=0;i<8;i++) //Перебираем байт

{

if ((data&0×80)==0×00) //Если старший бит = 0

PORTB&=~_BV (PB3); //Выставить MOSI (DI) -0

else

PORTB|=_BV (PB3); //1

data=data<<1; // сдвиг влево

PORTB|=_BV (PB5); //Импульс или строб

asm («nop»); //Пауза в 1 такт

PORTB&=~_BV (PB5);

}

}

2. Прием байта микроконтроллером.

unsigned char receive_byte_sd (void) // Возвращаем ответ

{

unsigned char data = 0; // инициализируем массив

for (unsigned char i=0; i<8; i++)

{

PORTB|=_BV (PB5); //Фронт импульса

data=data<<1; // Сдвигаем влево

if ((PINB&_BV (PB4))!=0×00) // Если состояние пина 1

data=data|0×01;

PORTB&=~_BV (PB5); //0

asm («nop»);

}

return data; // Возвращаем ответ

}

Из выше описанных, основных, функций начнем писать дальнейший код. Далее пропишем функцию передачи команды. Здесь хочется обратить внимания, на то, что Вы можете передавать все 5-ть аргументов: непосредственно саму команду и 4-аргумента отвечающих за адрес ячеек памяти самой карты. Что касается 6-го байта, то CRC при входе в режим SPI отключается (по умолчанию) и значение постоянно равно 0×95, которое используется только для CMD0, когда карта не в режиме. Включить проверку кода можно командой CMD58. Для экспериментов я передаю два аргумента.

3.Передача команды.

unsigned char comand_sd (char CMD, char arg) /*передаем команду и адрес к которому обращаемся и возвращаем ответ*/

{

long int i=0; // переменная для счетчика

unsigned char r1; // ответ карты

trans_byte_sd (CMD); // команда

trans_byte_sd (0×00);

trans_byte_sd (0×00);

trans_byte_sd (arg); // передача адреса

trans_byte_sd (0×00);

trans_byte_sd (0×95); // Передача CRC

/* После передачи команды ждем ответа формата R1.Каждой команде соответствует свой ответ*/

/* Цикл для ожидания получения ответа за определенное время*/

do

{

r1=receive_byte_sd ();

i++;

}while (((r1&0×80)!=0×00)&&(i<0xffff)); /* Как только старший бит байта не равен 0 и i не превышает 65 535 тактов*/

return r1; // Возвращаем ответ

}

4. И нициализация карты.

Теперь мы можем прописать инициализацию карты. Кратко программа описывается следующим образом: первое что необходимо, так это перевести карту в режим SPI. При подаче питания карта устанавливается в режим SD. Для выбора режима SPI на вход CS подается логический 0, в это же время подается команда сброса CMD0 и инициализации CMD1 на вход карты MOSI. Обратим внимание что команда начинается от шестнадцатеричного 0×40, к которому необходимо прибавить номер команды CMD в шестнадцатеричном виде.

unsigned char spi_card_init (void) // функция возвращает ответ

{

unsigned char r1; // переменная для приема ответа

long int i =0; // переменная для счетчика

_delay_ms (10); // небольшая задержка для стабилизации напряж.

PORTB|=_BV (PB1); //CS, устанавливаем 1, при подаче тактов

PORTB|=_BV (PB3); //линия подачи команд — 1 MOSI (DI)

for (unsigned char i=0; i<80;i++) // посылаем более 74 импульса

{

PORTB|=_BV (PB5); //CLK — 1

asm («nop»); //задержка в один такт

PORTB&=~_BV (PB5); //CLK — 0

}

PORTB&=~_BV (PB1); /* условие для входа в режим SPI линия CS должна быть равна 0 */

r1=comand_sd (0×40,0×00); // CMD0=0×40, адрес без разницы

if (r1!=0×01) return 4; //коды ошибок можете ставить любые

trans_byte_sd (0xff); /* посылаем строб, своеобразная пауза перед приемом ответа */

do // цикл приема ответа от карты

{

r1=comand_sd (0×41,0×00); /* посылаем команду инициализации */

trans_byte_sd (0xff); // пауза

i++; // счетчик

}while ((r1!= 0)&&(i<65535)); /*пока не получен ответ 0 и количество циклов не превышает 0xffff */

if (i>=0xffff) return 5; /* возвращаем ошибку если превысило время опроса */

return 0;//Возвращаем 0 в случае успешной инициализации

}

Следующий важный момент, в спецификации пишется, что информация передается блоками, по 512 бит, причем если карта SDSC как в нашем случае, то длину блока можн0 установить от 1 до 512 бит командой CMD16. По умолчанию 512 бит. Далее опишем две функции приема и передачи блоков. В спецификации даны блок-диаграммы, опираясь на которые мы напишем код.

Передача блока информации на карту.

За передачу ЕДИНСТВЕННОГО блока отвечает команда CMD24. После подачи команды, ждем ответ После чего следует стартовый байт, который подготавливает контроллер карты к приему информации, по окончанию карта отвечает байтом о состоянии передачи, который описан в главе 7.3.3.1. Т.е. правильный ответ должен быть= 5. Также ждем освобождения шины для дальнейшей передачи.

Байт отзыва о состоянии передачи.

В разделе 7.3.3.2 описывается формат передаваемого блока

unsigned char receive_block_sd (char* block, char arg) /* передаем массив для записи данных и адрес к которому обращаемся*/

{

long int i = 0;

unsigned char r1;

r1=comand_sd (0X51,arg); //CMD17

if (r1!=0×00) return 5; //Выйти, если ответ не 0×00

trans_byte_sd (0xff);

do //Ждем начала пакета данных

{

r1=receive_byte_sd ();

i++;

}while ((r1!= 0xfe)&&(i<65535));

if (i>=0xffff) return 5;

for (int i=0;i<512;i=i+1) //прием данных

block[i] = receive_byte_sd ();

receive_byte_sd (); //байт CRC

receive_byte_sd (); //байт CRC

return 0;

}

Перед тем как использовать программу, рассмотрим аппаратную часть. Как мы говорили, выше, что карта совместима с микроконтроллером в режиме SPI. Отметим следующие нюансы работы с картой:
1. Сопряжение логических уровней, необходимо при разном напряжении питания SD-карты и микроконтроллера AVR. Можно использовать резистивный делитель напряжения, который является линейным,т.е. напряжение на выходе зависит от напряжения на входе. А можно параллельный параметрический стабилизатор напряжения на стабилитроне, тоже что и первый вариант,только в нижнем плече используется стабилитрон, который является нелинейным делителем, и следит за опорным напряжением за счет своих свойств при повышении входного напряжения уменьшать внутреннее сопротивление,и наоборот.
Я использовал второй вариант. В схеме ниже на сигнальной линии сопротивления являются балластными(токоограничители), на вход делителя поступает напряжение 4,5 – 5 В, а выходное снимается с нижнего плеча делителя. Токоограничители необходимы для защиты карты и другой периферии при сбоях микроконтроллера. При хорошо отлаженном устройстве в них нет необходимости.

Заметьте, что линия MISO не нуждается в согласовании, т.к. работает только в одну сторону от карты к микроконтроллеру.
2. Второй момент, я не использую проверку наличия карты и защиты записи. У кого то есть эти контакты в слотах, у кого то нет.
3. Последний момент- питание. Либо ВЫ питаете 3.3 вольта всю схему, включительно с микроконтроллером, либо ставите делитель на вход схемы, не очень надежно. Либо стабилизатор 3.3 вольта, как я и сделал на микросхеме LP2980 . Важным моментом здесь является электролитический (танталовый) конденсатор, который защищает микроконтроллер от сброса при просадках напряжения.
Ниже представлена программа и результат. Как всегда, я стараюсь использовать одну программу постоянно ее изменяя. Данный код взят из статьи №5 (семисегментный индикатор).

#include

#include

#include

#include

//макросы для работы с индикатором

#define a 128

#define b 32

#define c 8

#define d 2

#define e 1

#define f 64

#define g 16

#define dp 4

// Переменные

char block ={}; //буфер записи/чтения данных на карту

short unsigned int j, k = 0; //в макросе прерывания

unsigned char Slot; // Массив чисел для отображения на индикаторе

//Объявляем функции

void trans_byte_sd (unsigned char data); // функция передачи байта

unsigned char receive_byte_sd (void); //Функция приема байта

unsigned char comand_sd (char,char); // функция передачи команды

unsigned char spi_card_init (void); //Функция инициализации карты памяти

unsigned char receive_block_sd (char* block, char arg); //Функция приема блока

unsigned char trans_block_sd (char* block, char arg); //Функция передачи блока

// Инициализации индикатора

void Slot_init ()

{…………………….};

// Переменные для отображения цифр

char Elem1, Elem2, Elem3;

// Вывод на индикатор

void Display (float i)

{ …………………………... }

int main (void) //начало основой программы

{

DDRB = 0x2A; //0010 1010 – PB1, PB3, PB5

DDRD = 0xff; //все выводы порта — выходы

PORTD = 0×00; //устанавливаем 0

PORTB |= 0хdb; //1101 1011 (PB0,1,3,4,6,7)

Slot_init ();

sei (); // либо SREG |= (1 << 7); разрешить общее прерывание

//инициализация таймера Т0

TIMSK = (1</*Флаг разрешения по переполнению таймера счетчика Т0*/

TCCR0 = (0< //1000000/8 = 125000

unsigned char temp;

int i;

for (i=0;i<512;i=i+1)

block[i]= i; //записываем в буфер

spi_card_init (); //инициализация

trans_block_sd (block,0×04); //отправляем данные карте

//Обнуляем буфер

for (int i=0;i<512;i=i+1)

block[i]=0;

// Считаем данные с карты

receive_block_sd (block, 0×04); ; //Функция приема байта

for (int i=0;i<512;i=i+1)

{

char otv;

otv = block[i];

Display (otv);

_delay_ms (100);

}

//Запишем по адресу в память 0

for (int i=0;i<512;i=i+1)

block[i]=0;

unsigned char comand_sd (char,0×00); //функция передачи команды

trans_block_sd (block,0×04); //отправляем данные карте

}

//Вывод на индикатор

ISR (TIMER0_OVF_vect)

{ ……………. }

Важный момент — это таймауты. Важно следить за временем чтения записи и стирании карты, так как может зависнуть микроконтроллер в режиме ожидания ответа карты. В спецификации четко описаны таймауты карты. Простой карты длится 5 мс, после чего переходит в энергосберегающий режим, в котором допустимы следующие команды CMD0, CMD1, CMD41 и CMD58. Поэтому при превышении лимита простоя передаем CMD1, ответ и дальше работаем с картой.
Внизу представлено два скриншота из программы WinHex , с помощью которой мы можем посмотреть содержимое ячеек памяти. Программа работает следующим образом: Записываем данные в буфер, оправляем карте, обнуляем буфер, считываем данные с карты в буфер и выводим на дисплей тем самым убеждаемся в передачи данных карте. Смотрим содержимое карты, обнуляем буфер, записываем 0 в карту и опять открываем содержимое карты, тем самым убеждаемся в работоспособности программы и схемы. Как всегда незабываем о мелочах, таких как не допайка, не большие трещенки в дорожках и др., что может забрать львинную долю времени. Поэтому если есть под руками осциллограф, то непременно используйте его для наладки. В статье №24 я привел небольшой пример диагностики карты на всех этапах ее работы. мы познакомимся с датчиком влажности и температуры DHT11. После чего начнем записывать данные (температуру и влажность) в текстовый файл, своеобразную базу данных. Пока на этом все. Всем пока.

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

В проект изначально использовалась карта памяти microSD объемом 1 ГБайт. Микроконтроллер - ATmega8 или ATmega32, работающий на частоте 8 МГц от внутреннего RC осциллятора. Кроме того, для подключения макета к персональному компьютеру для мониторинга данных использовался интерфейс RS-232. Для преобразования логических уровней интерфейса используется микросхема MAX232 . Для питания схемы необходим стабилизированный источник питания 3.3 В (микросхема MAX232 рассчитана на напряжение питания 5 В, однако, как показала практика, сохраняет работоспособность при 3.3 В). Подключение карты памяти по 7-проводной схеме, согласно распиновке (см. рис).

Принципиальная схема для микроконтроллера ATmega8.

Подтягивающие резисторы R1, R2 номиналом 51 кОм интерфейса SPI придают лучшую стабильность при работе с различными картами. Стабилитроны D1, D2 предназначены для защиты карты памяти при работе внутрисхемного программатора (ISP). Выводы микросхемы MAX232 VCC и GND на схемах не указаны, но их необходимо подкличить к соответствующим точкам схемы.

Принципиальная схема для микроконтроллера ATmega32

Принципиальная схема для микроконтроллера ATmega32 (добавлены часы реального времени на микросхеме DS1307)

Как вы заметили, питание последнего варианта устройства осуществляется от источника 12 В, а на плате установлены два регулятора напряжения 5.0 В (LM7805) и 3.3 В (LM1117-3.3). Для питания интерфейса SD карты используется 3.3 В, вся остальная часть схемы питается от источника 5.0 В. Микросхема часов реального времени DS1307 в стандартном включении и подключена к интерфейсу I2C микроконтроллера.

Сперва был изучен «сырой» формат передачи данных, на примере операций чтения любого блока данных, чтения и записи нескольких блоков данных, стирания нескольких блоков, записи данных в любой блок памяти SD. Устройство, собранное на макетной плате, подключалось к компьютеру по интерфейсу RS-232. Для отображения прочитанных данных с карты памяти, а также для ввода и записи данных на карту используется программа HyperTerminal (или аналогичная) на компьютере.

После удачной реализации обмена данными без спецификации, карта памяти была отформатирована (FAT32) в операционной системе Windows XP, затем на карту были записаны несколько текстовых файлов, директорий и другие типы файлов (в корневую директорию карты). После этого были написаны подпрограммы и функции по работе с файловой системой FAT32 для чтения файлов, для получения списка файлов на карте памяти (с использованием HiperTerminal), для получения информации о полном и свободном объеме памяти.

Вид окна программы HiperTerminal с функциями по работе с картой памяти SD:

Пользователю предлагаются свыше 10 опций по работе с картой памяти (для варианта с часами).

Опции 0 - 4 - это низкоуровневые функции. Gосле использования опций 0 - 3 Вам необходимо переформатировать карту перед использованием FAT32 подпрограмм.
Опции 5 - 9 - относятся к файловой системе FAT32. На данный момент поддерживаются только короткие имена файлов (8 Байт - имя файла, 3 Байта - расширение файла). Если будут записаны файлы с длинными именами, то они будут отображены в терминальной программе в коротком формате. Для тестирования этих опций не забудьте отформатировать карту в файловой системе FAT32, записать несколько директорий и текстовых файлов.

Описание опций:

0 - Erase Blocks - стирание выбранного количества блоков начиная с указанного.
1 - Write Single Block - запись данных в блок с определенным адресом. Данные вводятся с клавиатуры в программе Hiperterminal;
2 - Read Single Block - чтение данных с блока с определенным адресом. Прочитанные данные отображаются в окне терминальной программы;
3 - Writing multiple blocks - запись нескольких блоков, начиная с определенного адреса;
4 - Reading multiple blocks - чтение нескольких блоков, начиная с определенного адреса.

Примечание. Здесь функции работы с несколькими блоками (опции 3 и 4) отключены из-за нехватки памяти микроконтроллера ATmega8, поскольку эти функции не нужны для тестирования файловой системы FAT32. Для включения этих опций необходимо удалить макрос в файле SD_routines.h (#define FAT_TESTING_ONLY). И, если Вы используете ATmega8, на время тестирования опций 3 и 4 библиотека FAT32 может быть удалена с целью освобождения памяти микроконтроллера.

5 - Get File List - отображает список доступных директорий и файлов с занимаемым ими объемом памяти (в корневой директории карты);
6 - Read File - чтение указанного файла и отображение содержимого в окне терминальной программы;
7 - Create File - создать/добавить файл с указанным именем;
8 - Delete File - удалить все файлы файл с указанным именем;
9 - Read SD Memory Capacity - информация о полном и свободном объеме карты памяти (используется FSinfo сектор SD карты).

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

Для версии с часами реального времени (DS1307) на микроконтроллере ATmega32 свойства создаваемых или обновляемых файлов привязываются к дате и времени (дата создания/изменения), эти свойства прописываются в файловой таблице и могут быть проверены с помощью компьютера, а также часы могут быть полезны при сборе данных. В меню опций в терминальной программе добавлены три опции.