Скачал исходник.
Вывалились ошибки:
stm32 nok1100 disp.axf: Error: L6218E: Undefined symbol USART_Cmd (referred from main.o).
stm32 nok1100 disp.axf: Error: L6218E: Undefined symbol USART_GetFlagStatus (referred from main.o).
stm32 nok1100 disp.axf: Error: L6218E: Undefined symbol USART_Init (referred from main.o).
stm32 nok1100 disp.axf: Error: L6218E: Undefined symbol USART_ReceiveData (referred from main.o).
stm32 nok1100 disp.axf: Error: L6218E: Undefined symbol USART_SendData (referred from main.o).
Добавил в проект библиотеку для работы с USART — скомпилилось (неплохо было бы все же об этом упомянуть в статье, а?), но карта не инициализируется. Пробовал менять местами выводы MISO и MOSI — результат нулевой…
В проекте использую Standard Peripheral Library + заметно упоминание в тексте и коде об UART’е, думал это само собой влечет использование USART библиотеки. Используемые библиотеки из SPL перечислил. Чуть позже думаю выложить проект целиком.
Есть ли диалог по UART? Что за карта? Она живая? Пробовали ли другие карты?
Ситуация — человек, ни разу ДО того не сталкивавшийся с STM32, находит в интернете Ваши статьи, начинает их читать. Ставит необходимый софт и читает Ваши статьи, последовательно одну за другой, попутно компилируя примеры и проверяя работоспособность на плате STM32VL Discovery (как это у Вас в первой статье сказано). В первом примере все разжевано и разложено по полочкам — какие файлы библиотек куда положить, как структуру проекта оформить, какие опции в свойствах проекта включить/выключить. Все понятно, все прекрасно. Статья для новичков. В статье про подключение SD-карт — полная противоположность, как в той песне — «догадайся, мол, сама…». Мало того — на схеме подключения карты указаны пины процессора, хотя по идее должны быть указаны пины разъемов платы STM32VL Discovery (коли уж повествование началось на ее базе). Думаю, что в статьях должна прослеживаться некая преемственность, раз уж начали опираться с первой статьи на STM32VL Discovery — на ее базе и остальное повествование продолжайте. Так будет намного проще для читающих Ваши статьи.
По УАРТу данные в терминалку падают, в обратную не пробовал.
В процессе написания ответа взял другую карту — не инитится. Поменял местами выводы MISO и MOSI на разъеме дискавери — заработало. Так что в схемке ошибочка наблюдается. Кстати, вот тут http://mycontroller.ru/stm32-sd-card-podklyuchenie/ схема подключения правильная. Подключение карты к плате STM32VL Discovery получается таким: карта пин 1 — PA4, карта пин 2 — PA7, карта пин 5 — PA5, карта пин 7 — PA6. Заработала одна старая карточка (16 Мб) и новая (2 Гб). Старая карточка 8 Мб (раритет, однако 😉) от видеокамеры JVC инициализироваться не захотела.
Пожелание: если не затруднит, описывайте подробнее добавления/изменения в проекте и т.п.. Опытным товарищам это можно и не читать, а неопытным будет ясно и не будут возникать всякие глупые вопросы. 🙂
ЗЫ. Блоки данных пишутся/читаются на/с карты. Спасибо за статью!
Там идет специальная обучающая серия и она пронумерована, вот в ней пытаюсь максимально разжевать. Обычные же статьи могу быть, как обзорные/поверхностные, т.е. самое основное, т.к. материала очень много и всего не упомянуть, а могут быть так же развернутыми. К примеру: эта статья появилась раньше, чем рассказал об UART’е и SPI, не откладывать же материал на потом? да и когда будет этот потом и будет ли вообще?
За замечание насчёт перепутанных выводов спасибо, как выйду на работу с больничного перепроверю (SD карты у меня там остались).
Ответ на пожелание — постараюсь.
В схеме ошибка подтвердилась, вечером информацию обновлю. Спасибо, что заметили.
Спасибо, все отлично работает на F103RB, кингстон сдхц на 4гб скушалась без приреканий. Правда я не сразу заметил, что у меня на плате PA4 — это слейв-селект не для карточки, отладка слегка затянулась))
Вы написали что: SD_init() – инициализация SPI и карты памяти
в случае неудачи возвращает 0.
Разве не наоборот, в случае успешной инициализации, возвращается ноль, иначе - единица?
Ошибся, исправим. Спасибо, что заметили.
А вы пробовали SDHC карту? Она инициализируется но не получается не прочитать не записать, плюс не понятно как ее адресовывать,что то в интернете толком ни чего не нашел
Пробовал SDHC Qumo 8GB — чтение успешно, запись не помню проверял ли. Другие карты не пробовал.
странно, у меня кингстон SDHC на 2гб не пишется и не читается
Ещё может от карточки зависеть, т.е. повезет — не повезет.
Скажите, пожалуйста, а можно ли как-то прочитать данные, записанные на sd карту (без файловой системы), с компьютера. Я имею ввиду использование каких-либо программ для восстановления данных с флешек и пр? Дело в том, что с FatFS постоянно возникают проблемы (с низкоуровневыми функциями, скорее всего). Или чинить их или искать программы.
Такого ПО не искал — на примете нечего нет.
Там в инструкциях к библиотеки есть описание и замечания по её критическим участкам, например, на время каких операций лучше запретить прерывания и прекращение каких приведет к повреждению данных.
Было бы куда интереснее найти/сочинить универсальный драйвер для картридеров которые есть сейчас в любом буке для использования слотов CD/MMC вкачестве универсального SPI интерфейса / программатора, естественно с эмуляцией СОМ порта потому как практически весь софт программаторов работает через СОМ/LPT и практически все железки теперь имеют биос/загрузчики через SPI или общается через него, вот тогда бы вам народ памятник поставил (хотя бы виртуальный).
Удивляюсь почему до сих пор никто такого драйвера не написал, не думаю что это невозможно или архи сложно — «хардвару обходим сфтварой а софтвару — хардварой» , однако сколько не рыл в инете такого драйвера не нашел, а самому писать — слабо.
Хорошая статья! Можно увидеть весь проект с описанной инициализацией карточки?
А к статье разве он не прикреплен?
Хм… думал все основные файлы проекта выложил, вечерком постараюсь добавить.
На счёт сайта — да, печаль, хороший был ресурс, но уже, как с год помер и полноценной копии материалов с того ресурса нигде найти не могу.
Тот сайт, по библиотеке FatFS, на самом деле занимался переводом аналогичного ресурса, библиотеку можете скачать от туда — FatFs — Generic FAT File System Module , плюс там есть ещё её обновление от 14 ноября текущего года.
Все основные файлы проекта выложены, остаётся только standard peripheral library поставить.
Добрый вечер!
Интересует вопрос создания и записи данных в текстовый файл на флешке с периодичностью в 100кГц.
Есть камера DCR-DVD203E ПИШИТ на мини сд диск …задача убрать сд и установить блок записываюший на флеш карту 32-64 ГБ.. ЕСТЬ ВНАЛИЧИИ НО КАК СДЕЛАТЬ???? ВОПРОС— СМОГЛИ БЫ СДЕЛАТЬ И ЦЕНА ВОПРОСА
По обоим вопросам не чем помочь не смогу.
«Если вы обнаружили, что обратная связь не работает, просьба сообщить об этом через комментарии».
Сообщаю 😉
Сайт работает исправно, всё что приходит вижу. Это меня завалило работой по всем фронтам. И поэтому уже с пару недель на сайт не отвечаю. Скоро одни дела завершу и на недели со временем должно будет быть чуть посвободнее, отвечу на всё, что накопилось.
1. В идеале лучше использовать простые карты памяти, не HD. Но статистики по картам у меня нет.
2. Перепроверьте распиновку карты памяти по другим ресурсам в интернете, кто-то когда то замечал у меня ошибку, не помню подтвердил её и исправил или нет.
Понятно, извиняюсь за нетерпение 🙂
Спасибо за ответ, если найду ошибку — напишу в чем было дело.
Хм, проблема оказалась в интересном месте. На одном форуме нашел статью человека, у которого была схожая проблема. На ножках, задействованных в SPI1, также висит JTAG. Так вот оказалось, что он включается автоматически после Reset, несмотря на то, что я нигде его не включаю как альтернативную функцию. В статье предлагалось решение этой проблемы (), я же просто использовал другой SPI. После чего стало возможным отослать 74 синхроимпульса.
P.S. Правда дальше все равно не заработало 🙂 После отсылки запроса на программный сброс(с пустым аргументом) ответа на команду не приходит 🙁 Будем искать еще ошибки.
И это снова я. И опять ошибка возникала из-за неправильной работы ножки. В качестве ножки SlaveSelect я выбрал ту, которая указана в ДШ как NSS для SPI2. Настроил ее на ее на управление программно. Сброс/установку ножки осуществлял с помощью функции SPI_NSSInternalSoftwareConfig() (так написано в библиотеке SPL). Так вот ножка не изменяла своего значения! Более того, когда я перестал использовать эту функцию и стал напрямую менять бит через регистр порта BSRR, то ножка все равно постоянно была выставлена! Причины я не знаю. Возможно, что все дело в режиме программного управления NSS. Поэтому когда я стал использовать для SlaveSelect другой пин, то все заработало — ответы стали приходить.
P.S. Правда дальше все равно не заработало….Опять… 🙂
Поэтому снова обращение за советом к уважаемому автору (когда он разгребётся с работой) 🙂
Ситуация такая: на команду SEND_IF_COND приходит ответ 0x01 — значит флешка v2 — вроде бы логично — флешка куплена неделю назад и навряд ли она v1. Идем дальше: отсылаю ACMD41, т.е. APP_CMD (получаю ответ 0x01 — вроде тоже все норм) и APP_SEND_OP_COND — получаю ответ 0x05. Имеем illegal command error, значит флешка не воспринимает такую команду. Решил попробовать отослать просто CMD1(вдруг карта версии v1), т.е. SEND_OP_COND — получаю ответ 0x01. Т.е. карточка никак не хочет инициализироваться, т.к. ждем 0x00. Может ли быть еще другие варианты последовательности инициализации?
Решил проблему 🙂 Долго гуглил, находил различные решения (причем некоторые были противоположны друг другу:О) но ничего не помогало. Увидел вот эту ссылку http://stackoverflow.com/questions/2365897/initializing-sd-card-in-spi-issues — решил что это не поможет и стал дальше искать, а зря…. Так как позже, отчаявшись, решил пробовать все решения и добавил несколько команд spi_read(); в начале функции SD_sendCommand() и карточка наконец инициализировалась 🙂
P.S. В той же ссылке есть другой совет — «send ACMD41 with the bit set for the voltage you’re supplying the card with», и этот человек утверждает, что ему это помогло, хотя в Physical Layer Simplified Specification Version 4.10 говорит про аргумент ACMD41 так:
Argument Reserved bit HCS Reserved bits
Command Description — Sends host capacity support information and activates the card’s initialization process. Reserved bits shall be set to ‘0’
что явно противоречит выше сказанному. Так что не всем советам стоит верить. Возможно, что и моим тоже 🙂
И снова здравствуйте! 🙂 В ходе использования карточкой возник вопрос: а как отследить что мы пишем в неверный сектор? Я имею ввиду, например, на карте 1000000 секторов, а мы пытаемся записать в 1000001. Карта это спокойно воспринимает — присылает valid-ный R1-response на команду (0x00) и valid-ный Data-response после приема данных (0xE5, но это тоже самое что 0x05, ведь значимые только младшие 7 бит).
P.S. Причем при попытке считать из неверного сектора R1-response 0x40, т.е. Parameter Error.
stm32f103 контроллер? У них столкнулся с подобной проблемой, только в другом ключе и использовал не SPI. Решение проблемы нашел, в рамках одного из будущих материалов опишу его на сайте.
По остальным вопросам отправил Вам письмо.
Alex_EXE, благодарю за письмо. Всеми ссылками, которые Вы указали, активно пользовался и до этого 🙂 Кроме первой 🙂 Но она тоже выглядит полезной и ее стоит добавить в закладки. Я так понимаю Вы давали ссылку в этой статье на нее, но только на нерабочую версию, поэтому решил добавить ее в комментарии: http://mycontroller.ru/old_site/category/vneshnie-ustroystva/karta-pamyati-sd/default.htm
Теперь по поводу чем дело кончилось:) К сожалению, ответа на него я не нашел 🙁 Нет, проблему-то я решил, правда другим способом, но мне кажется что это лишние действия и было бы лаконичнее и красивее, если бы карта выдавала Parameter Error на попытку записать в неверный сектор. Возможно, где-то в закоулках даташита, все-таки скрывается ответ и его нужно просто очень внимательно прочитать 🙂 А вот об этом речь пойдет дальше, в следующем комменте 🙂
Так вот. Как я думал решить проблему. Чтобы не писать в несуществующий сектор нужно просто знать их количество и проверять не вышли ли мы за предел 🙂 Знаю, банально, но решать проблему как-то надо 🙂
Есть такой регистр CSD (The Card-Specific Data register) В нем определенные биты отвечают за размер карты C_SIZE, при чём: memory capacity = (C_SIZE+1) * 512KByte. Т.е. отсюда можно посчитать количество секторов. Читается он с помощью CMD9 (SEND_CSD). Нашел наверно с десяток ссылок (например https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Attachments/18065/stm32_eval_spi_sd.c) в которых был написан один и тот же(по смыслу, а не скопипащенный 🙂) алгоритм чтения этого регистра. Суть сводилась к следующему:
Reading the contents of the CSD register in SPI mode is a simple read-block transaction (при чем в даташите есть точно такая же строка, но абзац на этом не заканчивается, но видимо дальше никто не читает 🙂). В итоге, во все ссылках такая последовательность действий:
CS в ноль -> шлем команду CMD9 с пустым аргументом -> ждём R1(0x00) -> ждём Data Token(0xFE) -> читаем 16 байт регистра -> читаем 2 байта CRC -> CS в единицу. Всё, данные получили, осталось только их распарсить.
ОК, пишу код, запускаю. На команду отвечает R1(0x00), всё норм. Вместо Data Token(0xFE) приходит 0x7F, а дальше идут 0xFF. Приехали. Начинаю гуглить, искать что означает 0x7F и кто с этим сталкивался. Вообщем потратил кучу времени и всё в пустую. Потом смотрю на свой код команды чтения сектора и стоп! — в CMD17 сначала шлем команду, а потом CS в ноль, а тут наоборот почему-то, хотя везде сказано что что CMD9 та же самая CMD17. Думаю дай-ка попробую так. Ииии…нет 🙁 всё равно не получаем 0xFE. НО, если раньше дальше шли 0xFF, то теперь какие-то непонятные байты. Странно, непонятно…И тут у меня появилась мысль и полез я в даташит. И что же я там увидел, в следующей части абзаца, после строки про simple read-block transaction. А вот что:
The card will respond with a standard response token followed by a data block of 16 bytes suffixed with a 16-bit CRC.
Т.е. в даташите для команды CMD9 ни про какой Data Token не сказано! Т.е. сразу после R1(0x00) идут байты регистра! Вот что значат эти непонятные байты. Проверил — действительно, 18 байт (16 + CRC), а потом уже пошли 0xFF. Распарсил байты и проверил провел по даташиту все сходится, это он — CSD. И размер карты тоже сошелся. Ну дальше дело техники посчитать количество секторов.
Так что вот, мой так сказать опыт по этому вопросу, может кому пригодится, чтобы не трать (как мне дурачку) такое количество времени на поиски ошибок на пустом месте 🙁Alex_EXE пишет 22.10.2016 в 20:28
Кто знает, эта библиотека подойдет чтобы подключить к discovery флешку от mxic 25l на 32Мб?
BigPack 25 февраля 2014 в 22:02
Полнофункциональный драйвер SDHC карты памяти для Stm32f4 (часть 1)
- Системное программирование
Для чего эта статья?
Все эмбеддеры, рано или поздно, сталкиваются с проблемой нехватки ПЗУ микроконтроллера для своих проектов. Ну банально, Вам нужно разработать систему управления простеньким ЧПУ станком, где управляющая программа хранится на самом девайсе или систему сбора данных, скажем, от датчиков какого-нибудь эксперимента – очевидно, что микроконтроллер изначально не предназначался для хранения таких массивов информации.
Решений сего кейса масса, начиная от приобретения и подключения микросхем EEPROM и заканчивая коннектом стандартной USB флешки к аппаратному USB хосту камня (если таковой имеется, конечно). Ну, а для хэнд-майд проектов, отличным вариантом будет самая, что ни на есть классическая SD’шная карта памяти. Они бывают разного типа, имеют различные механизмы инициализации и передачи данных и подключаются к хосту через различные интерфейсы (их, правда, только три, но об этом позже). Более того, многие современные микроконтроллеры имеют на своем борту аппаратные модули этих интерфейсов, и работа разработчика сводится лишь к их конфигу и посылу карточке нужных команд в соответствии с протоколом. Ну и еще карты памяти имеют приятное свойство элементарно покупаться на каждом шагу.
О Secure Digital (SD) картах
Не буду переписывать Википедию – приведу здесь основные сведения и виды SD карт памяти и их характеристики.
Secure Digital формат
– популярный (пожалуй, самый популярный на сегодняшний день) формат flash памяти для использования, в основном, в портативных устройствах. Внутри каждой такой карточки имеется, собственно, микросхема flash памяти (Memory Core) и, связывающий ее с внешним миром контроллер, имеющий 8 регистров. Задачи последнего – аппаратная реализация внешних интерфейсов, поддержка информации о карте (тип, емкость, класс скорости еще куча других характеристик), контроль электропитания, и, конечно, управление самой микрухой памяти (адресация, чтение, запись, очистка и оганизация порядка 80 команд управления).
Формат 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 .
Интерфейс карты памяти
Как было сказано выше, Security Digital карты имеют три внешних интерфейса: SD, UHS-II и SPI. Первые являются «родными» каналами обмена данными с хостом, и, как следствие, позволяют реализовать полнофункциональное, полноскоростное взаимодействие. SPI же не поддерживает ряда команд и не дает максимальной скорости обмена данными, зато он есть во всех микроконтроллерах (и в современных и в старых моделях), что делает возможным без особых проблем приконнектить карточку ко всему, что плохо лежит. Существует масса статей о том, как это сделать. Но, с развитием микропроцессорной техники, с уменьшением нанометров в технологическом процессе производства камней, SPI интерфейс, как средство коммуникации с SD картой постепенно отмирает. Действительно, если ваш МК поддерживает аппаратную реализацию SD протокола, будите ли Вы связываться с менее функциональной альтернативой? Судьба послала мне на проект камень Stm32f4 от STMicroelectronics, в котором как раз таки и имеется периферийный модуль SDIO (Security Digital Input Output), аппаратно реализующий и интерфейс, и протокол карточки.
Так что же такое 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 Карты памяти
Ну мы, эмбеддеры, люди привыкшие, что все надо инициализировать, поэтому 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 карты
В данном примере используется самодельная функция посылки команды, написанная под периферию Stm32F4.char SDIO_send_command(char index, unsigned int arg, char resp_type, unsigned int *resp);
index – индекс команды;
arg - аргумент;
resp type – тип отклика (0 – без отклика, 1 – короткий (48 бит) отклик, 2 – длинный (136 бит) отклик);
resp - массив откликов (в случае короткого отклика информацию несет первый элемент массива, в случае длинного – 4 элемента).
Команда возвращает 0, в случае успешной операции посыла команды и приема ответа и код ошибки в противном случае.
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;
}
Запускаем код, убеждаемся, что в ответе пришел НУЛЬ и завершаем инициализацию. Все, можем работать с памятью и писать/считывать информацию.
Обмен данными
Здесь всем рулит SD Memory Card State Diagram (data transfer mode).
Существует 6 статусов карты в этом режиме и узнать их можно в отклике R1
на месте 12:9
битов. Обратимся к спецификации.
Stand by State (stby)
– устанавливается после инициализации вместо Idle State.
Transfer State (tran)
– режим передачи данных.
Receive Data State (rcv)
– ожидание пачки данных от хоста.
Programming State (prg)
– запись принятой пачки во flash.
Sending Data State (data)
– посылка пачки данных хосту.
Disconnect State (dis)
– используется для выбора другой карты командой CMD7.
Запись данных на карту
Итак, после успешной инициализации мы находимся в состоянии tran , во всяком случае, должны находиться. Смотрим по диаграмме: для того, чтобы перейти на состояние rcv , нужно послать команду CMD24 с адресом 512 байтной ячейки, которую хотим записать. Послали. Карта перешла в режим ожидания данных. Далее начинаем кидать ей информацию по шине данных, пока не перекинем все 512 байт или не пошлем команду CMD12 (стоп передачи). После завершения акта, карточка сама переедет в состояние prg и пробудет там некоторое время (пока данные запишутся). Ждем.… Как имено ждем? А посылаем ей в цикле CMD13 с адресом карты в аргументе, до тех пор, пока не вернется в отклике R1 типа статус tran . Когда это, наконец, случилось можно слать очередную пачку данных, вновь послав CMD24. Кроме того, существует еще режим записи несколькими блокам сразу (CMD25) и другие режимы – за подробностью – в спецификацию.Чтение данных
Дабы выполнить обратную процедуру, в первую очередь, убеждаемся, что карта стоит в tran . Шлем CMD17 с адресом RCA в аргументе. Если все пройдет успешно – карточка переедет в состояние data и начнет выдавать на линии данных информацию, опять же 512 байтным блоком. Задача хоста в это время внимательно слушать линию и считывать данные. Как только посылка закончится, карта сама переедет в статус tran . Думаю, не стоит и говорить о том, что считывание так же как и запись возможна несколькими блоками сразу.Не буду приводить в этой статье листинг программы чтения/записи, так как он, в отличии от подпрограммы инициализации слишком сильно завязан на железе SDIO модуля микроконтроллера Stm32f4, а это – тема второй части статьи.
Существует множество различных типов носителей данных на основе так называемой флеш-памяти. Мы пользуемся обычными флешками для передачи файлов друг-другу, micro-SD картами для увеличения свободного места в смартфонах, даже вместо старого доброго жесткого диска в современных ноутбуках используем SSD носители — ту же флеш-память. Флеш-память не имеет движущихся частей, в отличие от старинных дискет и более новых жестких дисков. Скорость чтения и записи такой памяти выше чем у всех прежних носителей, а энергопотребление — наоборот ниже. Другими словами, если мы хотим в наших электронных устройствах и роботах хранить какие-то данные, то рационально будет воспользоваться именно флеш-памятью. Зачем может понадобиться карта памяти? Например, для того, чтобы записывать на неё данные с различных датчиков нашего устройства. Кроме самих показаний датчиков, рационально еще записывать время съема этих показаний — это называется журналированием. Таким образом, подключив к Ардуино датчики температуры, влажности и давления, а также часы реального времени и карту памяти мы сможем сделать настоящую погодную станцию! Разберем как именно карта памяти подключается к Ардуино и каким образом осуществляется её запись и чтение.
1. Подключение модуля micro-SD карт к Ардуино
В этом уроке мы будем читать и записывать данные на micro-SD карту. В плане подключения в Ардуино, модуль micro-SD ничем не отличается от модуля для обычных SD карт. Модуль подключается к Ардуино по SPI шине, а значит нужно соединить уже знакомые по другим урокам контакты в стандартном порядке:| Модуль micro-SD карт | GND | VCC | CS | MOSI | MISO | SCK |
| Ардуино Уно | GND | +5V | 4 | 11 | 12 | 13 |
Внешний вид макета
2. Программа для чтения micro-SD карты
Чтобы проверить работу устройства, напишем простую программу, которая будет лишь считывать с карты служебную информацию: тип карты, тип файловой системы, размер первого раздела и список файлов на нём. #include
Если появилась подобная информация, значит с картой и модулем всё в порядке. Можно приступать к дальнейшей работе.
3. Программа для записи данных на micro-SD карту
Теперь попробуем создать новый файл на карте и записать туда простую фразу «Hello from robotclass». #include4. Программа для чтения данных с micro-SD карты
Наконец, прочитаем файл test.txt и выведем в COM-порт текст из него. #includeЗаключение
В следующем уроке мы попробуем добавить в схему часы реального времени и датчик температуры. Оставив такое устройство на целый день мы сможем в итоге построить дневной график температуры.Урок 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 базу.
- SPI. Универсален, и подойдёт для любого микроконтроллера, а подключение требует всего четыре пина.
- 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
Если всё прошло удачно, то на экран выведется информация о типе файловой системы и объёме вашей SD-карты. Если же производитель подсунул вам не лучший продукт, могут возникнуть ошибки. Здесь проще купить новую флешку, чем бороться с ошибками файловой системы, изначально заложенными в девайс.
Когда вы получите отклик от системы, можете начинать подгружать библиотеки и нужные вам файлы. SD-карта полностью работает и подключена, однако не забудьте протестировать несколько типов файловых систем, дабы подобрать оптимальный вариант по скорости и потреблению ресурсов. В каждом конкретном случае эти параметры будут разными, поэтому не бойтесь экспериментировать.
Заключение
SD-карта – необходимый элемент любой системы, в которой вы собираетесь использовать медиафайлы. Это будет хорошим решением как для приборов под «умный дом», так и для самодельных плееров. Однако не забывайте, что качество конечного продукта приравнивается к качеству его худшего компонента, и не стоит экономить на SD-картах.