// If Serial moniter Used!
while (!SerialUSB);

// setup() is the first function executed when you plug you board
// or when you reset it. This funcion runs once
void setup() {
// The pinMode sets digital pin 13 as an Output
pinMode(13, OUTPUT);
}

// After the setup() function, the loop runs over and over
// until you stop the board
void loop() {
digitalWrite(13, HIGH); // turn the LED on setting the pin 13 to HIGH
delay(1000);// wait for a second
digitalWrite(13, LOW); // turn the LED off setting the pin 13 to LOW
delay(1000);// wait for a second
}

Source Code1 : Blink

***********************************************************************
* This sketch demonstrate how to use alarm in interrupt mode.
This mode is more conveniently because you use processor for other tasks and when alarm match occurs interrupt routine is executed.
In this way, alarm flag checking is indipendent from main program flow.
***********************************************************************
//*RTC Alarm in interrupt mode*/
#include <RTCInt.h> //include RTCint library

RTCInt rtc; //create an RTCInt type object
int buzzer=11; //connect the buzzer to digital pin 11
int red=12; //connect red led to digital pin 12
int green=13; //connect green led to digital pin 13
/*setup*/
void setup()
{
SerialUSB.begin(9600); //serial communication initializing
pinMode(green,OUTPUT); //define green as output
pinMode(red,OUTPUT); //define red as output
pinMode(buzzer,OUTPUT); //define buzzer as output
digitalWrite(green,LOW); //initialize the green to LOW level
digitalWrite(red,LOW); //initialize the green to LOW level
rtc.begin(TIME_H24); //RTC initializing with 24 hour representation mode
rtc.setTime(17,0,5,0); //setting time (hour minute and second)
rtc.setDate(13,8,15); //setting date
rtc.enableAlarm(SEC,ALARM_INTERRUPT,alarm_int); //enabling alarm in interrupt mode
rtc.local_time.hour=17; //setting hour alarm
rtc.local_time.minute=1; //setting minute alarm
rtc.local_time.second=10; //setting second to match
rtc.setAlarm(); //write second in alarm register
}
/*loop*/
void loop()
{ noTone(buzzer); // disable the buzzer
digitalWrite(green,HIGH); //turn on green led
delay(500); //wait 500 millisecond
}

*************** Interrupt routine for alarm ******************************
void alarm_int(void)
{
SerialUSB.println(“Alarm match!”);
for(int i=0; i < 30; i++)
{ digitalWrite(green,LOW); //turn off green led
tone(buzzer,200); //play buzzer
digitalWrite(red,HIGH); //turn on red green
for(int j=0; j < 1000000; j++)
asm(“NOP”); //in interrupt routine you cannot use delay function then an alternative is NOP instruction cicled many time as you need
digitalWrite(red,LOW); //turn off red green italWrite(13,LOW);
for(int j=0; j < 2000000; j++)
asm(“NOP”);
}
RTC->MODE2.INTFLAG.bit.ALARM0=1; //clearing alarm0 flag
}

- Source Code2 : RTC Alarm Clock

/*
Simple Audio Player for Arduino Zero

Demonstrates the use of the Audio library for the Arduino Zero

Hardware required :
* Arduino shield with a SD card on CS4
* A sound file named “test.wav” in the root directory of the SD card
* An audio amplifier to connect to the DAC0 and ground
* A speaker to connect to the audio amplifier

Arturo Guadalupi <a.guadalupi@arduino.cc>
Angelo Scialabba <a.scialabba@arduino.cc>
Claudio Indellicati <c.indellicati@arduino.cc>

This example code is in the public domain

http://arduino.cc/en/Tutorial/SimpleAudioPlayerZero
*/

/*
Modify 2016.2.29 By D.H.Kim SD Memory Card Interface

[SD CARD]—-[ARDUINO]
9: NC —–
1: CS —–D4
2: DI <—-MOSI(84)
3: VSS1—–GND(86)
4: VDD —–3.3V
5: CLK <—-CLK(83)
6: VSS2—–GND(86)
7: DO —->MISO(81)
8: NC —–
*/

#include <SD.h>
#include <SPI.h>
#include <AudioZero.h>

void setup()
{
// debug output at 115200 baud
SerialUSB.begin(115200);

//Wait until USB CDC port connects
while(!SerialUSB);

// setup SD-card
SerialUSB.print(“Initializing SD card…”);
if (!SD.begin(4)) {
SerialUSB.println(“ failed!”);
while(true);
}
SerialUSB.println(“ done.”);

// 44100kHz stereo => 88200 sample rate
AudioZero.begin(44100);
}

void loop()
{
int count = 0;

// open wave file from sdcard
File myFile = SD.open(“test.wav”);
if (!myFile) {
// if the file didn’t open, print an error and stop
SerialUSB.println(“error opening test.wav”);
while (true);
}

SerialUSB.print(“Playing”);

// until the file is not finished
AudioZero.play(myFile);

SerialUSB.println(“End of file. Thank you for listening!”);
//while (true) ;
}

- Source Code3 : WAV File 출력

/*
leo_usb2serial
아두이노 M0를 활용한 USB to Serial Bridge
자료참고 : https://petervanhoyweghen.wordpress.com/2012/11/08/
using-the-leonardo-as-usb-to-serial-converter/
*/
static long baud = 57600;
static long newBaud = baud;

// this pin will output the DTR signal (as set by the pc)
#define DTR_PIN 13

#define LINESTATE_DTR 1

void lineCodingEvent(long baud, byte databits, byte parity, byte charFormat)
{
newBaud = baud;
}

void lineStateEvent(unsigned char linestate)
{
if(linestate & LINESTATE_DTR)
digitalWrite(DTR_PIN, HIGH);
else
digitalWrite(DTR_PIN, LOW);
}

void setup() {
pinMode(DTR_PIN, OUTPUT);
digitalWrite(DTR_PIN, LOW);

Serial5.begin(baud);
SerialUSB.begin(baud);

//Wait until USB CDC port connects
while(!SerialUSB){};
}

void loop() {

// Set the new baud rate
if(newBaud != baud) {
baud = newBaud;
SerialUSB.end();
SerialUSB.begin(baud);
}

//Copy byte incoming via TTL serial
if (Serial5.available()) {
char c = (char)Serial5.read();
SerialUSB.write(c);
}

//Copy byte incoming via CDC serial
if (SerialUSB.available()) {
char c = (char)SerialUSB.read();
Serial5.write(c);
}
}

- Source Code4 : USB 2 SERIAL

//Define the Temperature Sensor Pin
#define ADCVREF 3.3f
#define ADCMAXCOUNT 4096.0f
#define ADCVDIV 1.0f
#define ADCACCUR (ADCVREF / ADCMAXCOUNT) // 0.00080566
#define ADCRESOLUTION 12

int sensorPin = A0;
int inTmp;

/********************************************************************
* Function Name: int lowPassFilter2(int adVal)
* Return Value:
* Parameters:
* Description: 제1차 저주파 필터로 여러 함수에서 공통적으로 사용될 수 있으므로 구조체를
* 통해 접근이 이뤄지도록 한다.
*
* NOTE: http://wlsgk123123.blog.me/
********************************************************************/
#define LPFALPHA 0.95f
int lowPassFilter2(int adVal)
{
static float xLFP;
static float prevX;
static unsigned short firstRun;

if (firstRun == 0){
// 필터가 호출되면 처음 실행되는 부분으로 함수 내부의 변수들을 초기화 한다.
prevX = 0;
firstRun = 1;
}
// 이전 값에다 현재 값의 LPFALPHA 만큼을 더한 값이 최종 현재 값이 된다. 즉, 이전 값과 현재 값의 일정 퍼센트 만을 더해 현재 값을 생성해 내는 방식으로 필터링 한다.
xLFP = (LPFALPHA * prevX) + (1 – LPFALPHA) * (float)adVal;
prevX = xLFP;
return (unsigned int)prevX; // 정수값 만을 반환 시킨다.
}

/*
-AR_DEFAULT: the default analog reference are 5V or 3.3V;
-AR_INTERNAL: an built-in reference, equal to 1 volts
-AR_EXTERNAL: use as reference the voltage applied to AREF pin in the range 0-5V only.
*/
void setup() {
//Start Serial connection to read results in Serial Monitor
SerialUSB.begin(9600);
analogReadResolution(ADCRESOLUTION);
analogReference(AR_DEFAULT);
}

void loop() {
int lpfVar;
int adVal;
float rawADVoltage;
signed int adcMiliVolts;
signed int miliRealTemp;

//Get the sensor raw reading
//then convert it from a
// 10bit: 0 to 1023 digital range(1step = 0.00322)
// 12bit: 0 to 4095 digital range(1step = 0.0008056)
// 만일 12bit모드면 [21.9℃] 는 888이 읽힌다
// 888 = 0.719v / 0.0008056
adVal = analogRead(sensorPin);

// A/D채널을 읽어
lpfVar = lowPassFilter2(adVal); // 저역통과필터

// A/D변환 결과를 Voltage로 변환 시킨다.
// 이때 절사가 일어나 0.1도의 편차가 발생한다.
rawADVoltage = (float)lpfVar * ADCACCUR * ADCVDIV;

// Voltage를 MCP9700의 온도값 형태인 mV로 변환 시켜준다.
// 719.00 = (0.719 * 10000) / 10
adcMiliVolts = rawADVoltage * 1000.0f;

// MCP9700스타일의 온도를 섭씨 형태로 변환 시켜준다.
// 이때 온도는 219 = 719 – 500
miliRealTemp = adcMiliVolts – 500;

//Convert the raw value to Celsius
//temperature = (temperature – .5) * 100;

SerialUSB.print(adVal); SerialUSB.print(“, “);
SerialUSB.print(lpfVar); SerialUSB.print(“, “);
//SerialUSB.print(rawADVoltage); SerialUSB.print(“, “);
//SerialUSB.print(adcMiliVolts); SerialUSB.print(“, “);
SerialUSB.println(miliRealTemp);

//Print the temperature value to Serial Monitor
//SerialUSB.println(voltage);

//Read the temperature each second
delay(10);
}

- Source Code5 : 12Bit ADC

/********************************************************************
* Copyright (C) 2011 – 2014 Bosch Sensortec GmbH
*
* Usage: Example code to stream Accelerometer data
*
* License:
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of the
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* The information provided is believed to be accurate and reliable.
* The copyright holder assumes no responsibility for the consequences of use
* of such information nor for any infringement of patents or
* other rights of third parties which may result from its use.
* No license is granted by implication or otherwise under any patent or
* patent rights of the copyright holder.
*/

/*
9축모션쉴드를 테스트해보기 위해 만들어진 프로그램
*동작시키는 방법*
1. Serial Osciloscope 프로그램을 아래 주소에서 다운로드 받는다.
( http://www.x-io.co.uk/serial-oscilloscope/ )
2. 아래 3개 파트로 나뉘어진 주석을 한 영역씩만 풀어가며 아두이노-m0로 내려 보낸다.
3. Serial Osciloscope로 데이터가 들어오면 첫번째 데이터는 적색,
두번째 데이터는 녹색, 세번째는 청색으로 그래프가 그려진다.
4. 결과 : 가가속도 센서에서는 피치(X축), 롤(Y축) 정보가 잘 얻어 짐을 알 수 있다.
*/

//Contains the bridge code between the API and the Arduino Environment
#include “NAxisMotion.h”
#include <Wire.h>

//Object that for the sensor
NAxisMotion mySensor;

//To store the last streamed time stamp
unsigned long lastStreamTime = 0;

//To stream at 25Hz without using additional timers
//(time period(ms) =1000/frequency(Hz))
const int streamPeriod = 40;

//Flag to update the sensor data
//Default is true to perform the first read before the first stream
bool updateSensorData = true;

//This code is executed once
void setup() {
//Peripheral Initialization

//Initialize the Serial Port
//to view information on the Serial Monitor
SerialUSB.begin(115200);

while(!SerialUSB);

//Initialize I2C communication to the let the
//library communicate with the sensor.
I2C.begin();

//Sensor Initialization
//The I2C Address can be changed here
//inside this function in the library
mySensor.initSensor();

//Can be configured to other operation modes as desired
mySensor.setOperationMode(OPERATION_MODE_NDOF);

//The default is AUTO
//Changing to manual requires calling the relevant
//update functions prior to calling the read functions
mySensor.setUpdateMode(MANUAL);
//Setting to MANUAL requires lesser reads to the sensor

mySensor.updateAccelConfig();
updateSensorData = true;

SerialUSB.println();
SerialUSB.println(“Default accelerometer configuration settings…”);
SerialUSB.print(“Range: “);
SerialUSB.println(mySensor.readAccelRange());
SerialUSB.print(“Bandwidth: “);
SerialUSB.println(mySensor.readAccelBandwidth());
SerialUSB.print(“Power Mode: “);
SerialUSB.println(mySensor.readAccelPowerMode());

//Countdown
SerialUSB.println(“Streaming in …”);
SerialUSB.print(“3…”);
delay(1000); //Wait for a second
SerialUSB.print(“2…”);
delay(1000); //Wait for a second
SerialUSB.println(“1…”);
delay(1000); //Wait for a second
}

void loop() { //This code is looped forever
//Keep the updating of data as a separate task
if (updateSensorData) {
//Update the Accelerometer data
mySensor.updateAccel();
//Update the Linear Acceleration data
mySensor.updateLinearAccel();
//Update the Gravity Acceleration data
mySensor.updateGravAccel();
//Update the Calibration Status
mySensor.updateCalibStatus();
updateSensorData = false;
}
if ((millis() – lastStreamTime) >= streamPeriod) {
lastStreamTime = millis();
//Accelerometer X-Axis data : 적색그래프
SerialUSB.print(“ aX: “);
SerialUSB.print(mySensor.readAccelX());
SerialUSB.print(“m/s2, “);

//Accelerometer Y-Axis data : 녹색그래프
SerialUSB.print(“ aY: “);
SerialUSB.print(mySensor.readAccelY());
SerialUSB.print(“m/s2, “);

//Accelerometer Z-Axis data : 청색그래프
SerialUSB.print(“ aZ: “);
SerialUSB.print(mySensor.readAccelZ());
SerialUSB.print(“m/s2, “);

SerialUSB.println();
updateSensorData = true;
}
}

- Source Code5 : 가속도센서 테스트