From: root Date: Sun, 15 Feb 2015 16:46:42 +0000 (+0100) Subject: Initial Commit X-Git-Url: http://git.piffa.net/web?a=commitdiff_plain;h=5b737b67e45cd2ad8243f968667f75cbcc6cab63;p=sketchbook_andrea_bak Initial Commit Sun Feb 15 17:46:58 CET 2015 From Conny. --- 5b737b67e45cd2ad8243f968667f75cbcc6cab63 diff --git a/README b/README new file mode 100644 index 0000000..e2a6dec --- /dev/null +++ b/README @@ -0,0 +1,21 @@ +Andrea's Sketchbook +===================== + +Esempi per i corsi su Arduino. +Le ultime versioni sono disponibili su: git.andreamanni.com + +Per aggiornare il proprio archivio: +cd sketchbook_andrea/ ; git fetch + + +Note +------ + +- head_tails_ino +Is the code example of C book for control structures (IF) + +- loop_match_2_ino +Is the code example of C book for iterative structures (while - for loop) + + +>-- Copyright note: all these is released into the Public Domain --< diff --git a/RGB_LED/README b/RGB_LED/README new file mode 100644 index 0000000..133660a --- /dev/null +++ b/RGB_LED/README @@ -0,0 +1,2 @@ +Ottima lezione in italiano: +- http://www.maffucci.it/2014/09/27/arduino-lezione-09-uso-di-led-rgb-parte-1/ diff --git a/RGB_LED/RGB_PWM/RGB_PWM.ino b/RGB_LED/RGB_PWM/RGB_PWM.ino new file mode 100644 index 0000000..9563785 --- /dev/null +++ b/RGB_LED/RGB_PWM/RGB_PWM.ino @@ -0,0 +1,60 @@ +// This is meant for a Common Anodote RGB LED +// See all those (255 - val). + +#define GREEN 9 +#define BLUE 10 +#define RED 11 +#define delayTime 20 + +void setup() { + + pinMode(GREEN, OUTPUT); + pinMode(BLUE, OUTPUT); + pinMode(RED, OUTPUT); + digitalWrite(GREEN, HIGH); + digitalWrite(BLUE, HIGH); + digitalWrite(RED, HIGH); +} + +int redVal; +int blueVal; +int greenVal; + +void loop() { + + int redVal = 255; + int blueVal = 0; + int greenVal = 0; + for( int i = 0 ; i < 255 ; i += 1 ){ + greenVal += 1; + redVal -= 1; + analogWrite( GREEN, 255 - greenVal ); + analogWrite( RED, 255 - redVal ); + + delay( delayTime ); + } + + redVal = 0; + blueVal = 0; + greenVal = 255; + for( int i = 0 ; i < 255 ; i += 1 ){ + blueVal += 1; + greenVal -= 1; + analogWrite( BLUE, 255 - blueVal ); + analogWrite( GREEN, 255 - greenVal ); + + delay( delayTime ); + } + + redVal = 0; + blueVal = 255; + greenVal = 0; + for( int i = 0 ; i < 255 ; i += 1 ){ + redVal += 1; + blueVal -= 1; + analogWrite( RED, 255 - redVal ); + analogWrite( BLUE, 255 - blueVal ); + + delay( delayTime ); + } +} diff --git a/RGB_LED/rgb_all_color/rgb_all_color.ino b/RGB_LED/rgb_all_color/rgb_all_color.ino new file mode 100644 index 0000000..29969ad --- /dev/null +++ b/RGB_LED/rgb_all_color/rgb_all_color.ino @@ -0,0 +1,45 @@ + /* + Adafruit Arduino - Lesson 3. RGB LED + */ + + int redPin = 11; + int greenPin = 10; + int bluePin = 9; + + //uncomment this line if using a Common Anode LED + //#define COMMON_ANODE + + void setup() + { + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(bluePin, OUTPUT); + } + + void loop() + { + setColor(255, 0, 0); // red + delay(1000); + setColor(0, 255, 0); // green + delay(1000); + setColor(0, 0, 255); // blue + delay(1000); + setColor(255, 255, 0); // yellow + delay(1000); + setColor(80, 0, 80); // purple + delay(1000); + setColor(0, 255, 255); // aqua + delay(1000); + } + + void setColor(int red, int green, int blue) + { + #ifdef COMMON_ANODE + red = 255 - red; + green = 255 - green; + blue = 255 - blue; + #endif + analogWrite(redPin, red); + analogWrite(greenPin, green); + analogWrite(bluePin, blue); + } diff --git a/advanced_projects/LCD_clock/LCD_working_0/LCD_working_0.ino b/advanced_projects/LCD_clock/LCD_working_0/LCD_working_0.ino new file mode 100644 index 0000000..bc6e95c --- /dev/null +++ b/advanced_projects/LCD_clock/LCD_working_0/LCD_working_0.ino @@ -0,0 +1,23 @@ +// Chapter 7: Arduino Alarm Clock +// An alarm clock that uses the Adafruit Industries DS1307 RTC Breakout board +// and a 16 x 2 Parallel LCD Display +#include // I2C Wire Library for communicating with the DS1307 RTC +#include "RTClib.h" // Date and time functions for the DS1307 RTC connected +#include // Display functions for the LCD Display +RTC_DS1307 rtc; // Create a realtime clock called rtc +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Create an LCD called lcd + + +void setup () { + Wire.begin(); // Enables the communication for the LCD + rtc.begin(); // Enables the RTC + lcd.begin(16, 2); // Enables the LCD + + lcd.print(" It's Alive!"); // Print a message, centered, to the LCD to confirm it's working + delay(500); // Wait a moment so we can read it + lcd.clear(); // Clear the LCD +} +void loop(){ + +} + diff --git a/advanced_projects/LCD_clock/display_time_1/display_time_1.ino b/advanced_projects/LCD_clock/display_time_1/display_time_1.ino new file mode 100644 index 0000000..9208552 --- /dev/null +++ b/advanced_projects/LCD_clock/display_time_1/display_time_1.ino @@ -0,0 +1,53 @@ +// Chapter 7: Arduino Alarm Clock +// An alarm clock that uses the Adafruit Industries DS1307 RTC Breakout board +// and a 16 x 2 Parallel LCD Display +#include // I2C Wire Library for communicating with the DS1307 RTC +#include "RTClib.h" // Date and time functions for the DS1307 RTC connected +#include // Display functions for the LCD Display +RTC_DS1307 rtc; // Create a realtime clock called rtc +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Create an LCD called lcd + +DateTime now; // Time object + +void setup () { + Wire.begin(); // Enables the communication for the LCD + rtc.begin(); // Enables the RTC + lcd.begin(16, 2); // Enables the LCD + + lcd.print(" It's Alive!"); // Print a message, centered, to the LCD to confirm it's working + delay(500); // Wait a moment so we can read it + lcd.clear(); // Clear the LCD +} +void loop(){ + now = rtc.now(); // Get the current time + // Refresh the display + updateDisplay(); +} + +void updateDisplay(){ + int h = now.hour(); // Get the hours right now and store them in an integer called h + int m = now.minute(); // Get the minutes right now and store them in an integer called m + int s = now.second(); // Get the seconds right now and store them in an integer called s + lcd.setCursor(0, 0); // Set the cursor at the column zero, upper row... + lcd.print(" The time is: "); // ...with spaces to clear characters from setting alarm. + lcd.setCursor(4, 1); // Move the cursor to column four, lower row + if (h<10){ // Add a zero, if necessary, as above + lcd.print(0); + } + lcd.print(h); // Display the current hour + lcd.setCursor(6, 1); // Move to the next column + lcd.print(":"); // And print the colon + lcd.setCursor(7, 1); // Move to the next column + if (m<10){ // Add a zero, if necessary, as above + lcd.print(0); + } + lcd.print(m); // Display the current minute + lcd.setCursor(9, 1); // Move to the next column + lcd.print(":"); // And print the colon + lcd.setCursor(10, 1); // Move to the next column + if (s<10){ // Add a zero, if necessary, as above + lcd.print(0); + } + lcd.print(s); // Display the current second +} + diff --git a/advanced_projects/README b/advanced_projects/README new file mode 100644 index 0000000..27913a9 --- /dev/null +++ b/advanced_projects/README @@ -0,0 +1,7 @@ +This examples are taken from the book: += Arduino Projects For Dummies + ISBN: 978-1-118-55147-9 + +Codes and schematics are available from: +http://www.dummies.com/store/product/Arduino-Projects-For-Dummies.productCd-1118551478,navId-322496,descCd-DOWNLOAD.html +/ Downloads. diff --git a/advanced_projects/kit_knight_rider_10LED_array_iteration_1/kit_knight_rider_10LED_array_iteration_1.ino b/advanced_projects/kit_knight_rider_10LED_array_iteration_1/kit_knight_rider_10LED_array_iteration_1.ino new file mode 100644 index 0000000..d612db0 --- /dev/null +++ b/advanced_projects/kit_knight_rider_10LED_array_iteration_1/kit_knight_rider_10LED_array_iteration_1.ino @@ -0,0 +1,84 @@ +/* Arduino Projects for Dummies + * by Brock Craft + * + * Chapter 4: The All-Seeing Eye + * Sequentially lights up a series of LEDs + * + * v0.3 02.02.2015 + * Changed delayTime variable so that is is consistent with the + * text of the book. (Used to be timeDelay.) + * v0.2 03.07.2013 + * Fixed error: timeChanged = millis(); not within if loop brackets + */ + +// A variable to set a delay time between each LED +int delayTime = 50; + +// A variable to store which LED we are currently working on +int currentLED = 0; + +// A variable to store the direction of travel of LEDs +int dir = 1; + +// A variable to store the last time we changed something +unsigned long timeChanged = 0; + +// Create an array to hold the value for each LED pin +byte ledPin[] = { + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; + +void setup() { + // Set all pins for OUTPUT with a counter + for (int x=0; x<10; x++) { + pinMode(ledPin[x], OUTPUT); + } + + // Set all pins for OUTPUT iterating a pointer + // byte *ptr = ledPin ; + // while (*ptr) { + // pinMode(*ptr++, OUTPUT); + // } + + // Set up the + timeChanged = millis(); +} + +void loop() { + // Check whether it has been long enough + if ((millis() - timeChanged) > delayTime) { + // Turn off all of the LEDs, see next comment + for (int x=0; x<10; x++) { + digitalWrite(ledPin[x], LOW); + } + // Turning off just one LED instead on 10 would be more efficient + // digitalWrite(ledPin[currentLED - dir], LOW); + + // Turn on the current LED + digitalWrite(ledPin[currentLED], HIGH); + + // Increment by the direction value + currentLED += dir; + + // If we are at the end of a row, change direction + if (currentLED == 9) { + dir = -1; + } + if (currentLED == 0) { + dir = 1; + } + + // Let's change the speed wit a Pot on pin A5 + // delayTime = map(analogRead(5),0,1024,20,5 00); + // delay(2); + + // Store the current time as the time we last changed LEDs + timeChanged = millis(); + } +} + + + + + + + diff --git a/advanced_projects/kit_knight_rider_10LED_array_iteration_1/schema.png b/advanced_projects/kit_knight_rider_10LED_array_iteration_1/schema.png new file mode 100644 index 0000000..99f077a Binary files /dev/null and b/advanced_projects/kit_knight_rider_10LED_array_iteration_1/schema.png differ diff --git a/basic/TO_DO b/basic/TO_DO new file mode 100644 index 0000000..bd449fb --- /dev/null +++ b/basic/TO_DO @@ -0,0 +1,10 @@ +Sketch 8: Sketch con 4 modi per il LED: + +1. OFF +2. ON +3. Blink +4. Fast Blink + + +Si potrebbe fare con una struttura switch per attivare il modo, +valutare se usare un array per iterare tra i modi. diff --git a/basic/button_presses_LED_6/button_presses_LED_6.ino b/basic/button_presses_LED_6/button_presses_LED_6.ino new file mode 100644 index 0000000..771bbcc --- /dev/null +++ b/basic/button_presses_LED_6/button_presses_LED_6.ino @@ -0,0 +1,31 @@ +/* + * Alternating switch + */ + +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status +int buttonState; // variable to hold the last button state +int lightMode = 0; // State of the light +int LED = 12; + +void setup() { + pinMode(switchPin, INPUT_PULLUP); // Set the switch pin as input + pinMode(LED, OUTPUT); + + buttonState = digitalRead(switchPin); // read the initial state + +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + delay(100); // Debounce + if ((val != buttonState) && (val == HIGH)) { // check if the button is pressed + lightMode = 1 -lightMode ; + } + digitalWrite(LED,lightMode); + buttonState = val; // save the new state in our variable +} + + + diff --git a/basic/button_presses_LED_blinking_deBounce_8/button_presses_LED_blinking_deBounce_8.ino b/basic/button_presses_LED_blinking_deBounce_8/button_presses_LED_blinking_deBounce_8.ino new file mode 100644 index 0000000..3116b42 --- /dev/null +++ b/basic/button_presses_LED_blinking_deBounce_8/button_presses_LED_blinking_deBounce_8.ino @@ -0,0 +1,50 @@ +/* + * Turn on / off LED with a switch. + When the lightmode is on the LED Blinks + */ + +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status +int valBounce ; // variable for debouncing +int buttonState; // variable to hold the last button state +int lightMode = 0; // State of the light +int LED = 12; + +void setup() { + pinMode(switchPin, INPUT_PULLUP); // Set the switch pin as input + pinMode(LED, OUTPUT); + + buttonState = digitalRead(switchPin); // read the initial state + +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + delay(10); // Debounce + valBounce = digitalRead(switchPin); // read input value and store it in val + + if ((val == valBounce) && (val != buttonState) && (val == HIGH)) { // check if the button is pressed + lightMode = 1 -lightMode ; // Now with DeBounce + } + if (lightMode) { // Check if light mode is TRUE == 1 or FALSE == 0 + delay(50); // Keep the LED LOW for 50ms + digitalWrite(LED,HIGH); // Blink the LED + delay(50); // Keep the LED HIGH for 50ms + // digitalWrite(LED,LOW); // We don't need to turn it LOW + // It will go off anyway later + } + + digitalWrite(LED,LOW); // Almayes turn off the LED + // As lightMode is FALSE == 0 turn the LED off + // Turn it off + buttonState = val; // save the new state in our variable +} + + + + + + + + diff --git a/basic/button_presses_LED_deBounce_7/button_presses_LED_deBounce_7.ino b/basic/button_presses_LED_deBounce_7/button_presses_LED_deBounce_7.ino new file mode 100644 index 0000000..1e0e203 --- /dev/null +++ b/basic/button_presses_LED_deBounce_7/button_presses_LED_deBounce_7.ino @@ -0,0 +1,35 @@ +/* + * Alternating switch + */ + +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status +int valBounce ; // variable for debouncing +int buttonState; // variable to hold the last button state +int lightMode = 0; // State of the light +int LED = 12; + +void setup() { + pinMode(switchPin, INPUT_PULLUP); // Set the switch pin as input + pinMode(LED, OUTPUT); + + buttonState = digitalRead(switchPin); // read the initial state + +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + delay(10); // Debounce + valBounce = digitalRead(switchPin); // read input value and store it in val + + if ((val == valBounce) && (val != buttonState) && (val == HIGH)) { // check if the button is pressed + lightMode = 1 -lightMode ; // Now with DeBounce + } + digitalWrite(LED,lightMode); + buttonState = val; // save the new state in our variable +} + + + + diff --git a/basic/button_presses_count_down_5/button_presses_count_down_5.ino b/basic/button_presses_count_down_5/button_presses_count_down_5.ino new file mode 100644 index 0000000..7e43837 --- /dev/null +++ b/basic/button_presses_count_down_5/button_presses_count_down_5.ino @@ -0,0 +1,36 @@ +/* + * Alternating switch + */ + +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status +int buttonState; // variable to hold the last button state +int buttonPresses = 10; // Counter for the button + +void setup() { + pinMode(switchPin, INPUT_PULLUP); // Set the switch pin as input + + Serial.begin(9600); // Set up serial communication at 9600bps + buttonState = digitalRead(switchPin); // read the initial state + Serial.println("Don not press the button! :P "); +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + delay(100); // Debounce + if ((val != buttonState) && (val == HIGH)) { // check if the button is pressed + buttonPresses-- ; + Serial.print("Press it an other "); + Serial.print(buttonPresses); + Serial.println(" times."); + } + if (buttonPresses == 0) { + Serial.println("----- > ExplOdE! <------"); + // Serial.flush(); // Print out the whole serial buffer + // exit(0); // Exit the sketch + } + buttonState = val; // save the new state in our variable +} + + diff --git a/basic/button_presses_counter_AND_4/button_presses_counter_AND_4.ino b/basic/button_presses_counter_AND_4/button_presses_counter_AND_4.ino new file mode 100644 index 0000000..6f5c373 --- /dev/null +++ b/basic/button_presses_counter_AND_4/button_presses_counter_AND_4.ino @@ -0,0 +1,30 @@ +/* + * Alternating switch + */ + +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status +int buttonState; // variable to hold the last button state +int buttonPresses = 0; // Counter for the button + +void setup() { + pinMode(switchPin, INPUT_PULLUP); // Set the switch pin as input + + Serial.begin(9600); // Set up serial communication at 9600bps + buttonState = digitalRead(switchPin); // read the initial state +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + delay(100); // Debounce + if ((val != buttonState) && (val == HIGH)) { // check if the button is pressed + buttonPresses++ ; + Serial.print("Button has been pressed "); + Serial.print(buttonPresses); + Serial.println(" times."); + } + buttonState = val; // save the new state in our variable +} + + diff --git a/basic/button_state_3/button_state_3.ino b/basic/button_state_3/button_state_3.ino new file mode 100644 index 0000000..de29a13 --- /dev/null +++ b/basic/button_state_3/button_state_3.ino @@ -0,0 +1,29 @@ +/* + * Alternating switch + */ + +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status +int buttonState; // variable to hold the last button state + +void setup() { + pinMode(switchPin, INPUT); // Set the switch pin as input + + Serial.begin(9600); // Set up serial communication at 9600bps + buttonState = digitalRead(switchPin); // read the initial state +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + + if (val != buttonState) { // the button state has changed! + if (val == LOW) { // check if the button is pressed + Serial.println("Button just pressed"); + } else { // the button is -not- pressed... + Serial.println("Button just released"); + } + } + + buttonState = val; // save the new state in our variable +} diff --git a/basic/data_types_bin_hex_transformation_serial/data_types_bin_hex_transformation_serial.ino b/basic/data_types_bin_hex_transformation_serial/data_types_bin_hex_transformation_serial.ino new file mode 100644 index 0000000..a02701e --- /dev/null +++ b/basic/data_types_bin_hex_transformation_serial/data_types_bin_hex_transformation_serial.ino @@ -0,0 +1,40 @@ +void setup() { + // put your setup code here, to run once: + Serial.begin(9600); + +} + +void loop() { + + transforma(5); // Leggete i risultati con [CTR]+[SHIFT]+M + transforma(255); + + Serial.flush() ; + exit(0); // Termina l'esecuzione +} + +// Ignorate pure il resto del listato! + +/* Transforma + + Scrive su seriale il valore della variabile a + trasformandolo in binario e esadecimale + */ + +void transforma(int var) { + Serial.print("Valore in decimanle = "); + Serial.println(var); // Serial.println(a, DEC); + + Serial.print("Valore in binario = "); + Serial.println(var,BIN); + + Serial.print("Valore in esadecimanle = "); + Serial.println(var,HEX); + + Serial.println(); +} + + + + + diff --git a/basic/led_PWM_simple/led_PWM_simple.ino b/basic/led_PWM_simple/led_PWM_simple.ino new file mode 100644 index 0000000..45d3ff9 --- /dev/null +++ b/basic/led_PWM_simple/led_PWM_simple.ino @@ -0,0 +1,27 @@ +/* + Adafruit Arduino - Lesson 3. RGB LED + */ + +int redPin = 11; +int greenPin = 10; +int bluePin = 9; +int c = 0; + +//uncomment this line if using a Common Anode LED +//#define COMMON_ANODE + +void setup() +{ + pinMode(redPin, OUTPUT); + +} + +void loop() +{ + for ( c = 0; c < 255 ; c++) { + analogWrite(redPin, c) ; + delay(5 ); + } +} + + diff --git a/basic/simplest_pwm_byte/simplest_pwm_byte.ino b/basic/simplest_pwm_byte/simplest_pwm_byte.ino new file mode 100644 index 0000000..fc7658d --- /dev/null +++ b/basic/simplest_pwm_byte/simplest_pwm_byte.ino @@ -0,0 +1,27 @@ +/* + Fade + + This example shows how to fade an LED on pin 9 + using the analogWrite() function. + + This example code is in the public domain. + */ + +byte led = 9 ; // the pin that the LED is attached to + +byte brightness = 0; // how bright the LED is + +// the setup routine runs once when you press reset: +void setup() { + // declare pin 9 to be an output: + pinMode(led, OUTPUT); +} + +// the loop routine runs over and over again forever: +void loop() { + // set the brightness of pin 9: + analogWrite(led, brightness++); + delay(10); +} + + diff --git a/basic/switch_LED_2/switch_LED_2.ino b/basic/switch_LED_2/switch_LED_2.ino new file mode 100644 index 0000000..8141ad0 --- /dev/null +++ b/basic/switch_LED_2/switch_LED_2.ino @@ -0,0 +1,24 @@ +/* + * Switch and LED test program + */ + +int ledPin = 12; // LED is connected to pin 12 +int switchPin = 2; // switch is connected to pin 2 +int val; // variable for reading the pin status + + +void setup() { + pinMode(ledPin, OUTPUT); // Set the LED pin as output + pinMode(switchPin, INPUT); // Set the switch pin as input +} + + +void loop(){ + val = digitalRead(switchPin); // read input value and store it in val + if (val == LOW) { // check if the button is pressed + digitalWrite(ledPin, HIGH); // turn LED on + } + if (val == HIGH) { // check if the button is not pressed + digitalWrite(ledPin, LOW); // turn LED off + } +} diff --git a/basic/switch_test_serial/switch_test_serial.ino b/basic/switch_test_serial/switch_test_serial.ino new file mode 100644 index 0000000..9fa2b7d --- /dev/null +++ b/basic/switch_test_serial/switch_test_serial.ino @@ -0,0 +1,19 @@ +/* + * Switch test program + */ + +int switchPin = 2; // Switch connected to digital pin 2 + +void setup() // run once, when the sketch starts +{ + Serial.begin(9600); // set up Serial library at 9600 bps + pinMode(switchPin, INPUT); // sets the digital pin as input to read switch +} + + +void loop() // run over and over again +{ + Serial.print("Read switch input: "); + Serial.println(digitalRead(switchPin)); // Read the pin and display the value + delay(200); +} diff --git a/basic_programming/blink_with_functions/blink_with_functions.ino b/basic_programming/blink_with_functions/blink_with_functions.ino new file mode 100644 index 0000000..f798b46 --- /dev/null +++ b/basic_programming/blink_with_functions/blink_with_functions.ino @@ -0,0 +1,52 @@ +/* + Blink con funzioni. + + Le funzioni sono una sequenza di istruzione raggruppate appunto in un a funzione. + Le funzioni possono accettare argomenti e avere questi pre-impostati a valori di default se omessi. + Le funzioni possono limitarsi a svolgere istruzionioppure elaborare valori restituendo un risultato. + + */ + +// Pin 13 has an LED connected on most Arduino boards. +// give it a name: +int led = 13; +void lunga() { + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(1000); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(1000); // wait for a second +} + +void breve() { + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(200); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(1000); // wait for a second + +} + +void varia(int a = 1000) { // Varia has a default value, the user can override it with an argument + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(a); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(1000); // wait for a second + +} + +// the setup routine runs once when you press reset: +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); +} + +// the loop routine runs over and over again forever: +void loop() { + lunga() ; + lunga() ; + breve(); + breve(); + varia(3000); + + +} + diff --git a/basic_programming/conditional_test/head_tails_ino/head_tails_ino.ino b/basic_programming/conditional_test/head_tails_ino/head_tails_ino.ino new file mode 100644 index 0000000..7587967 --- /dev/null +++ b/basic_programming/conditional_test/head_tails_ino/head_tails_ino.ino @@ -0,0 +1,61 @@ +/* + Head tails + Generates a random number in order to simulate a coin toss. + + + Phisical LEDS and serial debug. + + This example code is in the public domain. + */ + +// Pin 13 has an LED connected on most Arduino boards. +// give it a name: +const int head = 13 ; // LED for HEAD +const int tail = 12 ; // LEAD for Tails +const int PAUSE = 1000 ; +const int REST = 50 ; +long randomNumber = 0L; // Use the "L" to tell compiler it's a long data type, not an int. +int hCount = 0; +int tCount = 0; +int runs = 0 ; + +// the setup routine runs once when you press reset: +void setup() { + // initialize the digital pin as an output. + pinMode(head, OUTPUT); + pinMode(tail, OUTPUT); + randomSeed(analogRead(0)); // Random initializer + Serial.begin(9600); + Serial.println("Initializing random sequence, please wait for results."); +} + +// the loop routine runs over and over again forever: +void loop() { + randomNumber = random(); + digitalWrite(head, LOW); + digitalWrite(tail, LOW); + delay(REST); // wait a bit + if (randomNumber % 2 == 1) { + digitalWrite(head, HIGH);// turn the LED on ON + hCount++ ; + } + else { + digitalWrite(tail, HIGH);// turn the LED ON + tCount++ ; + } + + delay(PAUSE); // Long pause + runs++; + + if (runs % 10 == 0) { // Each 10 runs print a summary to serial + Serial.print("Results after more 10 runs, for a total of: "); + Serial.println(runs); + Serial.print("Tails: \t") ; + Serial.println(tCount); + Serial.print("Heads: \t"); + Serial.println(hCount); + } +} + + + diff --git a/basic_programming/leap_year_functions/leap_year_functions.ino b/basic_programming/leap_year_functions/leap_year_functions.ino new file mode 100644 index 0000000..befac46 --- /dev/null +++ b/basic_programming/leap_year_functions/leap_year_functions.ino @@ -0,0 +1,80 @@ +/** + * Program: find out is the user typed in a leap year. The code assumes + * the user is not an idiot and only types in numbers that are a valid + * year. + * Author: Dr. Purdum, Aug. 7, 2012 + **/ +void setup() +{ + Serial.begin(9600); +} +void loop() +{ + if (Serial.available() > 0) { + int bufferCount; + int year; + char myData[20]; + bufferCount = ReadLine(myData); + year = atoi(myData); + Serial.print("Year: "); + Serial.print(year); + if (IsLeapYear(year)) { + Serial.print(" is "); + } + else { + Serial.print(" is not "); + } + Serial.println("a leap year"); + } +} +// Convert to int +/***** + * Purpose: Determine if a given year is a leap year + * Parameters: + * int yr + * The year to test + * Return value: + * int + * 1 if the year is a leap year, 0 otherwise + *****/ +int IsLeapYear(int yr) +{ + if (yr % 4 == 0 && yr % 100 != 0 || yr % 400 == 0) { + return 1; // It is a leap year + } + else { + return 0; + // not a leap year + } +} +/***** + * Purpose: Read data from serial port until a newline character is read ('\n') + * Parameters: + * char str[] + * character array that will be treated as a nul-terminated string + * Return value: + * int + * the number of characters read for the string + * CAUTION: This method will sit here forever if no input is read from the serial + * port and no newline character is entered. + ****/ +int ReadLine(char str[]) +{ + char c; + int index = 0; + while (true) { + if (Serial.available() > 0) { + c = Serial.read(); + if (c != '\n') { + str[index++] = c; + } + else { + str[index] = '\0'; // null termination character + break; + } + } + } + return index; +} + + diff --git a/basic_programming/loops/loop_match_2_for_loop/loop_match_2_for_loop.ino b/basic_programming/loops/loop_match_2_for_loop/loop_match_2_for_loop.ino new file mode 100644 index 0000000..22fe8bf --- /dev/null +++ b/basic_programming/loops/loop_match_2_for_loop/loop_match_2_for_loop.ino @@ -0,0 +1,64 @@ +/* Exercise 2, with a WHILE loop + Test a random number agains a value + Light a led in case + Light the other LED if a run of 255 test has gone + Log the results (if success) trough serialport + */ + +// Data structure + +const byte GREEN = 13 ; // LED for found value +const byte RED = 12 ; // LEAD for restart + +const int TARGET = 200 ; +long randomNumber = 0L; + +// Staff +const int WAIT = 1000 ; +const int REST = 10 ; +byte count = 0 ; +const byte MAXRUN = 10 ; +byte totalRun = 0 ; + +void setup() { + pinMode(RED,OUTPUT); + pinMode(GREEN,OUTPUT); + // Serial stuff + Serial.begin(9600); + Serial.println("Initializing random sequence, please wait for results."); + + // Random stuff + randomSeed(analogRead(0)); // Random initializer + +} + +void loop() { // put your main code here, to run repeatedly: + digitalWrite(GREEN, LOW); + digitalWrite(RED, LOW); + // Serial.println(count); + + for (count == 0; count < 255; count++ , delay(REST)) { + randomNumber = random(0,255); //Randoom value generated + if (randomNumber == TARGET) { // When we catch the value + Serial.print("--> Match found! Counter was at: "); // serial message + Serial.println(count); + digitalWrite(GREEN, HIGH); + delay(WAIT * 5); + digitalWrite(GREEN, LOW); + count++ ; + } + } + + Serial.println("Counter resetted."); // serial staff + digitalWrite(RED, HIGH); + delay(WAIT); + count++ ; + totalRun++ ; + if (totalRun == MAXRUN) { + Serial.println("10 runs done, exit program."); + digitalWrite(RED, HIGH); + delay(WAIT); + exit(0); + } +} + diff --git a/basic_programming/loops/loop_match_2_while_loop/loop_match_2_while_loop.ino b/basic_programming/loops/loop_match_2_while_loop/loop_match_2_while_loop.ino new file mode 100644 index 0000000..88c515c --- /dev/null +++ b/basic_programming/loops/loop_match_2_while_loop/loop_match_2_while_loop.ino @@ -0,0 +1,67 @@ +/* Exercise 2, with a WHILE loop + Test a random number agains a value + Light a led in case + Light the other LED if a run of 255 test has gone + Log the results (if success) trough serialport + */ + +// Data structure + +const byte GREEN = 13 ; // LED for found value +const byte RED = 12 ; // LEAD for restart + +const int TARGET = 200 ; +long randomNumber = 0L; + +// Staff +const int WAIT = 1000 ; +const int REST = 10 ; +byte count = 0 ; +const byte MAXRUN = 10 ; +byte totalRun = 0 ; + +void setup() { + pinMode(RED,OUTPUT); + pinMode(GREEN,OUTPUT); + // Serial stuff + Serial.begin(9600); + Serial.println("Initializing random sequence, please wait for results."); + + // Random stuff + randomSeed(analogRead(0)); // Random initializer + +} + +void loop() { // put your main code here, to run repeatedly: + digitalWrite(GREEN, LOW); + digitalWrite(RED, LOW); + // Serial.println(count); + + while (count < 255) { + randomNumber = random(0,255); //Randoom value generated + if (randomNumber == TARGET) { // When we catch the value + Serial.print("--> Match found! Counter was at: "); // serial message + Serial.println(count); + digitalWrite(GREEN, HIGH); + delay(WAIT); + count++ ; + } + //Serial.println(count); + count++ ; + delay(REST); + } + + + Serial.println("Counter resetted."); // serial staff + digitalWrite(RED, HIGH); + delay(WAIT); + count++ ; + totalRun++ ; + if (totalRun == MAXRUN) { + Serial.println("10 runs done, exit program."); + digitalWrite(RED, HIGH); + delay(WAIT); + exit(0); + } +} + diff --git a/basic_programming/loops/switch_loop_README b/basic_programming/loops/switch_loop_README new file mode 100644 index 0000000..8143081 --- /dev/null +++ b/basic_programming/loops/switch_loop_README @@ -0,0 +1,6 @@ +Use examples provided with arduino: + +EDIT -> Example -> Control -> ... + +- SwitchCase: check the range of a (mapped) analog input with a switch loop. +- SwitchCase2: SerialInput to light up a bunch of LEDS. diff --git a/basic_programming/pointers_c/pointers/pointers.ino b/basic_programming/pointers_c/pointers/pointers.ino new file mode 100644 index 0000000..b148b70 --- /dev/null +++ b/basic_programming/pointers_c/pointers/pointers.ino @@ -0,0 +1,45 @@ + +int *ptrNumber ; +void setup() { + // put your setup code here, to run once: + Serial.begin(9600); + +} + +void loop() { + int number = 5; + + + Serial.print("number is "); + Serial.println(number); + Serial.print("The lvalue for number is: "); + Serial.println((long) &number, DEC); + + Serial.print("---- Pointer was "); + Serial.println(*ptrNumber); + Serial.print("The lvalue for ptrNumber is: "); + Serial.println((long) &ptrNumber, DEC); + Serial.print(" and the rvalue is "); + Serial.println((long) ptrNumber, DEC); + + ptrNumber = &number ; + Serial.println("Assigned!"); + + Serial.print("===== Pointer was "); + Serial.println(*ptrNumber); + Serial.print("The lvalue for ptrNumber is: "); + Serial.println((long) &ptrNumber, DEC); + Serial.print(" and the rvalue is "); + Serial.println((long) ptrNumber, DEC); + + *ptrNumber = 6 ; + Serial.print("**** Pointer value is: "); + Serial.println(*ptrNumber); + Serial.println(number); + + Serial.flush(); + exit(0); + +} + + diff --git a/basic_programming/pointers_c/pointers_3_resetting_before_use/pointers_3_resetting_before_use.ino b/basic_programming/pointers_c/pointers_3_resetting_before_use/pointers_3_resetting_before_use.ino new file mode 100644 index 0000000..02642eb --- /dev/null +++ b/basic_programming/pointers_c/pointers_3_resetting_before_use/pointers_3_resetting_before_use.ino @@ -0,0 +1,49 @@ +/* +Purpose: Illustrate pointer arithmetic + Dr. Purdum, August 20, 2012 + */ +#include +void setup() { + Serial.begin(9600); +} +void loop() { + char buffer[50]; + char *ptr; + int i; + int length; + + strcpy(buffer, "When in the course of human events"); + ptr = buffer; + length = strlen(buffer); + Serial.print("The lvalue for ptr is: "); + Serial.print((unsigned int)&ptr); + Serial.print(" and the rvalue is "); + Serial.println((unsigned int)ptr); + while (*ptr) { + Serial.print(*ptr++); // This actually incrementa ptr* + 34 + } + Serial.println(""); + + Serial.println("Lenght of the string is: "); + Serial.println(length); + Serial.println(""); + + + // ptr = ptr - length ; // Whis would roll back ptr + for (i = 0; i < length; i++) { + Serial.print(*(ptr + i)); + // Serial.print(*(ptr + i- lenght)); // ptr is one lenght up ahead + } + // ptr = buffer ; // Right thing to do: reset the pointer before use + // for (i = 0; i < length; i++) { + // Serial.print(*(ptr + i)) + + + Serial.flush(); + // Make sure all the data is sent... + exit(0); +} + + + + diff --git a/basic_programming/pointers_c/pointers_function_scope_break/pointers_function_scope_break.ino b/basic_programming/pointers_c/pointers_function_scope_break/pointers_function_scope_break.ino new file mode 100644 index 0000000..1a0ad0a --- /dev/null +++ b/basic_programming/pointers_c/pointers_function_scope_break/pointers_function_scope_break.ino @@ -0,0 +1,41 @@ +int *ptr; // no rvalue + +void setup() { + // put your setup code here, to run once: + Serial.begin(9600); + +} + +void loop() { + int num =5; + ptr = &num ; + + transforma(num); // Leggete i risultati con [CTR]+[SHIFT]+M + Serial.println(num); + + Serial.flush() ; + exit(0); // Termina l'esecuzione +} + +// Ignorate pure il resto del listato! + +/* Transforma + + Scrive su seriale il valore della variabile a + trasformandolo in binario e esadecimale + */ + +void transforma(int var) { + Serial.print("Valore della variabile = "); + Serial.print(var); + *ptr = 12 ; // Num is outside the scope of this function + // but a pointer can get there + + + Serial.println(); +} + + + + + diff --git a/basic_programming/pointers_c/structure_pointers_function_stack_4/structure_pointers_function_stack_4.ino b/basic_programming/pointers_c/structure_pointers_function_stack_4/structure_pointers_function_stack_4.ino new file mode 100644 index 0000000..2ebc909 --- /dev/null +++ b/basic_programming/pointers_c/structure_pointers_function_stack_4/structure_pointers_function_stack_4.ino @@ -0,0 +1,47 @@ + + +struct RGB { + byte r; + byte g; + byte b; +} +myLED ; + +void setup() { + Serial.begin(9600); + // Serial link to PC +} +void loop() { + myLED = { + 100,200,255 } + ; + + // Serial.println(myLED.r) ; + + illumina(&myLED); + rossa(&myLED); + Serial.println(); + illumina(&myLED); + + Serial.flush(); + exit(0); +} + +void illumina(struct RGB *tempLED) { // Function with a pointer + Serial.println((*tempLED).r) ; // This does not waste STACK space + Serial.println((*tempLED).g) ; // Note: indirect operator * has lower priority + Serial.println(tempLED->b) ; // than dot . operator , so the parentheses + // That is the dereference -> operator +} + +struct RGB rossa(struct RGB *temp) { // Function with a pointer: + // This can change directly the original value without the need + // to reassign as in: myLED = rossa(myLED) + (*temp).r = 255 ; + //return *temp; +} + + + + + diff --git a/hardware/Infrared_controller/IR_reading_mapped/IR_reading_mapped.ino b/hardware/Infrared_controller/IR_reading_mapped/IR_reading_mapped.ino new file mode 100644 index 0000000..ae7e8b2 --- /dev/null +++ b/hardware/Infrared_controller/IR_reading_mapped/IR_reading_mapped.ino @@ -0,0 +1,58 @@ +// Remote infrared control +// http://www.instructables.com/id/Arduino-Infrared-Remote-tutorial/ + +// Requires library: https://github.com/shirriff/Arduino-IRremote +// Numbers 1->6 mapped with a switch construct +// +// Warning: DO NOT coonect the IR sensor to the Arduino without +// the PCB module + +#include +#include + +int RECV_PIN = 11; +IRrecv irrecv(RECV_PIN); +decode_results results; + +void setup() +{ + Serial.begin(9600); + irrecv.enableIRIn(); // Start the receiver +} + +void loop() +{ + if (irrecv.decode(&results)) + { + switch (results.value) { + case 0xFF30CF: + Serial.println("Uno"); + break; + case 0xFF18E7: + Serial.println("Due"); + break; + case 0xFF7A85: + Serial.println("Tre"); + break; + case 0xFF10EF: + Serial.println("Quattro"); + break; + case 0xFF38C7: + Serial.println("Cinque"); + break; + case 0xFF5AA5: + Serial.println("Sei"); + break; + case 0xFFFFFFFF: + Serial.println("Repeat"); + } + //Serial.println(results.value, HEX); // Debug: show value + irrecv.resume(); // Receive the next value + + } +} + + + + + diff --git a/hardware/Infrared_controller/basic_IR_reading_0/basic_IR_reading_0.ino b/hardware/Infrared_controller/basic_IR_reading_0/basic_IR_reading_0.ino new file mode 100644 index 0000000..380f8ff --- /dev/null +++ b/hardware/Infrared_controller/basic_IR_reading_0/basic_IR_reading_0.ino @@ -0,0 +1,33 @@ +// Remote infrared control +// http://www.instructables.com/id/Arduino-Infrared-Remote-tutorial/ + +// Requires library: https://github.com/shirriff/Arduino-IRremote +// Warning: DO NOT coonect the IR sensor to the Arduino without +// the PCB module + +#include +#include + +int RECV_PIN = 11; +IRrecv irrecv(RECV_PIN); +decode_results results; + +void setup() +{ + Serial.begin(9600); + irrecv.enableIRIn(); // Start the receiver +} + +void loop() +{ + if (irrecv.decode(&results)) + { + Serial.println(results.value, HEX); + if (results.value == 0xFF30CF) { + Serial.println("Uno"); + } + irrecv.resume(); // Receive the next value + } +} + + diff --git a/hardware/LCD_2x16/LCD_2x16.ino b/hardware/LCD_2x16/LCD_2x16.ino new file mode 100644 index 0000000..e11a48c --- /dev/null +++ b/hardware/LCD_2x16/LCD_2x16.ino @@ -0,0 +1,20 @@ +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // Print a message to the LCD. + lcd.print("Funziona benone!"); +} + +void loop() { + // set the cursor to column 0, line 1 + // (note: line 1 is the second row, since counting begins with 0): + lcd.setCursor(0, 1); + // print the number of seconds since reset: + lcd.print(millis()/1000); +} + diff --git a/hardware/LCD_display_4x20/LCD_display_4x20.ino b/hardware/LCD_display_4x20/LCD_display_4x20.ino new file mode 100644 index 0000000..4dce1f9 --- /dev/null +++ b/hardware/LCD_display_4x20/LCD_display_4x20.ino @@ -0,0 +1,58 @@ +/* + LiquidCrystal Library - Hello World + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints "Hello World!" to the LCD + and shows the time. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * LCD D4 pin to digital pin 5 + * LCD D5 pin to digital pin 4 + * LCD D6 pin to digital pin 3 + * LCD D7 pin to digital pin 2 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + Library originally added 18 Apr 2008 + by David A. Mellis + library modified 5 Jul 2009 + by Limor Fried (http://www.ladyada.net) + example added 9 Jul 2009 + by Tom Igoe + modified 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystal + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(7, 8, 9, 10, 11, 12); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(20, 4); + // Print a message to the LCD. + lcd.print("Schermo LCD a 4righe per 20 caratteri. Funziona anche bene."); +} + +void loop() { + // set the cursor to column 0, line 1 + // (note: line 1 is the second row, since counting begins with 0): + lcd.setCursor(5, 4); + // print the number of seconds since reset: + //lcd.print(millis()/1000); +} + diff --git a/hardware/ethernet/README b/hardware/ethernet/README new file mode 100644 index 0000000..ac494cc --- /dev/null +++ b/hardware/ethernet/README @@ -0,0 +1,9 @@ +Info +==== + + +- https://hwstartup.wordpress.com/2013/03/25/how-to-connect-an-arduino-to-the-internet-for-10/ +- http://www.homautomation.org/2014/10/27/how-to-choose-the-right-library-to-add-ethernet-enc28j60-to-your-arduino/ + +This NIC should also work with KSduino: +- http://blog.ksduino.org/post/37480815224/welcome-to-ksduino diff --git a/hardware/ethernet/ethernet_analog_read/ethernet_analog_read.ino b/hardware/ethernet/ethernet_analog_read/ethernet_analog_read.ino new file mode 100644 index 0000000..35314dd --- /dev/null +++ b/hardware/ethernet/ethernet_analog_read/ethernet_analog_read.ino @@ -0,0 +1,69 @@ +/* + Analog read + + Read a value from a Arduino sensor and publish + it in a web page. + + Note: you can set up the NIC with DHCP or static address + + */ + +#include + +// ethernet interface mac address, must be unique on the LAN +static byte mymac[] = { + 0x74,0x69,0x69,0x2D,0x30,0x31 }; +//static byte myip[] = { 192,168,0,100 }; + +byte Ethernet::buffer[500]; +BufferFiller bfill; + +// Analog vars: +int analogSensor = A0; +int sensorRead = 0; + +void setup () { + /* Static IP code + if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) + Serial.println( "Failed to access Ethernet controller"); + ether.staticSetup(myip); + + + + */ + // DHC code + Serial.begin(57600); + Serial.println("\n[getDHCPandDNS]"); + if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) + Serial.println( "Failed to access Ethernet controller"); + + if (!ether.dhcpSetup()) + Serial.println("DHCP failed"); +} + +static word homePage() { + bfill = ether.tcpOffset(); + bfill.emit_p(PSTR( + "HTTP/1.0 200 OK\r\n" + "Content-Type: text/html\r\n" + "Pragma: no-cache\r\n" + "\r\n" + "" + "Arduino WebServer" + "

Arduino analog Read

" + "

Analog Value from Arduino: $D

"), + sensorRead ); + return bfill.position(); +} + +void loop () { + sensorRead = analogRead(analogSensor); + + word len = ether.packetReceive(); + word pos = ether.packetLoop(len); + + if (pos) // check if valid tcp data is received + ether.httpServerReply(homePage()); // send web page data +} + + diff --git a/hardware/ethernet/ethernet_hello_world/ethernet_hello_world.ino b/hardware/ethernet/ethernet_hello_world/ethernet_hello_world.ino new file mode 100644 index 0000000..0b81959 --- /dev/null +++ b/hardware/ethernet/ethernet_hello_world/ethernet_hello_world.ino @@ -0,0 +1,38 @@ +// This is a demo of the RBBB running as webserver with the Ether Card +// Simple Hello World + +#include + +// ethernet interface mac address, must be unique on the LAN +static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 }; +static byte myip[] = { 192,168,0,100 }; + +byte Ethernet::buffer[500]; +BufferFiller bfill; + +void setup () { + if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) + Serial.println( "Failed to access Ethernet controller"); + ether.staticSetup(myip); +} + +static word homePage() { + bfill = ether.tcpOffset(); + bfill.emit_p(PSTR( + "HTTP/1.0 200 OK\r\n" + "Content-Type: text/html\r\n" + "Pragma: no-cache\r\n" + "\r\n" + "" + "RBBB server" + "

Hello World 2

")); + return bfill.position(); +} + +void loop () { + word len = ether.packetReceive(); + word pos = ether.packetLoop(len); + + if (pos) // check if valid tcp data is received + ether.httpServerReply(homePage()); // send web page data +} diff --git a/hardware/ethernet/ethernet_time/ethernet_time.ino b/hardware/ethernet/ethernet_time/ethernet_time.ino new file mode 100644 index 0000000..8fabce3 --- /dev/null +++ b/hardware/ethernet/ethernet_time/ethernet_time.ino @@ -0,0 +1,48 @@ +//#include +//#include +//#include + +// This is a demo of the RBBB running as webserver with the Ether Card +// 2010-05-28 http://opensource.org/licenses/mit-license.php + // https://hwstartup.wordpress.com/2013/03/25/how-to-connect-an-arduino-to-the-internet-for-10/ + +#include + +// ethernet interface mac address, must be unique on the LAN +static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 }; +static byte myip[] = { 192,168,0,100 }; + +byte Ethernet::buffer[500]; +BufferFiller bfill; + +void setup () { + if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) + Serial.println( "Failed to access Ethernet controller"); + ether.staticSetup(myip); +} + +static word homePage() { + long t = millis() / 1000; + word h = t / 3600; + byte m = (t / 60) % 60; + byte s = t % 60; + bfill = ether.tcpOffset(); + bfill.emit_p(PSTR( + "HTTP/1.0 200 OK\r\n" + "Content-Type: text/html\r\n" + "Pragma: no-cache\r\n" + "\r\n" + "" + "RBBB server" + "

$D$D:$D$D:$D$D

"), + h/10, h%10, m/10, m%10, s/10, s%10); + return bfill.position(); +} + +void loop () { + word len = ether.packetReceive(); + word pos = ether.packetLoop(len); + + if (pos) // check if valid tcp data is received + ether.httpServerReply(homePage()); // send web page data +} diff --git a/hardware/gyro_6axis/gyro_6axis.ino b/hardware/gyro_6axis/gyro_6axis.ino new file mode 100644 index 0000000..c65f0d5 --- /dev/null +++ b/hardware/gyro_6axis/gyro_6axis.ino @@ -0,0 +1,375 @@ +// 6 axis gyro demo +// Beware: this does not work on old Uno, requires a r3. + +// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class using DMP (MotionApps v2.0) +// 6/21/2012 by Jeff Rowberg +// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib +// +// Changelog: +// 2013-05-08 - added seamless Fastwire support +// - added note about gyro calibration +// 2012-06-21 - added note about Arduino 1.0.1 + Leonardo compatibility error +// 2012-06-20 - improved FIFO overflow handling and simplified read process +// 2012-06-19 - completely rearranged DMP initialization code and simplification +// 2012-06-13 - pull gyro and accel data from FIFO packet instead of reading directly +// 2012-06-09 - fix broken FIFO read sequence and change interrupt detection to RISING +// 2012-06-05 - add gravity-compensated initial reference frame acceleration output +// - add 3D math helper file to DMP6 example sketch +// - add Euler output and Yaw/Pitch/Roll output formats +// 2012-06-04 - remove accel offset clearing for better results (thanks Sungon Lee) +// 2012-06-01 - fixed gyro sensitivity to be 2000 deg/sec instead of 250 +// 2012-05-30 - basic DMP initialization working + +/* ============================================ +I2Cdev device library code is placed under the MIT license +Copyright (c) 2012 Jeff Rowberg + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +=============================================== +*/ + +// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files +// for both classes must be in the include path of your project +#include "I2Cdev.h" + +#include "MPU6050_6Axis_MotionApps20.h" +//#include "MPU6050.h" // not necessary if using MotionApps include file + +// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation +// is used in I2Cdev.h +#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE + #include "Wire.h" +#endif + +// class default I2C address is 0x68 +// specific I2C addresses may be passed as a parameter here +// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board) +// AD0 high = 0x69 +MPU6050 mpu; +//MPU6050 mpu(0x69); // <-- use for AD0 high + +/* ========================================================================= + NOTE: In addition to connection 3.3v, GND, SDA, and SCL, this sketch + depends on the MPU-6050's INT pin being connected to the Arduino's + external interrupt #0 pin. On the Arduino Uno and Mega 2560, this is + digital I/O pin 2. + * ========================================================================= */ + +/* ========================================================================= + NOTE: Arduino v1.0.1 with the Leonardo board generates a compile error + when using Serial.write(buf, len). The Teapot output uses this method. + The solution requires a modification to the Arduino USBAPI.h file, which + is fortunately simple, but annoying. This will be fixed in the next IDE + release. For more info, see these links: + + http://arduino.cc/forum/index.php/topic,109987.0.html + http://code.google.com/p/arduino/issues/detail?id=958 + * ========================================================================= */ + + + +// uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual +// quaternion components in a [w, x, y, z] format (not best for parsing +// on a remote host such as Processing or something though) +//#define OUTPUT_READABLE_QUATERNION + +// uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles +// (in degrees) calculated from the quaternions coming from the FIFO. +// Note that Euler angles suffer from gimbal lock (for more info, see +// http://en.wikipedia.org/wiki/Gimbal_lock) +//#define OUTPUT_READABLE_EULER + +// uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/ +// pitch/roll angles (in degrees) calculated from the quaternions coming +// from the FIFO. Note this also requires gravity vector calculations. +// Also note that yaw/pitch/roll angles suffer from gimbal lock (for +// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock) +#define OUTPUT_READABLE_YAWPITCHROLL + +// uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration +// components with gravity removed. This acceleration reference frame is +// not compensated for orientation, so +X is always +X according to the +// sensor, just without the effects of gravity. If you want acceleration +// compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead. +//#define OUTPUT_READABLE_REALACCEL + +// uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration +// components with gravity removed and adjusted for the world frame of +// reference (yaw is relative to initial orientation, since no magnetometer +// is present in this case). Could be quite handy in some cases. +//#define OUTPUT_READABLE_WORLDACCEL + +// uncomment "OUTPUT_TEAPOT" if you want output that matches the +// format used for the InvenSense teapot demo +//#define OUTPUT_TEAPOT + + + +#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6) +bool blinkState = false; + +// MPU control/status vars +bool dmpReady = false; // set true if DMP init was successful +uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU +uint8_t devStatus; // return status after each device operation (0 = success, !0 = error) +uint16_t packetSize; // expected DMP packet size (default is 42 bytes) +uint16_t fifoCount; // count of all bytes currently in FIFO +uint8_t fifoBuffer[64]; // FIFO storage buffer + +// orientation/motion vars +Quaternion q; // [w, x, y, z] quaternion container +VectorInt16 aa; // [x, y, z] accel sensor measurements +VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor measurements +VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor measurements +VectorFloat gravity; // [x, y, z] gravity vector +float euler[3]; // [psi, theta, phi] Euler angle container +float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector + +// packet structure for InvenSense teapot demo +uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n' }; + + + +// ================================================================ +// === INTERRUPT DETECTION ROUTINE === +// ================================================================ + +volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has gone high +void dmpDataReady() { + mpuInterrupt = true; +} + + + +// ================================================================ +// === INITIAL SETUP === +// ================================================================ + +void setup() { + // join I2C bus (I2Cdev library doesn't do this automatically) + #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE + Wire.begin(); + TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz) + #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE + Fastwire::setup(400, true); + #endif + + // initialize serial communication + // (115200 chosen because it is required for Teapot Demo output, but it's + // really up to you depending on your project) + Serial.begin(115200); + while (!Serial); // wait for Leonardo enumeration, others continue immediately + + // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio + // Pro Mini running at 3.3v, cannot handle this baud rate reliably due to + // the baud timing being too misaligned with processor ticks. You must use + // 38400 or slower in these cases, or use some kind of external separate + // crystal solution for the UART timer. + + // initialize device + Serial.println(F("Initializing I2C devices...")); + mpu.initialize(); + + // verify connection + Serial.println(F("Testing device connections...")); + Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed")); + + // wait for ready + Serial.println(F("\nSend any character to begin DMP programming and demo: ")); + while (Serial.available() && Serial.read()); // empty buffer + while (!Serial.available()); // wait for data + while (Serial.available() && Serial.read()); // empty buffer again + + // load and configure the DMP + Serial.println(F("Initializing DMP...")); + devStatus = mpu.dmpInitialize(); + + // supply your own gyro offsets here, scaled for min sensitivity + mpu.setXGyroOffset(220); + mpu.setYGyroOffset(76); + mpu.setZGyroOffset(-85); + mpu.setZAccelOffset(1788); // 1688 factory default for my test chip + + // make sure it worked (returns 0 if so) + if (devStatus == 0) { + // turn on the DMP, now that it's ready + Serial.println(F("Enabling DMP...")); + mpu.setDMPEnabled(true); + + // enable Arduino interrupt detection + Serial.println(F("Enabling interrupt detection (Arduino external interrupt 0)...")); + attachInterrupt(0, dmpDataReady, RISING); + mpuIntStatus = mpu.getIntStatus(); + + // set our DMP Ready flag so the main loop() function knows it's okay to use it + Serial.println(F("DMP ready! Waiting for first interrupt...")); + dmpReady = true; + + // get expected DMP packet size for later comparison + packetSize = mpu.dmpGetFIFOPacketSize(); + } else { + // ERROR! + // 1 = initial memory load failed + // 2 = DMP configuration updates failed + // (if it's going to break, usually the code will be 1) + Serial.print(F("DMP Initialization failed (code ")); + Serial.print(devStatus); + Serial.println(F(")")); + } + + // configure LED for output + pinMode(LED_PIN, OUTPUT); +} + + + +// ================================================================ +// === MAIN PROGRAM LOOP === +// ================================================================ + +void loop() { + // if programming failed, don't try to do anything + if (!dmpReady) return; + + // wait for MPU interrupt or extra packet(s) available + while (!mpuInterrupt && fifoCount < packetSize) { + // other program behavior stuff here + // . + // . + // . + // if you are really paranoid you can frequently test in between other + // stuff to see if mpuInterrupt is true, and if so, "break;" from the + // while() loop to immediately process the MPU data + // . + // . + // . + } + + // reset interrupt flag and get INT_STATUS byte + mpuInterrupt = false; + mpuIntStatus = mpu.getIntStatus(); + + // get current FIFO count + fifoCount = mpu.getFIFOCount(); + + // check for overflow (this should never happen unless our code is too inefficient) + if ((mpuIntStatus & 0x10) || fifoCount == 1024) { + // reset so we can continue cleanly + mpu.resetFIFO(); + Serial.println(F("FIFO overflow!")); + + // otherwise, check for DMP data ready interrupt (this should happen frequently) + } else if (mpuIntStatus & 0x02) { + // wait for correct available data length, should be a VERY short wait + while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); + + // read a packet from FIFO + mpu.getFIFOBytes(fifoBuffer, packetSize); + + // track FIFO count here in case there is > 1 packet available + // (this lets us immediately read more without waiting for an interrupt) + fifoCount -= packetSize; + + #ifdef OUTPUT_READABLE_QUATERNION + // display quaternion values in easy matrix form: w x y z + mpu.dmpGetQuaternion(&q, fifoBuffer); + Serial.print("quat\t"); + Serial.print(q.w); + Serial.print("\t"); + Serial.print(q.x); + Serial.print("\t"); + Serial.print(q.y); + Serial.print("\t"); + Serial.println(q.z); + #endif + + #ifdef OUTPUT_READABLE_EULER + // display Euler angles in degrees + mpu.dmpGetQuaternion(&q, fifoBuffer); + mpu.dmpGetEuler(euler, &q); + Serial.print("euler\t"); + Serial.print(euler[0] * 180/M_PI); + Serial.print("\t"); + Serial.print(euler[1] * 180/M_PI); + Serial.print("\t"); + Serial.println(euler[2] * 180/M_PI); + #endif + + #ifdef OUTPUT_READABLE_YAWPITCHROLL + // display Euler angles in degrees + mpu.dmpGetQuaternion(&q, fifoBuffer); + mpu.dmpGetGravity(&gravity, &q); + mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); + Serial.print("ypr\t"); + Serial.print(ypr[0] * 180/M_PI); + Serial.print("\t"); + Serial.print(ypr[1] * 180/M_PI); + Serial.print("\t"); + Serial.println(ypr[2] * 180/M_PI); + #endif + + #ifdef OUTPUT_READABLE_REALACCEL + // display real acceleration, adjusted to remove gravity + mpu.dmpGetQuaternion(&q, fifoBuffer); + mpu.dmpGetAccel(&aa, fifoBuffer); + mpu.dmpGetGravity(&gravity, &q); + mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity); + Serial.print("areal\t"); + Serial.print(aaReal.x); + Serial.print("\t"); + Serial.print(aaReal.y); + Serial.print("\t"); + Serial.println(aaReal.z); + #endif + + #ifdef OUTPUT_READABLE_WORLDACCEL + // display initial world-frame acceleration, adjusted to remove gravity + // and rotated based on known orientation from quaternion + mpu.dmpGetQuaternion(&q, fifoBuffer); + mpu.dmpGetAccel(&aa, fifoBuffer); + mpu.dmpGetGravity(&gravity, &q); + mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity); + mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q); + Serial.print("aworld\t"); + Serial.print(aaWorld.x); + Serial.print("\t"); + Serial.print(aaWorld.y); + Serial.print("\t"); + Serial.println(aaWorld.z); + #endif + + #ifdef OUTPUT_TEAPOT + // display quaternion values in InvenSense Teapot demo format: + teapotPacket[2] = fifoBuffer[0]; + teapotPacket[3] = fifoBuffer[1]; + teapotPacket[4] = fifoBuffer[4]; + teapotPacket[5] = fifoBuffer[5]; + teapotPacket[6] = fifoBuffer[8]; + teapotPacket[7] = fifoBuffer[9]; + teapotPacket[8] = fifoBuffer[12]; + teapotPacket[9] = fifoBuffer[13]; + Serial.write(teapotPacket, 14); + teapotPacket[11]++; // packetCount, loops at 0xFF on purpose + #endif + + // blink LED to indicate activity + blinkState = !blinkState; + digitalWrite(LED_PIN, blinkState); + } +} diff --git a/hardware/mesure_cyclic_lenght/mesure_cyclic_lenght.ino b/hardware/mesure_cyclic_lenght/mesure_cyclic_lenght.ino new file mode 100644 index 0000000..81f0945 --- /dev/null +++ b/hardware/mesure_cyclic_lenght/mesure_cyclic_lenght.ino @@ -0,0 +1,30 @@ +/* +Measure the lenght of the Loop cycle. +*/ + +long lastMillis = 0; +long loops = 0; + +void setup(){ + Serial.begin(9600); +} + +void loop(){ + long currentMillis = millis(); + loops++; + + /* By doing complex math, reading sensors, using the "delay" function, + * etc you will increase the time required to finish the loop, + * which will decrease the number of loops per second. + */ + + if(currentMillis - lastMillis > 1000){ + Serial.print("Loops last second:"); + Serial.println(loops); + + lastMillis = currentMillis; + loops = 0; + } +} + + diff --git a/hardware/real_time_clock__DS3231/real_time_clock__DS3231.ino b/hardware/real_time_clock__DS3231/real_time_clock__DS3231.ino new file mode 100644 index 0000000..268be71 --- /dev/null +++ b/hardware/real_time_clock__DS3231/real_time_clock__DS3231.ino @@ -0,0 +1,118 @@ +// See tutotial: http://tronixlabs.com/news/tutorial-using-ds1307-and-ds3231-realtime-clock-modules-with-arduino/ + +#include "Wire.h" +#define DS3231_I2C_ADDRESS 0x68 +// Convert normal decimal numbers to binary coded decimal +byte decToBcd(byte val) +{ + return( (val/10*16) + (val%10) ); +} +// Convert binary coded decimal to normal decimal numbers +byte bcdToDec(byte val) +{ + return( (val/16*10) + (val%16) ); +} +void setup() +{ + Wire.begin(); + Serial.begin(9600); + // set the initial time here: + // DS3231 seconds, minutes, hours, day, date, month, year + //setDS3231time(30,27,19,2,10,2,15); // Comment again after setting up + // or you will rset the clock at each upload +} +void setDS3231time(byte second, byte minute, byte hour, byte dayOfWeek, byte +dayOfMonth, byte month, byte year) +{ + // sets time and date data to DS3231 + Wire.beginTransmission(DS3231_I2C_ADDRESS); + Wire.write(0); // set next input to start at the seconds register + Wire.write(decToBcd(second)); // set seconds + Wire.write(decToBcd(minute)); // set minutes + Wire.write(decToBcd(hour)); // set hours + Wire.write(decToBcd(dayOfWeek)); // set day of week (1=Sunday, 7=Saturday) + Wire.write(decToBcd(dayOfMonth)); // set date (1 to 31) + Wire.write(decToBcd(month)); // set month + Wire.write(decToBcd(year)); // set year (0 to 99) + Wire.endTransmission(); +} +void readDS3231time(byte *second, +byte *minute, +byte *hour, +byte *dayOfWeek, +byte *dayOfMonth, +byte *month, +byte *year) +{ + Wire.beginTransmission(DS3231_I2C_ADDRESS); + Wire.write(0); // set DS3231 register pointer to 00h + Wire.endTransmission(); + Wire.requestFrom(DS3231_I2C_ADDRESS, 7); + // request seven bytes of data from DS3231 starting from register 00h + *second = bcdToDec(Wire.read() & 0x7f); + *minute = bcdToDec(Wire.read()); + *hour = bcdToDec(Wire.read() & 0x3f); + *dayOfWeek = bcdToDec(Wire.read()); + *dayOfMonth = bcdToDec(Wire.read()); + *month = bcdToDec(Wire.read()); + *year = bcdToDec(Wire.read()); +} +void displayTime() +{ + byte second, minute, hour, dayOfWeek, dayOfMonth, month, year; + // retrieve data from DS3231 + readDS3231time(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, + &year); + // send it to the serial monitor + Serial.print(hour, DEC); + // convert the byte variable to a decimal number when displayed + Serial.print(":"); + if (minute<10) + { + Serial.print("0"); + } + Serial.print(minute, DEC); + Serial.print(":"); + if (second<10) + { + Serial.print("0"); + } + Serial.print(second, DEC); + Serial.print(" "); + Serial.print(dayOfMonth, DEC); + Serial.print("/"); + Serial.print(month, DEC); + Serial.print("/"); + Serial.print(year, DEC); + Serial.print(" Day of week: "); + switch(dayOfWeek){ + case 1: + Serial.println("Sunday"); + break; + case 2: + Serial.println("Monday"); + break; + case 3: + Serial.println("Tuesday"); + break; + case 4: + Serial.println("Wednesday"); + break; + case 5: + Serial.println("Thursday"); + break; + case 6: + Serial.println("Friday"); + break; + case 7: + Serial.println("Saturday"); + break; + } +} +void loop() +{ + displayTime(); // display the real-time clock data on the Serial Monitor, + delay(1000); // every second +} + + diff --git a/hardware/ultrasonic/ultrasonic_distance_programming/ultrasonic_distance_programming.ino b/hardware/ultrasonic/ultrasonic_distance_programming/ultrasonic_distance_programming.ino new file mode 100644 index 0000000..5887a88 --- /dev/null +++ b/hardware/ultrasonic/ultrasonic_distance_programming/ultrasonic_distance_programming.ino @@ -0,0 +1,193 @@ +/* + HC-SR04 Ping distance sensor: + VCC to arduino 5v + GND to arduino GND + Echo to Arduino pin 7 + Trig to Arduino pin 8 + + This sketch originates from Virtualmix: http://goo.gl/kJ8Gl + Has been modified by Winkle ink here: http://winkleink.blogspot.com.au/2012/05/arduino-hc-sr04-ultrasonic-distance.html + And modified further by ScottC here: http://arduinobasics.blogspot.com.au/2012/11/arduinobasics-hc-sr04-ultrasonic-sensor.html + on 10 Nov 2012. + */ + + +#define echoPin 7 // Echo Pin +#define trigPin 8 // Trigger Pin +#define LEDPin 13 // Onboard LED + +int maximumRange = 200; // Maximum range needed +int minimumRange = 0; // Minimum range needed +long duration, distance; // Duration used to calculate distance + +void setup() { + Serial.begin (9600); + pinMode(trigPin, OUTPUT); + pinMode(echoPin, INPUT); + pinMode(LEDPin, OUTPUT); // Use LED indicator (if required) +} + +void loop() { +/* The following trigPin/echoPin cycle is used to determine the + distance of the nearest object by bouncing soundwaves off of it. */ + digitalWrite(trigPin, LOW); + delayMicroseconds(2); + + digitalWrite(trigPin, HIGH); + delayMicroseconds(10); + + digitalWrite(trigPin, LOW); + duration = pulseIn(echoPin, HIGH); + + //Calculate the distance (in cm) based on the speed of sound. + distance = duration/58.2; + + if (distance >= maximumRange || distance <= minimumRange){ + /* Send a negative number to computer and Turn LED ON + to indicate "out of range" */ + Serial.println("-1"); + digitalWrite(LEDPin, HIGH); + } + else { + /* Send the distance to the computer using Serial protocol, and + turn LED OFF to indicate successful reading. */ + Serial.println(distance); + digitalWrite(LEDPin, LOW); + } + + //Delay 50ms before next reading. + delay(50); +} + +// End Arduino, start Processing +// Take care of: myPort (for serial comm) +///* +///* The following Processing Sketch was created by ScottC on +// the 10 Nov 2012 : http://arduinobasics.blogspot.com/ +// +// Inspired by this Processing sketch by Daniel Shiffman: +// http://processing.org/learning/basics/sinewave.html +// +//*/ +//import processing.serial.*; +// +// +//int numOfShapes = 60; // Number of squares to display on screen +//int shapeSpeed = 2; // Speed at which the shapes move to new position +// // 2 = Fastest, Larger numbers are slower +// +////Global Variables +//Square[] mySquares = new Square[numOfShapes]; +//int shapeSize, distance; +//String comPortString; +//Serial myPort; +// +///* -----------------------Setup ---------------------------*/ +//void setup(){ +// size(displayWidth,displayHeight); //Use entire screen size. +// smooth(); // draws all shapes with smooth edges. +// +// /* Calculate the size of the squares and initialise the Squares array */ +// shapeSize = (width/numOfShapes); +// for(int i = 0; i0; i--){ +// /* Use the previous square's position as a target */ +// targetY=mySquares[i-1].getY(); +// oldY=mySquares[i].getY(); +// +// if(abs(oldY-targetY)<2){ +// newY=targetY; //This helps to line them up +// }else{ +// //calculate the new position of the square +// newY=oldY-((oldY-targetY)/shapeSpeed); +// } +// //Set the new position of the square +// mySquares[i].setY(newY); +// +// /*Calculate the colour of the square based on its +// position on the screen */ +// blueVal = int(map(newY,0,height,0,255)); +// redVal = 255-blueVal; +// fill(redVal,0,blueVal); +// +// /* Draw the square on the screen */ +// rect(mySquares[i].getX(), mySquares[i].getY(),shapeSize,shapeSize); +// } +//} +// +///* ---------------------sketchFullScreen---------------------------*/ +//// This puts processing into Full Screen Mode +//boolean sketchFullScreen() { +// return true; +//} +// +///* ---------------------CLASS: Square ---------------------------*/ +//class Square{ +// int xPosition, yPosition; +// +// Square(int xPos, int yPos){ +// xPosition = xPos; +// yPosition = yPos; +// } +// +// int getX(){ +// return xPosition; +// } +// +// int getY(){ +// return yPosition; +// } +// +// void setY(int yPos){ +// yPosition = yPos; +// } +//} + diff --git a/hardware/ultrasonic/ultrasonic_distance_simple/ultrasonic_distance_simple.ino b/hardware/ultrasonic/ultrasonic_distance_simple/ultrasonic_distance_simple.ino new file mode 100644 index 0000000..85b5ad6 --- /dev/null +++ b/hardware/ultrasonic/ultrasonic_distance_simple/ultrasonic_distance_simple.ino @@ -0,0 +1,54 @@ +/* +HC-SR04 Ping distance sensor] + VCC to arduino 5v GND to arduino GND + Echo to Arduino pin 13 Trig to Arduino pin 12 + Red POS to Arduino pin 11 + Green POS to Arduino pin 10 + 560 ohm resistor to both LED NEG and GRD power rail + More info at: http://goo.gl/kJ8Gl + Original code improvements to the Ping sketch sourced from Trollmaker.com + Some code and wiring inspired by http://en.wikiversity.org/wiki/User:Dstaub/robotcar + */ + +#define trigPin 8 +#define echoPin 7 +#define RED 11 +#define GREEN 10 + +void setup() { + Serial.begin (9600); + pinMode(trigPin, OUTPUT); + pinMode(echoPin, INPUT); + pinMode(RED, OUTPUT); + pinMode(GREEN, OUTPUT); +} + +void loop() { + long duration, distance; + digitalWrite(trigPin, LOW); // Prepare for ping + delayMicroseconds(2); // + digitalWrite(trigPin, HIGH); // Send a ping + delayMicroseconds(10); // + digitalWrite(trigPin, LOW); // Set down ping + duration = pulseIn(echoPin, HIGH); + distance = (duration/2) / 29.1; // Speed is ~300m/s, + // so it takes ~29.1 milliseconds for a cm. + // Distance is half of (out + back) + if (distance < 5) { // This is where the LED On/Off happens + digitalWrite(RED,HIGH); // When the Red condition is met, the Green LED should turn off + digitalWrite(GREEN,LOW); + } + else { + digitalWrite(RED,LOW); + digitalWrite(GREEN,HIGH); + } + if (distance >= 200 || distance <= 0){ + Serial.println("Out of range"); + } + else { + Serial.print(distance); + Serial.println(" cm"); + } + delay(500); +} + diff --git a/motors/simple_motor_PWM_potenziometer__minimum_transistor_diode_3/simple_motor_PWM_potenziometer__minimum_transistor_diode_3.ino b/motors/simple_motor_PWM_potenziometer__minimum_transistor_diode_3/simple_motor_PWM_potenziometer__minimum_transistor_diode_3.ino new file mode 100644 index 0000000..83965d1 --- /dev/null +++ b/motors/simple_motor_PWM_potenziometer__minimum_transistor_diode_3/simple_motor_PWM_potenziometer__minimum_transistor_diode_3.ino @@ -0,0 +1,51 @@ +/* + Simple Motor with variable spped from pot input + + This sketch use a transistor and a diode + in order to poer a 5v ~150mAh directly from the board. + Hard thing is to find a suitable motor! + + + This version uses a pot as throttle control, + serial for debuggin. + + Optimized for a minimum throttle value in order to keep the motor off + */ + +const int analogInPin = A0; +const int motorPin = 9; + +int potValue = 0; +int motValue = 0; +const int minMotValue = 50 ; // Minimum power requiement of my own motr, + // This is going to differ from motor to motor + +void setup() { + pinMode(motorPin, OUTPUT); + Serial.begin(9600); // Debuggin + +} +void loop() { + potValue = analogRead(analogInPin); + motValue = potValue / 4 ; // Simple mapping 1024 -> 255 + +if (motValue > minMotValue) { // Minimum motor spped check + analogWrite(motorPin,motValue); // Change the PWM speed of the motor +} else { +analogWrite(motorPin,LOW) ; +} + + + Serial.print("Pot value = " ); + Serial.print(potValue); + Serial.print("\t Motor speed = "); + Serial.println(motValue); + delay(3); // Pause, helps to stabilize the input, + // slows the serial output +} + + + + + + diff --git a/motors/simple_motor_PWM_potenziometer_transistor_diode_2/simple_motor_PWM_potenziometer_transistor_diode_2.ino b/motors/simple_motor_PWM_potenziometer_transistor_diode_2/simple_motor_PWM_potenziometer_transistor_diode_2.ino new file mode 100644 index 0000000..54a87ed --- /dev/null +++ b/motors/simple_motor_PWM_potenziometer_transistor_diode_2/simple_motor_PWM_potenziometer_transistor_diode_2.ino @@ -0,0 +1,41 @@ +/* + Simple Motor with variable spped from pot input + + This sketch use a transistor and a diode + in order to poer a 5v ~150mAh directly from the board. + Hard thing is to find a suitable motor! + + This version uses a pot as throttle control, + serial for debuggin. + */ + +const int analogInPin = A0; +const int motorPin = 9; + +int potValue = 0; +int motValue = 0; + +void setup() { + pinMode(motorPin, OUTPUT); + Serial.begin(9600); // Debuggin + +} +void loop() { + potValue = analogRead(analogInPin); + motValue = potValue / 4 ; // Simple mapping 1024 -> 255 + + analogWrite(motorPin,motValue); // Change the PWM speed of the motor + + Serial.print("Pot value = " ); + Serial.print(potValue); + Serial.print("\t Motor speed = "); + Serial.println(motValue); + delay(3); // Pause, helps to stabilize the input + // and keeps a brushed motor from over heating ;) +} + + + + + + diff --git a/motors/simple_motor_PWM_transistor_diode_1/simple_motor_PWM_transistor_diode_1.ino b/motors/simple_motor_PWM_transistor_diode_1/simple_motor_PWM_transistor_diode_1.ino new file mode 100644 index 0000000..ac23845 --- /dev/null +++ b/motors/simple_motor_PWM_transistor_diode_1/simple_motor_PWM_transistor_diode_1.ino @@ -0,0 +1,27 @@ +/* Simple Motor + This sketch use a transistor and a diode + in order to poer a 5v ~150mAh directly from the board. + Hard thing is to find a suitable motor! + + This version uses PWM for acceleration / deceleration + */ + +int motorPin = 9; +void setup() { + pinMode(motorPin, OUTPUT); +} +void loop() { + for(int motorValue = 0 ; motorValue <= 255; motorValue +=5){ // PWM up + analogWrite(motorPin, motorValue); + delay(60); + } + for(int motorValue = 255 ; motorValue >= 0; motorValue -=5){ // PWM down + analogWrite(motorPin, motorValue); + delay(30); + } +delay(900); // Pause +} + + + + diff --git a/motors/simple_motor_transistor_diode_0/simple_motor_transistor_diode_0.ino b/motors/simple_motor_transistor_diode_0/simple_motor_transistor_diode_0.ino new file mode 100644 index 0000000..5b86a2b --- /dev/null +++ b/motors/simple_motor_transistor_diode_0/simple_motor_transistor_diode_0.ino @@ -0,0 +1,23 @@ +/* Simple Motor + This sketch use a transistor and a diode + in order to power a 5v ~150mAh directly from the board. + Hard thing is to find a suitable motor! + + In order to power a more powerfull motor you need to connect + the transistor to an other power line. + */ + +int motorPin = 9; +void setup() { + pinMode(motorPin, OUTPUT); // We drive the motor just like a LED +} + +void loop() { + digitalWrite(motorPin, HIGH); // Turn on the motor full throttle + delay(1000); + digitalWrite(motorPin, LOW); // Turn off motor + delay(5000); +} + + + diff --git a/optimization/analogInput_with_range/analogInput_with_range.ino b/optimization/analogInput_with_range/analogInput_with_range.ino new file mode 100644 index 0000000..715cc79 --- /dev/null +++ b/optimization/analogInput_with_range/analogInput_with_range.ino @@ -0,0 +1,59 @@ +/* + Analog Input + Demonstrates analog input by reading an analog sensor on analog pin 0 and + turning on and off a light emitting diode(LED) connected to digital pin 13. + The amount of time the LED will be on and off depends on + the value obtained by analogRead(). + + The circuit: + * Potentiometer attached to analog input 0 + * center pin of the potentiometer to the analog pin + * one side pin (either one) to ground + * the other side pin to +5V + * LED anode (long leg) attached to digital output 13 + * LED cathode (short leg) attached to ground + + * Note: because most Arduinos have a built-in LED attached + to pin 13 on the board, the LED is optional. + + + Created by David Cuartielles + modified 30 Aug 2011 + By Tom Igoe + + This example code is in the public domain. + + http://arduino.cc/en/Tutorial/AnalogInput + + Modified by A.Manni for using a 2.4k Pot with 2 5k resistors + Range = (1024 - offset) * 1024 / (1024 - offset) + With serial debugging. + */ + +int sensorPin = A0; // select the input pin for the potentiometer +int ledPin = 13; // select the pin for the LED +int sensorValue = 0; // variable to store the value coming from the sensor + +void setup() { + // declare the ledPin as an OUTPUT: + pinMode(ledPin, OUTPUT); + Serial.begin(9600); +} + +void loop() { + // read the value from the sensor: + sensorValue = analogRead(sensorPin); + // turn the ledPin on + digitalWrite(ledPin, HIGH); + // stop the program for milliseconds: + delay(sensorValue); + // turn the ledPin off: + digitalWrite(ledPin, LOW); + // stop the program for for milliseconds: + // Range = (1024 - offset) * 1024 / (1024 - offset) + delay((sensorValue -723 ) * 3.4); // Range = 723 - 1024 + Serial.print("Sensor Value: ") ; + Serial.println(sensorValue); + Serial.print("Adjusted value: ") ; + Serial.println((sensorValue -723 ) * 3.4); +} diff --git a/optimization/analogInput_with_range_and_limits/analogInput_with_range_and_limits.ino b/optimization/analogInput_with_range_and_limits/analogInput_with_range_and_limits.ino new file mode 100644 index 0000000..aa18a9e --- /dev/null +++ b/optimization/analogInput_with_range_and_limits/analogInput_with_range_and_limits.ino @@ -0,0 +1,71 @@ +/* + Analog Input + Demonstrates analog input by reading an analog sensor on analog pin 0 and + turning on and off a light emitting diode(LED) connected to digital pin 13. + The amount of time the LED will be on and off depends on + the value obtained by analogRead(). + + The circuit: + * Potentiometer attached to analog input 0 + * center pin of the potentiometer to the analog pin + * one side pin (either one) to ground + * the other side pin to +5V + * LED anode (long leg) attached to digital output 13 + * LED cathode (short leg) attached to ground + + * Note: because most Arduinos have a built-in LED attached + to pin 13 on the board, the LED is optional. + + + Created by David Cuartielles + modified 30 Aug 2011 + By Tom Igoe + + This example code is in the public domain. + + http://arduino.cc/en/Tutorial/AnalogInput + + Modified by A.Manni for using a 2.4k Pot with 2 5k resistors + Range = (1024 - offset) * 1024 / (1024 - offset) + Range can be defined with map(sensorValue, 724, 0124, 0, 1024) + Note: range is inverted + With serial debugging. + - Added initial limit for delay + + */ + +int sensorPin = A0; // select the input pin for the potentiometer +int ledPin = 13; // select the pin for the LED +int sensorValue = 0; // variable to store the value coming from the sensor +int calValue = map(sensorValue, 723, 1024, 0, 1024) ; // variable to store calibrated value for the Pot +// This could be done with a map() +void setup() { + + pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT: + Serial.begin(9600); + +} + +void loop() { + // read the value from the sensor: + sensorValue = analogRead(sensorPin); + + // turn the ledPin on + digitalWrite(ledPin, HIGH); + // stop the program for milliseconds: + delay(sensorValue); + // turn the ledPin off: + digitalWrite(ledPin, LOW); + // stop the program for for milliseconds: + // Range = (1024 - offset) * 1024 / (1024 - offset) + // calValue = (sensorValue -723 ) * 3.4 ; + delay(calValue); + Serial.print("Sensor Value: ") ; + Serial.println(sensorValue); + Serial.print("Adjusted value: ") ; + Serial.println(calValue); + +} + + + diff --git a/piezo/README b/piezo/README new file mode 100644 index 0000000..4c3877f --- /dev/null +++ b/piezo/README @@ -0,0 +1,3 @@ +There are 4/5 nice sketches bundled with arduino: +-> Digital : tone* +-> Sensors: knock diff --git a/piezo/keyboard_three_pullup_buttons/keyboard_three_pullup_buttons.ino b/piezo/keyboard_three_pullup_buttons/keyboard_three_pullup_buttons.ino new file mode 100644 index 0000000..1bd4e47 --- /dev/null +++ b/piezo/keyboard_three_pullup_buttons/keyboard_three_pullup_buttons.ino @@ -0,0 +1,47 @@ +/* + Melody keyboard with Input Pullup Serial + Plays a pitch that changes based on 3 digital inputs + + This example demonstrates the use of pinMode(INPUT_PULLUP). It reads a + digital input on pin 2 and prints the results to the serial monitor. + + Thecircuit: + * 3 buttons in pin 2,3,4 with no resistors + * Piezo on digital pin 9 + * Serial debug is available + + This example code is in the public domain + + */ + +// Please take care of the include path +#include "/root/arduino/sketchbook-lessons/piezo_mario_tune/pitches.h"; +int input[]= {1,2,3}; + int notes[] = { + NOTE_A4, NOTE_C4,NOTE_E3 }; + +void setup(){ + //start serial connection + Serial.begin(9600); + //configure pin2 as an input and enable the internal pull-up resistor + pinMode(2, INPUT_PULLUP); + pinMode(3, INPUT_PULLUP); + pinMode(4, INPUT_PULLUP); + pinMode(9, OUTPUT); + + +} + +void loop(){ + for (int thisSensor = 2; thisSensor < 5; thisSensor++) { + int sensorReading = digitalRead(thisSensor); + if (sensorReading == LOW) { + Serial.println(thisSensor); + tone(9, notes[thisSensor -2], 50); // Notes array is translated + } + //delay(2); + } +} + + + diff --git a/piezo/piezo_mario_tune/piezo_mario_tune.ino b/piezo/piezo_mario_tune/piezo_mario_tune.ino new file mode 100644 index 0000000..26c171a --- /dev/null +++ b/piezo/piezo_mario_tune/piezo_mario_tune.ino @@ -0,0 +1,193 @@ +/* + Arduino Mario Bros Tunes + With Piezo Buzzer and PWM + by: Dipto Pratyaksa + last updated: 31/3/13 +*/ +#include + +#define melodyPin 3 +//Mario main theme melody +int melody[] = { + NOTE_E7, NOTE_E7, 0, NOTE_E7, + 0, NOTE_C7, NOTE_E7, 0, + NOTE_G7, 0, 0, 0, + NOTE_G6, 0, 0, 0, + + NOTE_C7, 0, 0, NOTE_G6, + 0, 0, NOTE_E6, 0, + 0, NOTE_A6, 0, NOTE_B6, + 0, NOTE_AS6, NOTE_A6, 0, + + NOTE_G6, NOTE_E7, NOTE_G7, + NOTE_A7, 0, NOTE_F7, NOTE_G7, + 0, NOTE_E7, 0,NOTE_C7, + NOTE_D7, NOTE_B6, 0, 0, + + NOTE_C7, 0, 0, NOTE_G6, + 0, 0, NOTE_E6, 0, + 0, NOTE_A6, 0, NOTE_B6, + 0, NOTE_AS6, NOTE_A6, 0, + + NOTE_G6, NOTE_E7, NOTE_G7, + NOTE_A7, 0, NOTE_F7, NOTE_G7, + 0, NOTE_E7, 0,NOTE_C7, + NOTE_D7, NOTE_B6, 0, 0 +}; +//Mario main them tempo +int tempo[] = { + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + + 9, 9, 9, + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, + + 9, 9, 9, + 12, 12, 12, 12, + 12, 12, 12, 12, + 12, 12, 12, 12, +}; + +// + +//Underworld melody +int underworld_melody[] = { + NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4, + NOTE_AS3, NOTE_AS4, 0, + 0, + NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4, + NOTE_AS3, NOTE_AS4, 0, + 0, + NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4, + NOTE_DS3, NOTE_DS4, 0, + 0, + NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4, + NOTE_DS3, NOTE_DS4, 0, + 0, NOTE_DS4, NOTE_CS4, NOTE_D4, + NOTE_CS4, NOTE_DS4, + NOTE_DS4, NOTE_GS3, + NOTE_G3, NOTE_CS4, + NOTE_C4, NOTE_FS4,NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4, + NOTE_GS4, NOTE_DS4, NOTE_B3, + NOTE_AS3, NOTE_A3, NOTE_GS3, + 0, 0, 0 +}; +//Underwolrd tempo +int underworld_tempo[] = { + 12, 12, 12, 12, + 12, 12, 6, + 3, + 12, 12, 12, 12, + 12, 12, 6, + 3, + 12, 12, 12, 12, + 12, 12, 6, + 3, + 12, 12, 12, 12, + 12, 12, 6, + 6, 18, 18, 18, + 6, 6, + 6, 6, + 6, 6, + 18, 18, 18,18, 18, 18, + 10, 10, 10, + 10, 10, 10, + 3, 3, 3 +}; + +void setup(void) +{ + pinMode(3, OUTPUT);//buzzer + pinMode(13, OUTPUT);//led indicator when singing a note + +} +void loop() +{ +//sing the tunes + sing(1); + sing(1); + sing(2); +} +int song = 0; + +void sing(int s){ + // iterate over the notes of the melody: + song = s; + if(song==2){ + Serial.println(" 'Underworld Theme'"); + int size = sizeof(underworld_melody) / sizeof(int); + for (int thisNote = 0; thisNote < size; thisNote++) { + + // to calculate the note duration, take one second + // divided by the note type. + //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc. + int noteDuration = 1000/underworld_tempo[thisNote]; + + buzz(melodyPin, underworld_melody[thisNote],noteDuration); + + // to distinguish the notes, set a minimum time between them. + // the note's duration + 30% seems to work well: + int pauseBetweenNotes = noteDuration * 1.30; + delay(pauseBetweenNotes); + + // stop the tone playing: + buzz(melodyPin, 0,noteDuration); + + } + + }else{ + + Serial.println(" 'Mario Theme'"); + int size = sizeof(melody) / sizeof(int); + for (int thisNote = 0; thisNote < size; thisNote++) { + + // to calculate the note duration, take one second + // divided by the note type. + //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc. + int noteDuration = 1000/tempo[thisNote]; + + buzz(melodyPin, melody[thisNote],noteDuration); + + // to distinguish the notes, set a minimum time between them. + // the note's duration + 30% seems to work well: + int pauseBetweenNotes = noteDuration * 1.30; + delay(pauseBetweenNotes); + + // stop the tone playing: + buzz(melodyPin, 0,noteDuration); + + } + } +} + +void buzz(int targetPin, long frequency, long length) { + digitalWrite(13,HIGH); + long delayValue = 1000000/frequency/2; // calculate the delay value between transitions + //// 1 second's worth of microseconds, divided by the frequency, then split in half since + //// there are two phases to each cycle + long numCycles = frequency * length/ 1000; // calculate the number of cycles for proper timing + //// multiply frequency, which is really cycles per second, by the number of seconds to + //// get the total number of cycles to produce + for (long i=0; i < numCycles; i++){ // for the calculated length of time... + digitalWrite(targetPin,HIGH); // write the buzzer pin high to push out the diaphram + delayMicroseconds(delayValue); // wait for the calculated delay value + digitalWrite(targetPin,LOW); // write the buzzer pin low to pull back the diaphram + delayMicroseconds(delayValue); // wait again or the calculated delay value + } + digitalWrite(13,LOW); + +} diff --git a/piezo/piezo_mario_tune/pitches.h b/piezo/piezo_mario_tune/pitches.h new file mode 100644 index 0000000..55c7d54 --- /dev/null +++ b/piezo/piezo_mario_tune/pitches.h @@ -0,0 +1,95 @@ +/************************************************* + * Public Constants + *************************************************/ + +#define NOTE_B0 31 +#define NOTE_C1 33 +#define NOTE_CS1 35 +#define NOTE_D1 37 +#define NOTE_DS1 39 +#define NOTE_E1 41 +#define NOTE_F1 44 +#define NOTE_FS1 46 +#define NOTE_G1 49 +#define NOTE_GS1 52 +#define NOTE_A1 55 +#define NOTE_AS1 58 +#define NOTE_B1 62 +#define NOTE_C2 65 +#define NOTE_CS2 69 +#define NOTE_D2 73 +#define NOTE_DS2 78 +#define NOTE_E2 82 +#define NOTE_F2 87 +#define NOTE_FS2 93 +#define NOTE_G2 98 +#define NOTE_GS2 104 +#define NOTE_A2 110 +#define NOTE_AS2 117 +#define NOTE_B2 123 +#define NOTE_C3 131 +#define NOTE_CS3 139 +#define NOTE_D3 147 +#define NOTE_DS3 156 +#define NOTE_E3 165 +#define NOTE_F3 175 +#define NOTE_FS3 185 +#define NOTE_G3 196 +#define NOTE_GS3 208 +#define NOTE_A3 220 +#define NOTE_AS3 233 +#define NOTE_B3 247 +#define NOTE_C4 262 +#define NOTE_CS4 277 +#define NOTE_D4 294 +#define NOTE_DS4 311 +#define NOTE_E4 330 +#define NOTE_F4 349 +#define NOTE_FS4 370 +#define NOTE_G4 392 +#define NOTE_GS4 415 +#define NOTE_A4 440 +#define NOTE_AS4 466 +#define NOTE_B4 494 +#define NOTE_C5 523 +#define NOTE_CS5 554 +#define NOTE_D5 587 +#define NOTE_DS5 622 +#define NOTE_E5 659 +#define NOTE_F5 698 +#define NOTE_FS5 740 +#define NOTE_G5 784 +#define NOTE_GS5 831 +#define NOTE_A5 880 +#define NOTE_AS5 932 +#define NOTE_B5 988 +#define NOTE_C6 1047 +#define NOTE_CS6 1109 +#define NOTE_D6 1175 +#define NOTE_DS6 1245 +#define NOTE_E6 1319 +#define NOTE_F6 1397 +#define NOTE_FS6 1480 +#define NOTE_G6 1568 +#define NOTE_GS6 1661 +#define NOTE_A6 1760 +#define NOTE_AS6 1865 +#define NOTE_B6 1976 +#define NOTE_C7 2093 +#define NOTE_CS7 2217 +#define NOTE_D7 2349 +#define NOTE_DS7 2489 +#define NOTE_E7 2637 +#define NOTE_F7 2794 +#define NOTE_FS7 2960 +#define NOTE_G7 3136 +#define NOTE_GS7 3322 +#define NOTE_A7 3520 +#define NOTE_AS7 3729 +#define NOTE_B7 3951 +#define NOTE_C8 4186 +#define NOTE_CS8 4435 +#define NOTE_D8 4699 +#define NOTE_DS8 4978 + + diff --git a/serial/README b/serial/README new file mode 100644 index 0000000..6e1c3f6 --- /dev/null +++ b/serial/README @@ -0,0 +1,8 @@ +- Simple serial communication 2 arduino: switch 1 and LED 2 +- Serial Parser: Examples -> strings +- Serial to RGB LED + + +- I2C +- SPI +- display lcd , clock, ethernet, gyro, diff --git a/shift_register/shiftOut_binary_count/shiftOut_binary_count.ino b/shift_register/shiftOut_binary_count/shiftOut_binary_count.ino new file mode 100644 index 0000000..6878989 --- /dev/null +++ b/shift_register/shiftOut_binary_count/shiftOut_binary_count.ino @@ -0,0 +1,57 @@ + +//**************************************************************// +// Name : shiftOutCode, Hello World +// Author : Carlyn Maw,Tom Igoe, David A. Mellis +// Date : 25 Oct, 2006 +// Modified: 23 Mar 2010 +// Version : 2.0 +// Notes : Code for using a 74HC595 Shift Register // +// : to count from 0 to 255 +//**************************************************************** + +//Pin connected to ST_CP of 74HC595 +int latchPin = 8; +//Pin connected to SH_CP of 74HC595 +int clockPin = 12; +////Pin connected to DS of 74HC595 +int dataPin = 11; + + + +void setup() { + //set pins to output so you can control the shift register + pinMode(latchPin, OUTPUT); + pinMode(clockPin, OUTPUT); + pinMode(dataPin, OUTPUT); + // Serial Debug + Serial.begin(9600); + Serial.print("Decimal"); + Serial.print("\t"); + Serial.println("Binary"); +} + +void loop() { + // count from 0 to 255 and display the number + // on the LEDs + for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) { + // take the latchPin low so + // the LEDs don't change while you're sending in bits: + digitalWrite(latchPin, LOW); + + // shift out the bits: + shiftOut(dataPin, clockPin, SBFIRST, numberToDisplay); + + //take the latch pin high so the LEDs will light up: + digitalWrite(latchPin, HIGH); + // Serial Debug + Serial.print(numberToDisplay); + Serial.print("\t"); + Serial.println(numberToDisplay, BIN); + // pause before next value: + delay(200); + } +} + + + + diff --git a/shift_register/shift_register_8bit/shift_register_8bit.ino b/shift_register/shift_register_8bit/shift_register_8bit.ino new file mode 100644 index 0000000..7ce253e --- /dev/null +++ b/shift_register/shift_register_8bit/shift_register_8bit.ino @@ -0,0 +1,43 @@ +//**************************************************************// +// Name : shiftOutCode, Hello World +// Author : Carlyn Maw,Tom Igoe, David A. Mellis +// Date : 25 Oct, 2006 +// Modified: 23 Mar 2010 +// Version : 2.0 +// Notes : Code for using a 74HC595 Shift Register +// +// : to count from 0 to 255 +//**************************************************************** + + +//Pin connected to ST_CP of 74HC595 +int latchPin = 8; +//Pin connected to SH_CP of 74HC595 +int clockPin = 12; +////Pin connected to DS of 74HC595 +int dataPin = 11; +void setup() { + //set pins to output so you can control the shift register + pinMode(latchPin, OUTPUT); + +pinMode(clockPin, OUTPUT); +pinMode(dataPin, OUTPUT); +} +void loop() { + // count from 0 to 255 and display the number + // on the LEDs + for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) { + // take the latchPin low so + // the LEDs don’t change while you’re sending in bits: + digitalWrite(latchPin, LOW); + // shift out the bits: + shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay); + //take the latch pin high so the LEDs will light up: + digitalWrite(latchPin, HIGH); + // pause before next value: + delay(500); + } +} + + + diff --git a/shift_register/shift_register_custom_pattern_4/shift_register_custom_pattern_4.ino b/shift_register/shift_register_custom_pattern_4/shift_register_custom_pattern_4.ino new file mode 100644 index 0000000..c5e1da7 --- /dev/null +++ b/shift_register/shift_register_custom_pattern_4/shift_register_custom_pattern_4.ino @@ -0,0 +1,136 @@ + +/* + Shift Register Example + Turning on the outputs of a 74HC595 using an array + + Hardware: + * 74HC595 shift register + * LEDs attached to each of the outputs of the shift register + + */ +//Pin connected to ST_CP of 74HC595 +int latchPin = 8; +//Pin connected to SH_CP of 74HC595 +int clockPin = 12; +////Pin connected to DS of 74HC595 +int dataPin = 11; + +//holders for infromation you're going to pass to shifting function +byte data; +byte dataArray[10]; + +void setup() { + //set pins to output because they are addressed in the main loop + pinMode(latchPin, OUTPUT); + Serial.begin(9600); + + //Arduino doesn't seem to have a way to write binary straight into the code + //so these values are in HEX. Decimal would have been fine, too. + dataArray[0] = 0xFF; //11111111 + dataArray[1] = 0xFE; //11111110 + dataArray[2] = 0xFC; //11111100 + dataArray[3] = 0xF8; //11111000 + dataArray[4] = 0xF0; //11110000 + dataArray[5] = 0xE0; //11100000 + dataArray[6] = 0xC0; //11000000 + dataArray[7] = 0x80; //10000000 + dataArray[8] = 0x00; //00000000 + dataArray[9] = 0x38; //11100000 + + //function that blinks all the LEDs + //gets passed the number of blinks and the pause time + blinkAll_2Bytes(2,500); +} + +void loop() { + + for (int j = 0; j < 10; j++) { + //load the light sequence you want from array + data = dataArray[j]; + //ground latchPin and hold low for as long as you are transmitting + digitalWrite(latchPin, 0); + //move 'em out + shiftOut(dataPin, clockPin, data); + //return the latch pin high to signal chip that it + //no longer needs to listen for information + digitalWrite(latchPin, 1); + delay(300); + } +} + + + +// the heart of the program +void shiftOut(int myDataPin, int myClockPin, byte myDataOut) { + // This shifts 8 bits out MSB first, + //on the rising edge of the clock, + //clock idles low + + //internal function setup + int i=0; + int pinState; + pinMode(myClockPin, OUTPUT); + pinMode(myDataPin, OUTPUT); + + //clear everything out just in case to + //prepare shift register for bit shifting + digitalWrite(myDataPin, 0); + digitalWrite(myClockPin, 0); + + //for each bit in the byte myDataOut� + //NOTICE THAT WE ARE COUNTING DOWN in our for loop + //This means that %00000001 or "1" will go through such + //that it will be pin Q0 that lights. + for (i=7; i>=0; i--) { + digitalWrite(myClockPin, 0); + + //if the value passed to myDataOut and a bitmask result + // true then... so if we are at i=6 and our value is + // %11010100 it would the code compares it to %01000000 + // and proceeds to set pinState to 1. + if ( myDataOut & (1<= count){ + index = 0; + } +} + diff --git a/shift_register/shift_register_pattern/sketch_jan27c/sketch_jan27c.ino b/shift_register/shift_register_pattern/sketch_jan27c/sketch_jan27c.ino new file mode 100644 index 0000000..c5e1da7 --- /dev/null +++ b/shift_register/shift_register_pattern/sketch_jan27c/sketch_jan27c.ino @@ -0,0 +1,136 @@ + +/* + Shift Register Example + Turning on the outputs of a 74HC595 using an array + + Hardware: + * 74HC595 shift register + * LEDs attached to each of the outputs of the shift register + + */ +//Pin connected to ST_CP of 74HC595 +int latchPin = 8; +//Pin connected to SH_CP of 74HC595 +int clockPin = 12; +////Pin connected to DS of 74HC595 +int dataPin = 11; + +//holders for infromation you're going to pass to shifting function +byte data; +byte dataArray[10]; + +void setup() { + //set pins to output because they are addressed in the main loop + pinMode(latchPin, OUTPUT); + Serial.begin(9600); + + //Arduino doesn't seem to have a way to write binary straight into the code + //so these values are in HEX. Decimal would have been fine, too. + dataArray[0] = 0xFF; //11111111 + dataArray[1] = 0xFE; //11111110 + dataArray[2] = 0xFC; //11111100 + dataArray[3] = 0xF8; //11111000 + dataArray[4] = 0xF0; //11110000 + dataArray[5] = 0xE0; //11100000 + dataArray[6] = 0xC0; //11000000 + dataArray[7] = 0x80; //10000000 + dataArray[8] = 0x00; //00000000 + dataArray[9] = 0x38; //11100000 + + //function that blinks all the LEDs + //gets passed the number of blinks and the pause time + blinkAll_2Bytes(2,500); +} + +void loop() { + + for (int j = 0; j < 10; j++) { + //load the light sequence you want from array + data = dataArray[j]; + //ground latchPin and hold low for as long as you are transmitting + digitalWrite(latchPin, 0); + //move 'em out + shiftOut(dataPin, clockPin, data); + //return the latch pin high to signal chip that it + //no longer needs to listen for information + digitalWrite(latchPin, 1); + delay(300); + } +} + + + +// the heart of the program +void shiftOut(int myDataPin, int myClockPin, byte myDataOut) { + // This shifts 8 bits out MSB first, + //on the rising edge of the clock, + //clock idles low + + //internal function setup + int i=0; + int pinState; + pinMode(myClockPin, OUTPUT); + pinMode(myDataPin, OUTPUT); + + //clear everything out just in case to + //prepare shift register for bit shifting + digitalWrite(myDataPin, 0); + digitalWrite(myClockPin, 0); + + //for each bit in the byte myDataOut� + //NOTICE THAT WE ARE COUNTING DOWN in our for loop + //This means that %00000001 or "1" will go through such + //that it will be pin Q0 that lights. + for (i=7; i>=0; i--) { + digitalWrite(myClockPin, 0); + + //if the value passed to myDataOut and a bitmask result + // true then... so if we are at i=6 and our value is + // %11010100 it would the code compares it to %01000000 + // and proceeds to set pinState to 1. + if ( myDataOut & (1< 0) { + // ASCII '0' through '9' characters are + // represented by the values 48 through 57. + // so if the user types a number from 0 through 9 in ASCII, + // you can subtract 48 to get the actual value: + int bitToSet = Serial.read() - 48; + + // write to the shift register with the correct bit set high: + registerWrite(bitToSet, HIGH); + } +} + +// This method sends bits to the shift register: + +void registerWrite(int whichPin, int whichState) { +// the bits you want to send + byte bitsToSend = 0; + + // turn off the output so the pins don't light up + // while you're shifting bits: + digitalWrite(latchPin, LOW); + + // turn on the next highest bit in bitsToSend: + bitWrite(bitsToSend, whichPin, whichState); + + // shift the bits out: + shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend); + + // turn on the output so the LEDs can light up: + digitalWrite(latchPin, HIGH); + delay(300); + +} +