Escudo de registro de cartão microSD WPI304N para Arduino
Manual do usuário
Escudo de registro de cartão microSD para Arduino®

WPI304N

Introdução

A todos os residentes da União Europeia
Informações ambientais importantes sobre este produto
Este símbolo no dispositivo ou na embalagem indica que o descarte do dispositivo após seu ciclo de vida pode prejudicar o meio ambiente. Não descarte a unidade (ou baterias) como lixo municipal indiferenciado; deve ser levado a uma empresa especializada para reciclagem. Este dispositivo deve ser devolvido ao seu distribuidor ou a um serviço de reciclagem local. Respeite as regras ambientais locais.
Em caso de dúvida, entre em contato com as autoridades locais de descarte de resíduos.
Obrigado por escolher Wadda! Leia atentamente o manual antes de colocar este dispositivo em serviço. Se o dispositivo foi danificado em trânsito, não o instale ou use e entre em contato com seu revendedor.

Instruções de segurança

Leia e entenda este manual e todos os sinais de segurança antes de usar este aparelho.
Somente para uso interno.

• Este dispositivo pode ser usado por crianças com 8 anos ou mais, e pessoas com capacidades físicas, sensoriais ou mentais reduzidas ou falta de experiência e conhecimento, se tiverem recebido supervisão ou instruções sobre o uso do dispositivo de forma segura e entenderem os perigos envolvidos. As crianças não devem brincar com o dispositivo. A limpeza e a manutenção do usuário não devem ser feitas por crianças sem supervisão.

Diretrizes gerais

• Consulte a Garantia de Qualidade e Serviço Velleman® nas últimas páginas deste manual.
• Todas as modificações do dispositivo são proibidas por razões de segurança. Danos causados ​​por modificações do usuário no dispositivo não são cobertos pela garantia.
• Use o dispositivo somente para o propósito pretendido. Usar o dispositivo de forma não autorizada anulará a garantia.
• Danos causados ​​pela desconsideração de certas diretrizes deste manual não são cobertos pela garantia e o revendedor não se responsabiliza por quaisquer defeitos ou problemas decorrentes.
• Nem a Velleman Group nv nem seus revendedores podem ser responsabilizados por quaisquer danos (extraordinários, incidentais ou indiretos) – de qualquer natureza (financeiro, físico…) decorrentes da posse, uso ou falha deste produto.
• Guarde este manual para referência futura.

O que é Arduino®

Arduino ® é uma plataforma de prototipagem de código aberto baseada em hardware e software fáceis de usar. As placas Arduino ® são capazes de ler entradas – sensor de luz acesa, um dedo em um botão ou uma mensagem do Twitter – e transformá-las em uma saída – ativação de um motor, ligar um LED, publicar algo online. Você pode dizer à sua placa o que fazer enviando um conjunto de instruções para o microcontrolador na placa. Para fazer isso, você usa a linguagem de programação Arduino (com base em Wiring) e o IDE de software Arduino ® (com base em Processing). Shields/módulos/componentes adicionais são necessários para ler uma mensagem do Twitter ou publicar online. Navegue até www.arduino.cc para maiores informações.

Produto acabadoview

Este shield será útil para registro de dados com seu Arduino®. Pode ser facilmente montado e personalizado para qualquer projeto de registro de dados.
Você pode usar este cartão para acessar cartões de memória microSD usando o protocolo SPI em seus projetos de microcontroladores.

Especificações

• suporta cartões microSD (≤ 2 GB) e cartões microSDHC (≤ 32 GB) (alta velocidade)
• volume a bordotage circuito de conversão de nível que faz interface com o volume de dadostages entre 5 V do controlador Arduino ® e 3.3 V para pinos de dados do cartão SD
• fonte de alimentação: 4.5-5.5 V
• volume a bordotage regulador 3V3, para voltagcircuito de nível e
• interface de comunicação: barramento SPI
• 4 furos de posicionamento de parafusos M2 para fácil instalação
• tamanho: 4.1 x 2.4 cm

Fiação

Escudo de registro	Para Arduino® Uno	Para Arduino ® Mega
CS (seleção de cabo)	4	53
SCK (CLK)	13	52
MOSI	11	51
MISO	12	50
5 V (4.5 V a 5.5 V)	5V	5V
Terra	Terra	Terra

Diagrama de circuito

Operação

Introdução
O módulo de cartão SD WPI304N é especialmente útil para projetos que exigem registro de dados. O Arduino ® pode criar um file em um cartão SD para gravar e salvar dados, usando o padrão SD biblioteca do Arduino ® IDE. O módulo WPI304N usa o protocolo de comunicação SPI.
Preparando o cartão microSD
O primeiro passo ao usar o módulo de cartão SD WPI304N com Arduino ® é formatar o cartão microSD como FAT16 ou FAT32 file sistema. Siga as instruções abaixo:

1. Insira o cartão SD no seu computador. Vá para Meu Computador e clique com o botão direito do mouse na unidade removível do cartão SD. Selecione Formatar, como mostrado na imagem abaixo.
2. Uma nova janela aparece. Selecione FAT32, pressione Start para inicializar o processo de formatação e siga as instruções na tela.

Usando o módulo de cartão SD
Insira o cartão microSD formatado no módulo de cartão SD. Conecte o módulo de cartão SD ao Arduino ® Uno conforme mostrado no circuito abaixo, ou verifique a tabela de atribuição de pinos em uma seção anterior.

Codificação
Informações do cartão SD
Para certificar-se de que tudo está conectado corretamente e que o cartão SD está funcionando, vá para File →Examples → SD → CardInfo no software Arduino ® IDE.
Agora, carregue o código para sua placa Arduino® Uno. Certifique-se de selecionar a placa e a porta COM corretas. Abra o monitor serial com taxa de transmissão 9600. Normalmente, as informações do seu cartão microSD serão apresentadas no monitor serial. Se tudo estiver funcionando corretamente, você verá uma mensagem semelhante no monitor serial.

Ler e escrever dados no cartão microSD
A biblioteca SD fornece funções úteis que permitem escrever e ler facilmente de um cartão SD. Abra o ReadWrite example de File →Examples → SD →  LerEscrever e carregue-o na sua placa Arduino® Uno.
Código

1. /*
2. Leitura/gravação de cartão SD
3.
4. Este example mostra como ler e gravar dados de e para um cartão SD file
5. O circuito:
6. Cartão SD conectado ao barramento SPI da seguinte forma:
7. ** MOSI – pino 11
8. ** MISO – pino 12
9. ** CLK – pino 13
10. ** CS – pino 4 (para MKRZero SD: SDCARD_SS_PIN)
11.
12. criado em novembro de 2010
13. por David A. Mellis
14. modificado em 9 de abril de 2012
15. por Tom Igoe
16.
17. Este exampO código é de domínio público.
18.
19. */
20.
21. #incluir
22. #incluir
23.
24. File myFile;
25.
26. configuração vazia() {
27. // Abra as comunicações seriais e aguarde a porta abrir:
28. Serial.begin(9600);
29. enquanto (!Serial) {
30. ; // aguarde a porta serial conectar. Necessário somente para porta USB nativa
31.}
32.
33.
34. Serial.print(“Inicializando cartão SD…”);
35.
36. se (!SD.begin(4)) {
37. Serial.println(“inicialização falhou!”);
38. enquanto (1);
39.}
40. Serial.println(“inicialização concluída.”);
41.
42. // abra o file. observe que apenas um file pode ser aberto ao mesmo tempo,
43. // então você tem que fechar este antes de abrir outro.
44. meuFile = SD.open(“teste.txt”, FILE_ESCREVER);
45.
46. ​​// se o file aberto ok, escreva para ele:
47. se (meuFile) {
48. Serial.print(“Escrevendo em test.txt…”);
49. meuFile.println(“testando 1, 2, 3.”);
50. // feche o file:
51. meuFile.fechar();
52. Serial.println(“feito.”);
53. } senão {
54. ​​// se o file não abriu, imprimiu um erro:
55. Serial.println(“erro ao abrir test.txt”);
56.}
57.
58. // reabrir o file para ler:
59. meuFile = SD.open(“teste.txt”);
60. se (meuFile) {
61. Serial.println(“teste.txt:”);
62.
63. // leia do file até que não haja mais nada nele:
64. enquanto (meuFile.disponível()) {
65. Serial.write(meuFile.ler());
66.}
67. // feche o file:
68. meuFile.fechar();
69. } senão {
70. ​​// se o file não abriu, imprimiu um erro:
71. Serial.println(“erro ao abrir test.txt”);
72.}
73.}
74.
75. loop vazio() {
76. // nada acontece após a configuração
77.}

Depois que o código for carregado e tudo estiver ok, a seguinte janela aparecerá no monitor serial.Isso indica que a leitura/escrita foi bem-sucedida. Para verificar sobre o files no cartão SD, use o Bloco de notas para abrir o TEST.TXT file no cartão microSD. Os seguintes dados aparecem no formato .txt:

NonBlockingWrite.ino example
No ex originalampo código NonBlockingWrite, altere a linha 48
se (!SD.begin()) {
para
se (!SD.begin(4)) {
Adicione também as seguintes linhas após a linha 84:
// imprima o comprimento do buffer. Isso mudará dependendo de quando
// os dados são realmente gravados no cartão SD file:
Serial.print(“Comprimento do buffer de dados não salvos (em bytes): “);
Serial.println(buffer.length());
// observe o horário em que a última linha foi adicionada à string
O código completo deve ser o seguinte:

1. /*
2. Escrita sem bloqueio
3.
4. Este example demonstra como executar gravações sem bloqueio
5. para um file em um cartão SD. O file conterá o millis() atual
6. valor a cada 10 ms. Se o cartão SD estiver ocupado, os dados serão armazenados em buffer
7. para não bloquear o esboço.
8.
9. NOTA: meuFile.availableForWrite() sincronizará automaticamente o
10. file conteúdo conforme necessário. Você pode perder alguns dados não sincronizados
11. ainda se meuFile.sync() ou meuFile.close() não é chamado.
12.
13. O circuito:
14. Cartão SD conectado ao barramento SPI da seguinte forma:
15. MOSI – pino 11
16. MISO – pino 12
17. SCK / CLK – pino 13
18. CS – pino 4 (para MKRZero SD: SDCARD_SS_PIN)
19.
20. Este exampO código é de domínio público.
21. */
22.
23. #incluir
24.
25. // file nome a ser usado para escrever
26. caractere constante filenome[] = “demo.txt”;
27.
28. // File objeto a representar file
29. File TXTFile;
30.
31. // string para saída de buffer
32. Buffer de string;
33.
34. unsigned long lastMillis = 0;
35.
36. configuração vazia() {
37. Serial.begin(9600);
38. enquanto (!Serial);
39. Serial.print(“Inicializando cartão SD…”);
40.
41. // reserve 1kB para String usada como buffer
42. buffer.reserva(1024);
43.
44. // define o pino LED para saída, usado para piscar ao escrever
45. pinMode(LED_BUILTIN, SAÍDA);
46.
47. // inicializar o cartão SD
48. se (!SD.begin(4)) {
49. Serial.println(“Cartão falhou ou não está presente”);
50. Serial.println(“inicialização falhou. Coisas para verificar:”);
51. Serial.println(“1. um cartão está inserido?”);
52. Serial.println(“2. sua fiação está correta?”);
53. Serial.println(“3. você alterou o pino chipSelect para corresponder ao seu escudo ou
módulo?");
54. Serial.println(“Nota: pressione o botão de reset na placa e reabra este Serial Monitor
depois de corrigir seu problema!”);
55. // não faça mais nada:
56. enquanto (1);
57.}
58.
59. // Se você quiser começar do zero file,
60. // descomente a próxima linha:
61. // SD.remover(filenome);
62.
63. // tente abrir o file para escrever
64. textoFile = SD.abrir(filenome, FILE_ESCREVER);
65. se (!txtFile) {
66. Serial.print(“erro ao abrir “);
67. Serial.println(filenome);
68. enquanto (1);
69.}
70.
71. // adicione algumas novas linhas para começar
72. textoFile.imprimir();
73. textoFile.println(“Olá Mundo!”);
74. Serial.println(“Começando a escrever para file…”);
75.}
76.
77. loop vazio() {
78. // verifique se já se passaram mais de 10 ms desde a última linha adicionada
79. unsigned long agora = millis();
80. se ((agora – lastMillis) >= 10) {
81. // adicione uma nova linha ao buffer
82. buffer += “Olá “;
83. buffer += agora;
84. tampão += “\r\n”;
85. // imprima o comprimento do buffer. Isso mudará dependendo de quando
86. // os dados são realmente gravados no cartão SD file:
87. Serial.print(“Comprimento do buffer de dados não salvos (em bytes): “);
88. Serial.println(buffer.length());
89. // observe o horário em que a última linha foi adicionada à string
90. lastMillis = agora;
91.}
92.
93. // verifique se o cartão SD está disponível para gravar dados sem bloquear
94. // e se os dados armazenados em buffer forem suficientes para o tamanho total do bloco
95. int não assinado chunkSize = txtFile.disponívelParaGravar();
96. se (chunkSize && buffer.length() >= chunkSize) {
97. // escrever para file e piscar LED
98. digitalWrite(LED_BUILTIN, ALTO);
99. textoFile.write(buffer.c_str(), tamanho do pedaço);
100. digitalWrite(LED_BUILTIN, BAIXO);
101.
102. // remove dados escritos do buffer
103. buffer.remove(0, tamanho do pedaço);
104.}
105.}

Reservados modificações e erros tipográficos – © Velleman Group nv. WPI304N_v01
Velleman Group nv, Legen Heirweg 33 – 9890 Gavere.
whadda.com

Documentos / Recursos

Escudo de registro de cartão microSD WHADDA WPI304N para Arduino [pdf] Manual do Usuário Escudo de registro de cartão microSD WPI304N para Arduino, WPI304N, Escudo de registro de cartão microSD para Arduino, Escudo de registro de cartão, Escudo de registro, Escudo

Referências

• Manual do usuário