在Arduino上使用霍尔开关比较简单，电路连接上只需要用专用的传感器连接线，将霍尔开关与传感器扩展板上的相应端口连接起来就可以了：

编程的话使用最简单的数字输入函数digitalRead()进行读取就可以了：

int ledPin = 13;
int switchPin = 19;
int value = 0; 

void setup() {
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  value = digitalRead(switchPin);
  if (HIGH == value) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

使用的时候当霍尔开关靠近磁铁的时候，从Arduino相应引脚读出来的值为高，而当霍尔开关远离磁铁的时候，从Arduino相应引脚读出来的值为低。另外这里介绍的霍尔开关模块属于单极性霍尔元件，所以只对磁铁的南极或者北极有响应，实验的时候如果发现不响应的话可以试着换磁铁的另一极使用噢;-)

这个4位7段数码管的模块采用专用的驱动芯片来控制数码管的各个引脚，并且使用I2C总线与Arduino进行连接，也就是说我们只需要用两根数据线就可以用Arduino来控制这一数码管模块了：

连接的方法很简单，只需要用专用的I2C连接线，将这一4位7段数码管与Arduino专用扩展板上的I2C端口连接起来就可以了：

同时注意将模块背面的RS开关设置到ON的位置，使能I2C引脚上的上拉电阻：

测试的时候可以使用如下的代码，该代码可以在数码管上循环显示0-9和a-f，同时还可以控制数码管上的小数点：

#include "Wire.h"  // enable I2C bus

//byte saa1064 = 0x70 >> 1; // define the I2C bus address for our SAA1064 (pin 1 to GND)
byte saa1064 = 0x76 >> 1; // define the I2C bus address for our SAA1064 (pin 1 to VCC)

int digits[16]={63, 6, 91, 79, 102, 109, 125,7, 127, 111, 119, 124, 57, 94, 121, 113};
// these are the byte representations of pins required to display each digit 0~9 then A~F

void setup()
{
  Wire.begin(); // start up I2C bus
  delay(500);
  initDisplay();
}

void initDisplay()
// turns on dynamic mode and adjusts segment current to 12mA
{
  Wire.beginTransmission(saa1064);
  Wire.send(B00000000); // this is the instruction byte. Zero means the next byte is the control byte
  Wire.send(B01000111); // control byte (dynamic mode on, digits 1+3 on, digits 2+4 on, 12mA segment current
  Wire.endTransmission();
}

void displayDigits()
// show all digits 0~9, A~F on all digits of display
{
  for (int z=0; z<16; z++)
  {
    Wire.beginTransmission(saa1064);
    Wire.send(1); // instruction byte - first digit to control is 1 (right hand side)
    Wire.send(digits[z]); // digit 1 (RHS)
    Wire.send(digits[z]); // digit 2
    Wire.send(digits[z]); // digit 3
    Wire.send(digits[z]); // digit 4 (LHS)
    Wire.endTransmission();
    delay(500);
  }

// now repeat but with decimal point

 for (int z=0; z<16; z++)
  {
    Wire.beginTransmission(saa1064);
    Wire.send(1); // instruction byte - first digit to control is 1 (right hand side)
    Wire.send(digits[z]+128); // digit 1 (RHS)
    Wire.send(digits[z]+128); // digit 2
    Wire.send(digits[z]+128); // digit 3
    Wire.send(digits[z]+128); // digit 4 (LHS)
    Wire.endTransmission();
    delay(500);
  }
}

void clearDisplay()
// clears all digits
{
  Wire.beginTransmission(saa1064);
  Wire.send(1); // instruction byte - first digit to control is 1 (right hand side)
  Wire.send(0); // digit 1 (RHS)
  Wire.send(0); // digit 2
  Wire.send(0); // digit 3
  Wire.send(0); // digit 4 (LHS)
  Wire.endTransmission();
}

void loop()
{
  displayDigits();
  clearDisplay();
  delay(1000);
}

运行结果如下图所示：

由于该模块使用的是I2C接口，因此实际上也允许同时接入多个数码管模块，但必须对模块的地址进行设置。在数码管模块的背面有一个ADDR跳线，正是进行这一地址位设置的：

设置的办法是用铬铁将中间的引脚分别与VCC或者GND端连接起来，如果中间引脚与VCC连接时，相应的地址为0×76：

如果中间引脚与GND连接时，相应的地址为0×70：

这一模块在出厂时中间的引脚即不与VCC连接，也不与GND连接，此时的地址也是0×76。

FlexiForce压力传感器在实际使用的时候需要搭配相应的放大电路，因此我们设计了这一电子积木，以便在实际工程中能够很方便地运用这一传感器：

同其他电子积木一样，在使用的时候只需要用传感器连接线，将该模块与传感器扩展板连接起来就可以了：

对Arduino来讲，读取该传感器输出的值与其它模拟传感器的做法是一样的，下面是相应的测试代码：

int sensorPin = 5;
int value = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  value = analogRead(sensorPin);
  Serial.println(value, DEC);
  delay(10);
}

RS485串行总线接口标准以差分平衡方式传输信号，具有很强的抗共模干扰的能力，允许一对双绞线上一个发送器驱动多个 负载设备，其理论的通讯距离是1200米，速率高达20Mbps，并可以用在强噪声的环境中正常工作，因此在工业通讯领域中被广泛应用。 当我们在Arduino上使用RS485时，更多的可能是借助其互连功能，将多个Arduino连接成一个RS485网络，来实现各个Arduino之间的通信。

在由RS485构成的多机串行通信系统中，一般采用的都是主从式结构：也就是说主机负责所有的通信协调过程，从机一般被动地接收主机发送过来的数据，或者根据主机的命令向主机反馈相应的数据，各个从机之间一般不进行数据交换，而是通过主机进行中转。之所以采用这种方式是因为于RS485是一种半双工通讯，发送和接收共用同一物理信道，在任一时刻都只允许一台设备处于发送状态。如果在时序上配合不好，就会发生总线冲突，使整个系统的通讯瘫痪，从而无法正常工作。

我们以一个三个结点的网络为例，介绍如何利用RS485串口模块来构建一个RS485网络，该网络中包括一台作为主机使用的Arduino（S）和两台作为从机使用的Arduino（CA, CB）。对于网络中的每一台Arduino来讲，硬件连接上我们都需要一块Arduino专用传感器扩展板、一条COM连接线和一条通用传感器连接线，其中COM连接线用来将RS485串口模块与传感器扩展板上的COM口连接起来，而通用传感器连接线则用来将RS485串口模块上的RE/DE引脚和标号为2的数字I/O口连接起来：

我们之前已经介绍过，RS485网络上的任何时候都只有一台设备处于发送状态，而其它设备则应该全部都处于接收状态。Arduino正是通过对RE/DE引脚的控制，来指定该设备是向RS485网络中发送数据，还是从RS485网络中接收数据。为了说明上的方便，在我们的例子中主设备S一直都处于发送状态，相应的RE/DE引脚一直处于高电平状态；两台从设备CA和CB一直处于接收状态，相应的RE/DE引脚则一直处于低电平状态。

在RS485串口模块上另一个需要引起我们注意的就是标记为“TERM?”的开关，它是用来控制终端电阻的，目的是为了吸收RS485网络中的反射信号，以保证正常传输的信号不受到干扰。不过该电阻只能在RS485总线上的最后一台设备上出现，这也是为什么叫做终端电阻的原因。在我们上面给出的网络拓朴图中不难看出，从机CB是总线上的最后一台设置，因此我们需要在该设备所对应的RS485串口模块上将“TERM?”开关拨到“Y”的位置：

而在主机S和从机CA上该开关都需要设置到与之相反的位置上：

由于是要将三个Arduino连接成一个RS485网络，因此我们还需要将RS485 串口模块两两连接起来，这是通过RS485串口模块上的“485 IN”和“485 THU”两个插座来实现的。具体说来，就是我们需要将前一个RS485串口模块的“485 THU”接口，与下一个RS485串口模块的“485 IN”接口连接起来，连接的时候我们可以使用模拟传感器连接线，或者是普通的杜邦线。对于我们正在构建的三个结点的RS485网络来讲，则是要求主机S的“485 THU”与从机CA的“485 IN”连接起来，然后再将从机CA的“485 THU”与从机CB的“485 IN”连接起来，实验中我们使用的是长度为2米的模拟传感器连接线。下图中从左至右依次为主机S，从机CA和从机CB：

硬件都连接好之后，下面我们就可以为各个Arduino来编写相应的程序了。下面是主机S的代码：

int EN = 2;

void setup()
{
  pinMode(EN, OUTPUT);
  Serial.begin(19200);
}

void loop()
{
// send data 
  digitalWrite(EN, HIGH);//使能发送
  Serial.print('A');
  Serial.print('B');
  delay(1000);
}

从主机S的代码不难看出，虽然采用的是RS485串口协议，但编程时使用的还是普通的串口操作语句。

下面是从机CA所使用的代码：

int ledPin = 13;
int EN = 2;
int val;

void setup()
{
  pinMode(ledPin, OUTPUT);
  pinMode(EN, OUTPUT);
  Serial.begin(19200);
}

void loop()
{
  // receive data
 digitalWrite(EN, LOW);//使能接收
 val = Serial.read();
  if (-1 != val) {
    if ('A' == val) {
      digitalWrite(ledPin, HIGH);
      delay(500);
      digitalWrite(ledPin, LOW);
      delay(500);
    }
 }
}

下面是从机CB所使用的代码：

int ledPin = 13;
int EN = 2;
int val;

void setup()
{
  pinMode(ledPin, OUTPUT);
  pinMode(EN, OUTPUT);
  Serial.begin(19200);
}

void loop()
{
  // receive data
 digitalWrite(EN, LOW);//使能接收
 val = Serial.read();
  if (-1 != val) {
    if ('B' == val) {
      digitalWrite(ledPin, HIGH);
      delay(500);
      digitalWrite(ledPin, LOW);
      delay(500);
    }
 }
}

从代码中不难看出，CA和CB分别响应主机S发送过来的字母A或者B，然后做相应的反应：点亮一个LED灯。在将三台Arduino都分别通电之后，你就可以看到作为主机的CA和CB在接到主机S发过来的命令之后，分别做相应的点灯动作。

最后需要说明的一点是，虽然在我们的例子中演示的是主机S不断向从机CA和CB发送数据的单向通信过程，但其实在RS485网络中也是可以实现双向通信的，只但需要在代码上做更多的工作，并且需要在主机和从面之间根据应用的需要定义一个相应的数据通信协议。

目前这一方案受限于所采用的DAC芯片精度的影响，最高只能做到16bit，22KHz，Mono格式的WAV文件，不过这对于大部分应用场合来讲已经足够了。

使用该模块时需要事先准备好符合我们要求WAV文件，有不少音频转换软件可以完成该任务。下面我们以Audacity（http://audacity.sourceforge.net/）为例，讲述如何讲MP3文件转换成我们所需要的格式。

运行Audacity之后，选择“File”菜单下的“Open”命令，打开需要进行转换的MP3文件：

通常MP3文件都是立体声（Stereo）格式的，我们需要将其分离成两个单独的音轨，这可以通过选择左侧声音文件标题下拉框中的“Split Stereo Track”命令来完成：

为了避免这两个音轨在混音之后音量过大，我们可以分在每个音轨上将增益（Gain）设置成-6dB，修改的方法是拖动相应音轨左侧标有正负号的滑动条：

将下来我们需要从每条音频的标题下拉菜单下选择“Mono”命令，将其转换成单声道格式，注意每一路都需要做这个转换：

现在我们可以选择“Project”菜单下的“Quick Mix”命令来完成单声道文件的混音：

通过上述的步骤，我们已经将立体声（Stereo）格式的声音数据转化成单声道（Mono）格式的声音数据，此外我们还需要设置相应的采样位数和采样频率。对于采样位数的设置，我们可以从每条音频的标题下拉菜单中选择“Set Sample Format”下的“16-bit”命令，将采样位数设置为16位：

而采样频率的设置则可以通过Auda对话框底部的“Project rate”进行设置，我们的WAV播放模块最高只支持22Khz：

所有参数都设置好之后，我们就可以导出所需要的声音文件了。选择“Edit”菜单下的“Preferences…”命令，在打开的对话框中从“Uncompressed Export”下拉框中选择“WAV (Microsoft 16 bit PCM)”后单击“Ok”按钮：

最后选择“File”菜单下的“Export As WAV…”命令，导出我们所需要的WAV文件就可以了，为了确保之后Arduino能够正常处理，该WAV文件需要用字母命名，并且文件名称不能超过8个字节。为了确保产生的文件是正确的，我们还可以在Windows中右键单击该文件后，从弹出的菜单中选择“属性”命令打开属性对话框，然后从“摘要”中检查生产的文件是否符合我们的要求：

生成的文件我们可以通过读卡器将其复制到SD卡中，为了保证读取的正确性，可以考虑先格式化后再将WAV文件复制到SD卡中。注意SD卡应该格式化成FAT格式的，而不要格式化成FAT32格式的。

带有WAV文件的SD卡准备好之后，我们可以用Arduino IDC扩展板将SD卡模块和WAV声音播放模块都连接到Arduino上：

通过Arduino皤放SD卡中存储的WAV文件我们需要用到wavehc库（http://code.google.com/p/wavehc/）。我们测试时使用的是wavehc20101009.zip这个文件，你可以通过wavehc的官方网站下载该文件，也可以通过这个地址直接下载我们在测试时使用的库文件包。

在将下载后的wavhc库解压缩之后，将压缩包中的WaveHC上当复制到Arduino安装目录中的libraries目录下。wavhc库默认使用了Arduino上的2、3、4、5这4个引脚，但 我们的Arduino IDC扩展板上的IDC-6座则是与Arduino的6、7、8、9这4个引脚相连接的，因此我们需要对WaveHC目录下的WavePinDefs.h这个文件进行修改， 相应的对应关系为2->9、3->7、4->6、5->8。你可以手工修改这个文件中以MCP_DAC_开头的那些宏定义，也可以直接下载我们已经修改好的WavePinDefs.h文件。

测试时我们使用的是wavhc库压缩包examples目录下的daphc，其实现的功能是不断从SD卡中查找以.WAV为扩展名的WAV文件进行播放，相应的代码为：

/*
 * This example plays every .WAV file it finds on the SD card in a loop
 */
#include "WaveHC.h"
#include "WaveUtil.h"

SdReader card;    // This object holds the information for the card
FatVolume vol;    // This holds the information for the partition on the card
FatReader root;   // This holds the information for the volumes root directory
WaveHC wave;      // This is the only wave (audio) object, since we will only play one at a time

uint8_t dirLevel; // indent level for file/dir names    (for prettyprinting)
dir_t dirBuf;     // buffer for directory reads

/*
 * Define macro to put error messages in flash memory
 */
#define error(msg) error_P(PSTR(msg))

// Function definitions (we define them here, but the code is below)
void play(FatReader &dir);

//////////////////////////////////// SETUP
void setup()
{
  Serial.begin(9600);           // set up Serial library at 9600 bps for debugging

  putstring_nl("\nWave test!");  // say we woke up!

  putstring("Free RAM: ");       // This can help with debugging, running out of RAM is bad
  Serial.println(FreeRam());

  //  if (!card.init(true)) { //play with 4 MHz spi if 8MHz isn't working for you
  if (!card.init()) {         //play with 8 MHz spi (default faster!)  
    error("Card init. failed!");  // Something went wrong, lets print out why
  }

  // enable optimize read - some cards may timeout. Disable if you're having problems
  card.partialBlockRead(true);

  // Now we will look for a FAT partition!
  uint8_t part;
  for (part = 0; part < 5; part++) {   // we have up to 5 slots to look in
    if (vol.init(card, part))
      break;                           // we found one, lets bail
  }
  if (part == 5) {                     // if we ended up not finding one   
    error("No valid FAT partition!");  // Something went wrong, lets print out why
  }

  // Lets tell the user about what we found
  putstring("Using partition ");
  Serial.print(part, DEC);
  putstring(", type is FAT");
  Serial.println(vol.fatType(),DEC);     // FAT16 or FAT32?

  // Try to open the root directory
  if (!root.openRoot(vol)) {
    error("Can't open root dir!");      // Something went wrong,
  }

  // Whew! We got past the tough parts.
  putstring_nl("Files found (* = fragmented):");

  // Print out all of the files in all the directories.
  root.ls(LS_R | LS_FLAG_FRAGMENTED);
}

//////////////////////////////////// LOOP
void loop()
{
  root.rewind();
  play(root);
}

/////////////////////////////////// HELPERS
/*
 * print error message and halt
 */
void error_P(const char *str)
{
  PgmPrint("Error: ");
  SerialPrint_P(str);
  sdErrorCheck();
  while(1);
}
/*
 * print error message and halt if SD I/O error, great for debugging!
 */
void sdErrorCheck(void)
{
  if (!card.errorCode()) return;
  PgmPrint("\r\nSD I/O error: ");
  Serial.print(card.errorCode(), HEX);
  PgmPrint(", ");
  Serial.println(card.errorData(), HEX);
  while(1);
}
/*
 * play recursively - possible stack overflow if subdirectories too nested
 */
void play(FatReader &dir)
{
  FatReader file;
  while (dir.readDir(dirBuf) > 0) {    // Read every file in the directory one at a time

    // Skip it if not a subdirectory and not a .WAV file
    if (!DIR_IS_SUBDIR(dirBuf)
         && strncmp_P((char *)&dirBuf.name[8], PSTR("WAV"), 3)) {
      continue;
    }

    Serial.println();            // clear out a new line

    for (uint8_t i = 0; i < dirLevel; i++) {
       Serial.print(' ');       // this is for prettyprinting, put spaces in front
    }
    if (!file.open(vol, dirBuf)) {        // open the file in the directory
      error("file.open failed");          // something went wrong
    }

    if (file.isDir()) {                   // check if we opened a new directory
      putstring("Subdir: ");
      printEntryName(dirBuf);
      dirLevel += 2;                      // add more spaces
      // play files in subdirectory
      play(file);                         // recursive!
      dirLevel -= 2;
    }
    else {
      // Aha! we found a file that isnt a directory
      putstring("Playing ");
      printEntryName(dirBuf);              // print it out
      if (!wave.create(file)) {            // Figure out, is it a WAV proper?
        putstring(" Not a valid WAV");     // ok skip it
      } else {
        Serial.println();                  // Hooray it IS a WAV proper!
        wave.play();                       // make some noise!

        uint8_t n = 0;
        while (wave.isplaying) {// playing occurs in interrupts, so we print dots in realtime
          putstring(".");
          if (!(++n % 32))Serial.println();
          delay(100);
        }
        sdErrorCheck();                    // everything OK?
        // if (wave.errors)Serial.println(wave.errors);     // wave decoding errors
      }
    }
  }
}

如果一切正常，此时你应该就能够在WAV声音播放模块上接的耳机或者音箱中听到你存储在SD卡中的WAV文件在播放时的效果了。上述Arduino代码在运行的时候会试图通过串口传输一些调试信息，必要的时候可以打开Arduino的串口来查看相应的原因（比如SD卡中没有正常找到）。

#include <Wire.h>
#define EEPROM_ADDR 0x50           // I2C Buss address of 24LC256 256K EEPROM

void setup()
{
  Wire.begin();                        // join I2C bus (address optional for master)
  Serial.begin(9600);

  // TESTS FOR EACH FUNCTION BEGIN HERE
  Serial.println("Writing Test:");
  for (int i=0; i<20; i++){            // loop for first 20 slots
    i2c_eeprom_write_byte(EEPROM_ADDR,i,i+65);   // write address + 65 A or 97 a
    Serial.print(". ");
    delay(10);                         // NEED THIS DELAY!
  }
  Serial.println("");
  delay(500);

  Serial.println("Reading Test:");
  for (int i=0; i<20; i++){            // loop for first 20 slots
    Serial.print(i2c_eeprom_read_byte(EEPROM_ADDR, i),BYTE);
    Serial.print(" ");
  }

  // setup for page tests . . .
  byte PageData[30];                   // array that will hold test data for a page
  byte PageRead[30];                   // array that will hold result of data for a page
  for (int i=0; i<30; i++){            // zero both arrays for next test
    PageData[i] = 0;
    PageRead[i] = 0;
  }
  Serial.println("");
  for (int i=0; i<30; i++) PageData[i] = i+33;  // fill up array for next test char 33 = !

  Serial.println("Writing Page Test:");
  i2c_eeprom_write_page(EEPROM_ADDR, 100, PageData, 28 ); // 28 bytes/page is max

  Serial.println("Reading Page Test:");
  i2c_eeprom_read_buffer( EEPROM_ADDR, 100, PageRead, 28);
  for (int i=0; i<28; i++){
    Serial.print(PageRead[i],BYTE);    // display the array read
    Serial.print(" ");
  }
}

void loop()
{
}

void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data )
{
  int rdata = data;
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));    // Address High Byte
  Wire.send((int)(eeaddress & 0xFF));  // Address Low Byte
  Wire.send(rdata);
  Wire.endTransmission();
}

// Address is a page address, 6-bit (63). More and end will wrap around
// But data can be maximum of 28 bytes, because the Wire library has a buffer of 32 bytes
void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length )
{
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddresspage >> 8)); // Address High Byte
  Wire.send((int)(eeaddresspage & 0xFF)); // Address Low Byte
  byte c;
  for ( c = 0; c < length; c++)
    Wire.send(data[c]);
  Wire.endTransmission();
  delay(10);                           // need some delay
}

byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress )
{
  byte rdata = 0xFF;
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));    // Address High Byte
  Wire.send((int)(eeaddress & 0xFF));  // Address Low Byte
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress,1);
  if (Wire.available()) rdata = Wire.receive();
  return rdata;
}

// should not read more than 28 bytes at a time!
void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length )
{
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));    // Address High Byte
  Wire.send((int)(eeaddress & 0xFF));  // Address Low Byte
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress,length);
  //int c = 0;
  for ( int c = 0; c < length; c++ )
    if (Wire.available()) buffer[c] = Wire.receive();
}

上述代码运行时的效果如下图所示：

DS1307是DALLAS公司的一款实时种芯片，采用I2C协议与单片机通讯，而Arduino上正好有这一接口，因此连接起来就非常方便了。DS1307中有一个可编程波形输出口，它可以用来驱动LED小灯，或者作为中断来触发某些事件，不过用它去带一些大功率的东西的时候要注意。我们设计的这一款实时钟模块，将Ds1307的I2C接口和可编程波形输出接口SQW都连接出来了，不过一般情况下我们只会用到I2C接口来实现基本的时钟设置/读取功能。需要注意的是，该模块必须先安装上电池才可以正常工作。电池使用的是纽扣电池（型号CR1220），正极朝上：

在电路连接上我们可以使用Arduino专用传感器扩展板V4，不过要将相应的跳线设置到IIC的位置上：

剩下的工作就是用4芯的I2C/COM连接线将传感器扩展板上的专用接口，与实时钟模块上的IIC（I2C其实就是IIC的缩写）端口连接起来了：

硬件连接的工作完成之后，如何在Arduino里对该模块进行编程呢？上网搜索了一下，发现在Arduino上使用DS1307做为时钟芯片的玩家还真不少，而且还封装好了相应的Arduino库，实验时我使用的是Google Code上的这个DS1307库，你也可以在这里下载到我使用的版本。将下载好的压缩文件解压缩到Arduino 0018的libraries目录下后，重新启动Arduino并用它自带的测试程序进行测试：

#include <WProgram.h>
#include <Wire.h>
#include <DS1307.h> // written by  mattt on the Arduino forum and modified by D. Sjunnesson

void setup()
{
  Serial.begin(9600);

  RTC.stop();
  RTC.set(DS1307_SEC,1);        //set the seconds
  RTC.set(DS1307_MIN,23);     //set the minutes
  RTC.set(DS1307_HR,12);       //set the hours
  RTC.set(DS1307_DOW,4);       //set the day of the week
  RTC.set(DS1307_DATE,15);       //set the date
  RTC.set(DS1307_MTH,7);        //set the month
  RTC.set(DS1307_YR,10);         //set the year
  RTC.start();

}

void loop()
{

  Serial.print(RTC.get(DS1307_HR,true)); //read the hour and also update all the values by pushing in true
  Serial.print(":");
  Serial.print(RTC.get(DS1307_MIN,false));//read minutes without update (false)
  Serial.print(":");
  Serial.print(RTC.get(DS1307_SEC,false));//read seconds
  Serial.print("      ");                 // some space for a more happy life
  Serial.print(RTC.get(DS1307_DATE,false));//read date
  Serial.print("/");
  Serial.print(RTC.get(DS1307_MTH,false));//read month
  Serial.print("/");
  Serial.print(RTC.get(DS1307_YR,false)); //read year 
  Serial.println();

  delay(1000);
}

程序读起来应该不算困难，基本上就是使用RTC.set来对时钟进行设置，然后就可以通过RTC.get来读取相应的时间信息了，至于时钟怎么维护，那就是 DS1307 的工作了:)

将程序下载到Arduino里并运行起来之后，就可以通过串口监控窗口来查看相应的输出结果了：
]]> http://blog.flamingoeda.com/2010/07/16/%e7%94%b5%e5%ad%90%e7%a7%af%e6%9c%a8-%e5%ae%9e%e6%97%b6%e9%92%9f%e6%a8%a1%e5%9d%97-rtc-ds1307/feed/ 0 http://blog.flamingoeda.com/2010/07/06/%e7%94%b5%e5%ad%90%e7%a7%af%e6%9c%a8-%e6%97%a0%e7%ba%bf%e6%95%b0%e4%bc%a0%e6%a8%a1%e5%9d%97-apc220/ http://blog.flamingoeda.com/2010/07/06/%e7%94%b5%e5%ad%90%e7%a7%af%e6%9c%a8-%e6%97%a0%e7%ba%bf%e6%95%b0%e4%bc%a0%e6%a8%a1%e5%9d%97-apc220/#comments Tue, 06 Jul 2010 10:24:00 +0000 flamingoeda http://blog.flamingoeda.com/?p=594 在使用APC220实现Arduino无线数据传输那篇文章里，我们介绍了如何使用APC220模块在PC和Arduino间实现无线数据传输。那时我们使用的是厂家提供的USB适配器。，由于这个适配器只能接APC220模块，而不能起到其它的作用，或多或少觉得有些浪费。更加重要的是，为此我们得提供两个不同的套件，一个给Arduino使用，一个给PC使用，两者之间不能实现互换。

正是基于上面的这些问题，我们针对电子积木系列开发了一款USB转串口的适配器Serial Dongle，使用它就可以通过PC机来连接和使用各种基于串口的电子积木模块了，比如这里介绍的无线数传模块APC220。

APC220模块的使用可以参考使用APC220实现Arduino无线数据传输那篇文章，两者间的唯一区别只在于如何对USB虚拟出来的串口进行设置，以便能够使用厂家提供的设置程序RF-ANET来对APC220的各个参数进行调整。首先我们将USB转串口适配器Serial Dongle连接到PC机上，然后从设备管理器中找到该串口，并打开其属性设置窗口：

点击Advanced按钮打开高级属性设置窗口，我们需要从Com Port Number列表中为Serial Dongle设置一个较小的COM号（如COM5），否则厂家给的设置程序会出现无法打开该串口的错识。另一个需要修改的地方是BM Options中的延时设置需要从16改为更小的值（如8）：

现在可以运行厂家给的设置程序了，此时特别需要注意的是操作顺序。应该先接好Serial Dongle，并将Serial Dongle右上角的开关拨到M的位置：

接着运行设置程序RF-ANET，最后再用连接线将APC220模块连接到Serial Dongle上，此时应该可以看到APC220设置程序窗口的最下面会显示Found device，表明APC220模块已经成功找到。如果设置程序没有找到APC220模块，可以试着断开APC220与Serial Dongle的连接，然后再次将APC220模块连接到SerialDongle上，直到设置程序成功找到APC220模块。

当APC220模块成功地被设置程序RF-ANET找到之后，我们就可以按照实际的需要来使用Serial Dongle对APC220模块进行各种参数配置了，而不再依赖厂家提供的USB适配器了;-)

至于随后的使用过程，那就完全一致了。一方面，我们可以将APC220模块通过4芯的串口连接线，与Arduino传感器扩展板相连接，这样Arduino就可以通过串口来操作APC220模块实现无线数据的收发：

另一方面，我们可以通过Serial Dongle连接APC220模块与电脑，并通过电脑的串口读写功能来操作APC220模块实现无线数据的收发：

下图就是利用两个APC220模块实现Arduino与电脑间无线数据传输的连接图：

针对硬件上的需求，我们开发了SD卡模块，它通过SPI接口与Arduino进行通信：

同时，为了方便同Arduino的SPI接口进行连接，提供了相应的IDC扩展板，该扩展板上有一个专门为SPI设计的六芯插座：

电路的连接上则依然沿用了电子积木所一向强调的即插即用方式，我们只需要用6芯的IDC连接线，将IDC扩展板上的SPI插座与SD卡模块上的相应插座连接起来，就完成了电路部分的连接：

回到软件部分，我们的目标是要让SD卡上记录的数据能够在电脑上顺利地读出，因此在向SD卡上记录相应数据的时候需要遵循一定的规定，即文件系统的类型。对于像Arduino这样的小系统来讲，相对简单的FAT16是一个比较不错的选择。

在这里我们要用到读卡器来对SD卡进行相应的处理，将其格式化成FAT文件系统：

Arduino上使用的软件则是基于SparkFun提供的FAT库，但根据硬件差异做了一定的修改，你可以从这里下载到修改过的FAT库。该库需要被解压缩到Arduino的hardware\libraries子目录中。

测试时使用的时FAT库里自带的示例程序：

//Include all the libraries necessary for FAT32
#include <byteordering.h>
#include <fat.h>
#include <FAT16.h>
#include <fat_config.h>
#include <partition.h>
#include <partition_config.h>
#include <sd-reader_config.h>
#include <sd_raw.h>
#include <sd_raw_config.h>

FAT TestFile;      //This will be the file we manipulate in the sketch
char buffer[512];  //Data will be temporarily stored to this buffer before being written to the file
int read_size=0;   //Used as an indicator for how many characters are read from the file
int count=0;       //Miscellaneous variable

void setup()
{
  Serial.begin(9600);  //Initiate serial communication at 9600 bps

  TestFile.initialize();  //Initialize the SD card and the FAT file system.
  Serial.println("Starting...");
  TestFile.create_file("Sample.txt");  //Create a file on the SD card named "Read_File_Test.txt"
                                       //NOTE: This function will return a 0 value if it was unable to create the file.
  TestFile.open();  //Now that the file has been created, open it so we can write to it.
}

void loop()
{
  TestFile.write("This is test data.");  //using the write function will always write to the beginning of the file. 
                                         // Here we add some text to the file.
  TestFile.close();  //We are done writing to the file for now. Close it for later use.

  while(1){
    TestFile.open();  //Open the file. When the file is opened we will be looking at the beginning of the file.
    read_size=TestFile.read(buffer); //Read the contents of the file. This will only read the amount of data specified
                                    // by the size of 'buffer.'

    Serial.println(read_size, DEC);  //Print the number of characters read by the read function.
    for(int i=0; iSerial.print(buffer[i], BYTE);  //Print out the contents of the buffer.
    }
    Serial.println();

    sprintf(buffer, "%d", count++); //Now we'll use the buffer to write data back to the file. 
                                   // Here's we'll only add one value to buffer, the 'count' variable. 
    TestFile.write(buffer);         //Write the new buffer to the end of the file
    TestFile.close();               //Close the file for later use.

    delay(1000);  //Wait one second before repeating the loop.
  }
}

这样Arduino在运行的时候，会不断地向SD卡模块上的Sample.txt文件中写入相应的数据，随后我们同样可以通过读卡器读出该文件中记录的内容。

需要注意的是，由于用来操作SD卡和文件系统的代码相对较多，目前该模块只能运行在带有ATmega328P的Arduino上面。另外，目前市场上可选的SD卡种类繁多，可能不是每种SD卡都能够被很好的兼容，目前我测试过通过的SD卡有：

• SanDisk 2GB SD2 Card
• Apacer 60X 1GB SD Card

测试没有通过的SD卡有：

• SanDisk 16MB SD Card