roboforum.ru

/*
  SD card test
 
 This example shows how use the utility libraries on which the'
 SD library is based in order to get info about your SD card.
 Very useful for testing a card when you're not sure whether its working or not.
 
 The circuit: 
  * SD card attached to SPI bus as follows:
 ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila
 ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila
 ** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila
 ** CS - depends on your SD card shield or module.
        Pin 4 used here for consistency with other Arduino examples
 
 
 created  28 Mar 2011
 by Limor Fried
 modified 9 Apr 2012
 by Tom Igoe
 */
// include the SD library:
#include <SPI.h>
#include <SD.h>
 
// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;
 
#define PIN_RESET_ 9
#define PIN_SCE_   10
#define PIN_DC_    12
#define PIN_SDIN_  11
#define PIN_SCLK_  13
 
#define LCD_C_     LOW
#define LCD_D_     HIGH
 
#define LCD_X_     84
#define LCD_Y_     48
 
static const byte ASCII[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20  
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ВҐ
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j 
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e в†ђ
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f в†’
};
 
void LcdCharacter(char character)
{
  LcdWrite(LCD_D_, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D_, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D_, 0x00);
}
 
void LcdClear(void)
{
  for (int index = 0; index < LCD_X_ * LCD_Y_ / 8; index++)
  {
    LcdWrite(LCD_D_, 0x00);
  }
}
 
void LcdInitialise(void)
{
  pinMode(PIN_SCE_, OUTPUT);
  pinMode(PIN_RESET_, OUTPUT);
  pinMode(PIN_DC_, OUTPUT);
  pinMode(PIN_SDIN_, OUTPUT);
  pinMode(PIN_SCLK_, OUTPUT);
  digitalWrite(PIN_RESET_, LOW);
  digitalWrite(PIN_RESET_, HIGH);
  LcdWrite(LCD_C_, 0x21 );  // LCD Extended Commands.
  LcdWrite(LCD_C_, 0xB1 );  // Set LCD Vop (Contrast). 
  LcdWrite(LCD_C_, 0x04 );  // Set Temp coefficent. //0x04
  LcdWrite(LCD_C_, 0x14 );  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_C_, 0x20 );  // LCD Basic Commands
  LcdWrite(LCD_C_, 0x0C );  // LCD in normal mode.
}
 
void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}
 
void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC_, dc);
  digitalWrite(PIN_SCE_, LOW);
  shiftOut(PIN_SDIN_, PIN_SCLK_, MSBFIRST, data);
  digitalWrite(PIN_SCE_, HIGH);
}
 
void gotoXY(int x, int y)
{
  LcdWrite(0, 0x80 | x);  // Column.
  LcdWrite(0, 0x40 | y);  // Row.  
}
 
// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 8;
 
void setup() {
  LcdInitialise();
  
  LcdClear();
  gotoXY(0,0);
  LcdString("Test!");
  
  // Open serial communications and wait for port to open:
  pinMode(16, OUTPUT); digitalWrite(16, LOW);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
 
  LcdClear();
  gotoXY(0,0);
  LcdString("Initializing SD card...");
  
  //Serial.print("\nInitializing SD card...");
 
  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) { digitalWrite(16, HIGH);
  
  LcdClear();
  gotoXY(0,0);
  LcdString("Initialization failed.");
  
    //Serial.println("initialization failed. Things to check:");
    //Serial.println("* is a card inserted?");
    //Serial.println("* is your wiring correct?");
    //Serial.println("* did you change the chipSelect pin to match your shield or module?");
    return;
  } else {
    
  LcdClear();
  gotoXY(0,0);
  LcdString("Wiring is correct and a card is present.");
  
    //Serial.println("Wiring is correct and a card is present.");
  }
 
  // print the type of card
  //Serial.print("\nCard type: ");
  switch (card.type()) {
    case SD_CARD_TYPE_SD1:
    
  LcdClear();
  gotoXY(0,0);
  LcdString("Card type: SD1");
  
      //Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
    
  LcdClear();
  gotoXY(0,0);
  LcdString("Card type: SD2");
  
      //Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
    
  LcdClear();
  gotoXY(0,0);
  LcdString("Card type: SDHC");
  
      //Serial.println("SDHC");
      break;
    default:
    
  LcdClear();
  gotoXY(0,0);
  LcdString("Card type: Unknown");
  
      //Serial.println("Unknown");
      break;
  }
 
  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) { digitalWrite(16, HIGH);
  
  LcdClear();
  gotoXY(0,0);
  LcdString("Could not find FAT16/FAT32 partition.");
  
    //Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    return;
  }
  
  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  
  LcdClear();
  gotoXY(0,0);
  LcdString("Volume type is FAT.");
  
  //Serial.print("\nVolume type is FAT");
  //Serial.println(volume.fatType(), DEC);
  //Serial.println();
 
  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
  volumesize *= 512;                            // SD card blocks are always 512 bytes
  //Serial.print("Volume size (bytes): ");
  //Serial.println(volumesize);
  //Serial.print("Volume size (Kbytes): ");
  volumesize /= 1024;
  //Serial.println(volumesize);
  //Serial.print("Volume size (Mbytes): ");
  volumesize /= 1024;
  //Serial.println(volumesize);
 
 
  //Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);
 
  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
  
  LcdClear();
  gotoXY(0,0);
  LcdString("Test!");
}
 
 
void loop(void)
{
  
}