PIR alarm

// Uses a PIR sensor to detect movement, buzzes a buzzer

// more info here: [Link]
alarm/
// email me, John Park, at jp@[Link]
// based upon:
// PIR sensor tester by Limor Fried of Adafruit
// tone code by michael@[Link]


int ledPin = 13; // choose the pin for the LED
int inputPin = 2; // choose the input pin (for PIR sensor)
int pirState = LOW; // we start, assuming no motion detected
int val = 0; // variable for reading the pin status
int pinSpeaker = 10; //Set up a speaker on a PWM pin (digital 9,
10, or 11)

void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inputPin, INPUT); // declare sensor as input
pinMode(pinSpeaker, OUTPUT);
[Link](9600);
}

void loop(){
val = digitalRead(inputPin); // read input value
if (val == HIGH) { // check if the input is HIGH
digitalWrite(ledPin, HIGH); // turn LED ON
playTone(300, 160);
delay(150);


if (pirState == LOW) {
// we have just turned on
[Link]("Motion detected!");
// We only want to print on the output change, not state
pirState = HIGH;
}
} else {
digitalWrite(ledPin, LOW); // turn LED OFF
playTone(0, 0);
delay(300);
if (pirState == HIGH){
// we have just turned of
[Link]("Motion ended!");
// We only want to print on the output change, not state
pirState = LOW;
}
}
}
// duration in mSecs, frequency in hertz
void playTone(long duration, int freq) {
duration *= 1000;
int period = (1.0 / freq) * 1000000;
long elapsed_time = 0;
while (elapsed_time < duration) {
digitalWrite(pinSpeaker,HIGH);
delayMicroseconds(period / 2);
digitalWrite(pinSpeaker, LOW);
delayMicroseconds(period / 2);
elapsed_time += (period);
}
}


Charlieplexing 12 LED s

#define A 12
#define B 11
#define C 10
#define D 9

#define PIN_CONFIG 0
#define PIN_STATE 1

#define LED_COUNT 12

int matrix[LED_COUNT][2][4] = {
// PIN_CONFIG PIN_STATE
// A B C D A B C D
{ { OUTPUT, OUTPUT, INPUT, INPUT }, { HIGH, LOW, LOW, LOW } }, // AB 0
{ { OUTPUT, OUTPUT, INPUT, INPUT }, { LOW, HIGH, LOW, LOW } }, // BA 1
{ { INPUT, OUTPUT, OUTPUT, INPUT }, { LOW, HIGH, LOW, LOW } }, // BC 2
{ { INPUT, OUTPUT, OUTPUT, INPUT }, { LOW, LOW, HIGH, LOW } }, // CB 3
{ { OUTPUT, INPUT, OUTPUT, INPUT }, { HIGH, LOW, LOW, LOW } }, // AC 4
{ { OUTPUT, INPUT, OUTPUT, INPUT }, { LOW, LOW, HIGH, LOW } }, // CA 5
{ { OUTPUT, INPUT, INPUT, OUTPUT }, { HIGH, LOW, LOW, LOW } }, // AD 6
{ { OUTPUT, INPUT, INPUT, OUTPUT }, { LOW, LOW, LOW, HIGH } }, // DA 7
{ { INPUT, OUTPUT, INPUT, OUTPUT }, { LOW, HIGH, LOW, LOW } }, // BD 8
{ { INPUT, OUTPUT, INPUT, OUTPUT }, { LOW, LOW, LOW, HIGH } }, // DB 9
{ { INPUT, INPUT, OUTPUT, OUTPUT }, { LOW, LOW, HIGH, LOW } }, // CD 10
{ { INPUT, INPUT, OUTPUT, OUTPUT }, { LOW, LOW, LOW, HIGH } } // DC 11
};

void turnOn( int led ) {
pinMode( A, matrix[led][PIN_CONFIG][0] );
pinMode( B, matrix[led][PIN_CONFIG][1] );
pinMode( C, matrix[led][PIN_CONFIG][2] );
pinMode( D, matrix[led][PIN_CONFIG][3] );
digitalWrite( A, matrix[led][PIN_STATE][0] );
digitalWrite( B, matrix[led][PIN_STATE][1] );
digitalWrite( C, matrix[led][PIN_STATE][2] );
digitalWrite( D, matrix[led][PIN_STATE][3] );
}

void setup() {}

void loop() {
for( int l = 0; l < LED_COUNT; l++ ) {
turnOn( l );
delay( 1000 / LED_COUNT );
}
}




#define A 12
#define B 11
#define C 10
#define D 9

#define LED_COUNT 12
#define DDR_BYTE 0
#define PORT_BYTE 1

byte matrix[LED_COUNT][2] = {
// DDR_BYTE PORT_BYTE
// ABCD ABCD
{ 0b00011000, 0b00010000 }, // AB 0
{ 0b00011000, 0b00001000 }, // BA 1
{ 0b00001100, 0b00001000 }, // BC 2
{ 0b00011100, 0b00000100 }, // CB 3
{ 0b00010100, 0b00010000 }, // AC 4
{ 0b00010100, 0b00000100 }, // CA 5
{ 0b00010010, 0b00010000 }, // AD 6
{ 0b00010010, 0b00000010 }, // DA 7
{ 0b00001010, 0b00001000 }, // BD 8
{ 0b00001010, 0b00000010 }, // DB 9
{ 0b00000110, 0b00000100 }, // CD 10
{ 0b00000110, 0b00000010 } // DC 11
};

void turnOn( byte led ) {
DDRB = matrix[led][DDR_BYTE];
PORTB = matrix[led][PORT_BYTE];
}

void setup() {}

void loop() {
for( byte l = 0; l < LED_COUNT; l++ ) {
turnOn( l );
delay( 10 );
}
}


Aquaponics Online Temperature
and Humidity


Control funduino 8 relay channel module with arduino and
ethernet shield


/*
Network Relay System


*/

#include "etherShield.h"
#include "ETHER_28J60.h"

int i, rsize, relay[] = {8, 7, 6, 5, 3, 2, 1, 0};

static uint8_t mac[6] = {0x10, 0x10, 0x10, 0x02, 0x00, 0x00};
static uint8_t ip[4] = {10, 10, 10, 200};
static uint16_t port = 80;
unsigned long runtime, starttime;

ETHER_28J60 ether;

void setup() {
pinMode(4, OUTPUT); // REQUIRED for [Link] ENC28J60 shield!!!
digitalWrite(4, HIGH); // Same as above.

// [Link](57600);
[Link](mac, ip, port);
rsize = sizeof(relay) / 2;
for (i = 0; i < rsize; i = i + 1) {
pinMode(relay[i], OUTPUT);
}
runtime = 0;
starttime = millis();
}

void loop() {
int c;
char * param;
char * params;

if (params = [Link]()) {
if (strstr(params, "?status")) {
for (i = 0; i < rsize; i = i + 1) {
[Link](digitalRead(relay[i]));
}
} else {
if((strlen(params) > 3) && (!(strstr(params, "[Link]")))) {
runtime = 0;
param = strtok(params, "?&");
while (param != NULL) {
if (strstr(param, "p=")) {
i = atoi(param + 2) - 1;
} else if (strstr(param, "c=")) {
c = atoi(param + 2);
if (c == 1) {
for (c = 0; c < rsize; c = c + 1) { digitalWrite(relay[c],
LOW); }
digitalWrite(relay[i], HIGH);
} else {
for (c = 0; c < rsize; c = c + 1) { digitalWrite(relay[c],
LOW); }
}
} else if (strstr(param, "t=")) {
runtime = (unsigned long)(atoi(param + 2)) * 1000;
if (runtime < 15000) { runtime = 15000; }
starttime = millis();
}
param = strtok(NULL, "& ");
}
if (runtime == 0) {
runtime = 60000; // 60 sec. default run time (takes 10 seconds
for valve to open).
starttime = millis();
}
}

[Link]("<tt>Network Relay System\n<br>\n");
for (i = 0; i < rsize; i = i + 1) {
[Link]("<br>Port #");
[Link](i+1);
[Link](": <a href='?p=");
[Link](i+1);
if (digitalRead(relay[i]) == 1) {
[Link]("&c=0'>Off</a> in ");
[Link]((runtime - (millis() - starttime))/1000);
[Link](" seconds.\n");
}
else {
[Link]("&c=1'>On</a>\n");
}
}
[Link]("<p><a href='/'>Refresh</a>,<a
href='/?status'>Status</a>\n");
}
[Link]();
}

if ((unsigned long)(millis() - starttime) > runtime) {
for (c = 0; c < rsize; c = c + 1) { digitalWrite(relay[c], LOW); }
}
}




Web Control Relay - Arduino



Using the same hardware and an ethernet sheild I found and modified an ethernet sketch to
control the relays. This sketh controls each rely with a specific URL. I have the IP set to
[Link]. The URL for pin 2 is [Link]/$1 and [Link]/$2 to toggle it on
or off.
pin3 is $3 and $4
pin4 is $5 and $6
pin5 is $7 and $8
pin6 is $9 and $0
pin7 is $A and $B
pin8 is $C and $D
pin9 is $E and $F

I didn't write this sketch. I just made a few mods. All credit goes to the original author.

/*
Web Server Demo
thrown together by Randy Sarafan

Allows you to turn on and off an LED by entering different urls.

To turn it on:
[Link]

To turn it off:
[Link]

Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Connect an LED to pin D2 and put it in series with a 220 ohm resistor to ground

Based almost entirely upon Web Server by Tom Igoe and David Mellis

Edit history:
created 18 Dec 2009
by David A. Mellis
modified 4 Sep 2010
by Tom Igoe

*/

#include <SPI.h>
#include <Ethernet.h>

boolean incoming = 0;

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDA, 0x02 };
IPAddress ip(192,168,1,111); //<<< ENTER YOUR IP ADDRESS HERE!!!

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup()
{
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);

// start the Ethernet connection and the server:
[Link](mac, ip);
[Link]();
[Link](9600);
}

void loop()
{
// listen for incoming clients
EthernetClient client = [Link]();
if (client) {
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while ([Link]()) {
if ([Link]()) {
char c = [Link]();
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply

//reads URL string from $ to first blank space
if(incoming && c == ' '){
incoming = 0;
}
if(c == '$'){
incoming = 1;
}

//Checks for the URL string $1 or $2
if(incoming == 1){
[Link](c);

if(c == '1'){
[Link]("ON");
digitalWrite(2, HIGH);
}
if(c == '2'){
[Link]("OFF");
digitalWrite(2, LOW);
}
if(c == '3'){
[Link]("ON");
digitalWrite(3, HIGH);
}
if(c == '4'){
[Link]("OFF");
digitalWrite(3, LOW);
}
if(c == '5'){
[Link]("ON");
digitalWrite(4, HIGH);
}
if(c == '6'){
[Link]("OFF");
digitalWrite(4, LOW);
}
if(c == '7'){
[Link]("ON");
digitalWrite(5, HIGH);
}
if(c == '8'){
[Link]("OFF");
digitalWrite(5, LOW);
}
if(c == '9'){
[Link]("ON");
digitalWrite(6, HIGH);
}
if(c == '0'){
[Link]("OFF");
digitalWrite(6, LOW);
}
if(c == 'A'){
[Link]("ON");
digitalWrite(7, HIGH);
}
if(c == 'B'){
[Link]("OFF");
digitalWrite(7, LOW);
}
if(c == 'C'){
[Link]("ON");
digitalWrite(8, HIGH);
}
if(c == 'D'){
[Link]("OFF");
digitalWrite(8, LOW);
}
if(c == 'E'){
[Link]("ON");
digitalWrite(9, HIGH);
}
if(c == 'F'){
[Link]("OFF");
digitalWrite(9, LOW);
}

}

if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
[Link]();
}
}



Program de test modul 8 relee
int Relay1 = 13;
int Relay2 = 12;
int Relay3 = 11;
int Relay4 = 10;
int Relay5 = 9;
int Relay6 = 8;
int Relay7 = 7;
int Relay8 = 6;
void setup()
{
pinMode(Relay1, OUTPUT); //Set Pin12 as output
pinMode(Relay2, OUTPUT);
pinMode(Relay3, OUTPUT);
pinMode(Relay4, OUTPUT);
pinMode(Relay5, OUTPUT);
pinMode(Relay6, OUTPUT);
pinMode(Relay7, OUTPUT);
pinMode(Relay8, OUTPUT);
}
void loop()
{
digitalWrite(Relay1, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay1, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay2, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay2, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay3, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay3, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay4, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay4, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay5, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay5, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay6, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay6, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay7, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay7, LOW); //Turn on relay
delay(2000);
digitalWrite(Relay8, HIGH); //Turn off relay
delay(2000);
digitalWrite(Relay8, LOW); //Turn on relay
delay(2000);
}




Control relay module with ethernet shield and some nice html shit

//for use with IDE 1.0


//open serial monitor to see what the arduino receives


//use the \ slash to escape the " in the html


//for use with W5100 based ethernet shields


// this project is hosted at


// [Link]




#include <SPI.h>


#include <Ethernet.h>










byte mac[] = { 0x90, 0xA2, 0xDA, 0x0D, 0x78, 0xE0 }; // <------- PUT YOUR MAC
Address Here


byte ip[] = { 192, 168, 1, 102 }; // <------- PUT YOUR IP
Address Here


byte gateway[] = { 192, 168, 1, 254 }; // <------- PUT YOUR ROUTERS
IP Address to which your shield is connected Here


byte subnet[] = { 255, 255, 255, 0 }; // <------- It will be as it
is in most of the cases


EthernetServer server(80); // <------- It's Defaulf
Server Port for Ethernet Shield




String readString;




//////////////////////




void setup()


{




pinMode(6, OUTPUT); // Pin Assignment through which relay will be controlled


pinMode(7, OUTPUT);


pinMode(8, OUTPUT);


pinMode(9, OUTPUT);








//start Ethernet





[Link](mac, ip, gateway, subnet);


[Link]();





//enable serial data print





[Link](9600);


[Link]("server LED test 1.0"); // so that we can know what is getting
loaded


}




void loop()


{








// Create a client connection




EthernetClient client = [Link]();


if (client) {


while ([Link]()) {


if ([Link]()) {


char c = [Link]();







//read char by char HTTP request


if ([Link]() < 100) {




//store characters to string


readString += c;


//[Link](c);


}




//if HTTP request has ended


if (c == '\n') {




///////////////


[Link](readString); //print to serial monitor for debuging




/* Start OF HTML Section. Here Keep everything as it is unless you
understands its working */





[Link]("HTTP/1.1 200 OK"); //send new page


[Link]("Content-Type: text/html");


[Link]();


//[Link]("<meta http-equiv=\"refresh\" content=\"5\">");




[Link]("<HTML>");


[Link]("<HEAD>");


[Link]("<meta name='apple-mobile-web-app-capable' content='yes'
/>");


[Link]("<meta name='apple-mobile-web-app-status-bar-style'
content='black-translucent' />");


[Link]("<link rel=\"stylesheet\" type=\"text/css\"
href=\"[Link] />");








[Link]("</HEAD>");


[Link]("<body bgcolor=\"#D0D0D0\">");





[Link]("<hr/>");


[Link]("<hr/>");


[Link]("<h4><center><img border=\"2\"
src=\"[Link]
C6BoJrRUFko/UEUFeCwkvdI/AAAAAAAAAOc/E7gcYvPV6r4/s960/[Link]\"
/></center></h4>");


[Link]("<hr/>");


[Link]("<hr/>");





[Link]("<br />");


[Link]("<br />");


[Link]("<br />");


[Link]("<br />");


[Link]("<br />");





// Relay Control Code


[Link]("<a href=\"/?relay1on\"\">Turn On Light 1</a>");


[Link]("<a href=\"/?relay1off\"\">Turn Off Light 1</a><br />");





[Link]("<br />");


[Link]("<br />");


[Link]("<br />");


[Link]("<br />");





[Link]("<a href=\"/?relay2on\"\">Turn On Light 2</a>");


[Link]("<a href=\"/?relay2off\"\">Turn Off Light 2</a><br />");





[Link]("<br />");


[Link]("<br />");


[Link]("<br />");


[Link]("<br />");





[Link]("<a href=\"/?relay3on\"\">Turn On Light 3</a>");


[Link]("<a href=\"/?relay3off\"\">Turn Off Light 3</a><br />");





[Link]("<br />");


[Link]("<br />");


[Link]("<br />");


[Link]("<br />");





[Link]("<a href=\"/?relay4on\"\">Turn On Light 4</a>");


[Link]("<a href=\"/?relay4off\"\">Turn Off Light 4</a><br />");




[Link]("<br />");


[Link]("<br />");














// control arduino pin via ethernet Start //








if([Link]("?relay1on") >0)//checks for on


{


digitalWrite(6, HIGH); // set pin 4 high


[Link]("Led On");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 1 Is On");


[Link]("<br />");


}


else{


if([Link]("?relay1off") >0)//checks for off


{


digitalWrite(6, LOW); // set pin 4 low


[Link]("Led Off");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 1 Is Off");


[Link]("<br />");


}


}





if([Link]("?relay2on") >0)//checks for on


{


digitalWrite(7, HIGH); // set pin 4 high


[Link]("Led On");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 2 Is On");


[Link]("<br />");


}


else{


if([Link]("?relay2off") >0)//checks for off


{


digitalWrite(7, LOW); // set pin 4 low


[Link]("Led Off");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 2 Is Off");


[Link]("<br />");


}


}





if([Link]("?relay3on") >0)//checks for on


{


digitalWrite(8, HIGH); // set pin 4 high


[Link]("Led On");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


// [Link]("Light 3 Is On");


[Link]("<br />");


}


else{


if([Link]("?relay3off") >0)//checks for off


{


digitalWrite(8, LOW); // set pin 4 low


[Link]("Led Off");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 3 Is Off");


[Link]("<br />");


}


}








if([Link]("?relay4on") >0)//checks for on


{


digitalWrite(9, HIGH); // set pin 4 high


[Link]("Led On");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 4 Is On");


[Link]("<br />");


}


else{


if([Link]("?relay4off") >0)//checks for off


{


digitalWrite(9, LOW); // set pin 4 low


[Link]("Led Off");


[Link]("<link rel='apple-touch-icon'
href='[Link] />");


//[Link]("Light 4 Is Off");


[Link]("<br />");


}


}





// control arduino pin via ethernet End //











// Relay Status Display


[Link]("<center>");


[Link]("<table border=\"5\">");


[Link]("<tr>");





if (digitalRead(6))


{


[Link]("<td>Light 1 is ON</td>");





}


else


{


[Link]("<td>Light 1 is OFF</td>");





}








[Link]("<br />");





if (digitalRead(7))


{


[Link]("<td>Light 2 is ON</td>");





}


else


{


[Link]("<td>Light 2 is OFF</td>");





}





[Link]("</tr>");


[Link]("<tr>");





if (digitalRead(8))


{


[Link]("<td>Light 3 is ON</td>");





}


else


{


[Link]("<td>Light 3 is OFF</td>");





}














if (digitalRead(9))


{


[Link]("<td>Light 4 is ON</td>");





}


else


{


[Link]("<td>Light 4 is OFF</td>");





}





[Link]("</tr>");


[Link]("</table>");





[Link]("</center>");











//clearing string for next read





readString="";




[Link]("</body>");


[Link]("</HTML>");




delay(1);


//stopping client


[Link]();




}


}


}


}


}




Observatie: se alege orice adresa la shieldul ethernet pt arduino, adica alegem
ce ip vrem noi unde ne cereyour ip;





Cod modul relee

/* Used Arduino Mega pins and Relay ones
- D46 > In1, D47 > In2, D48 > In3, D49 > In4, D50 > In5, D51 > In6, D52 > In7, D53
> In8
- VCC > 5V
- I GND on Relay board > Arduino's GND
- II GND on Relay board > External Power source's GND (If you use external power
source) */

void setup(){
for(int i=46; i<=53; i++){
pinMode(i, OUTPUT);
}
}

void loop(){
for(int i=46; i<=53; i++){
int z = i-45;
digitalWrite(i, LOW);
delay(z*20);
digitalWrite(i, HIGH);
delay(z*20);
}
}



Cod de test modul 8 relee pare sa fuctioneze

int relay1 = 35;
int relay2 = 37;
int relay3 = 39;
int relay4 = 41;
int relay5 = 43;
int relay6 = 45;
int relay7 = 47;
int relay8 = 49;
int i = 1000;

void setup() {
pinMode(relay1, OUTPUT);
pinMode(relay2, OUTPUT);
pinMode(relay3, OUTPUT);
pinMode(relay4, OUTPUT);
pinMode(relay5, OUTPUT);
pinMode(relay6, OUTPUT);
pinMode(relay7, OUTPUT);
pinMode(relay8, OUTPUT);
}
void loop() {
digitalWrite(relay1, HIGH);
digitalWrite(relay2, HIGH);
digitalWrite(relay3, HIGH);
digitalWrite(relay4, HIGH);
digitalWrite(relay5, HIGH);
digitalWrite(relay6, HIGH);
digitalWrite(relay7, HIGH);
digitalWrite(relay8, HIGH);
if (i >= 5){
delay(i);
digitalWrite(relay1, LOW);
delay(i);
digitalWrite(relay1, HIGH);
delay(i);
digitalWrite(relay2, LOW);
delay(i);
digitalWrite(relay2, HIGH);
delay(i);
digitalWrite(relay3, LOW);
delay(i);
digitalWrite(relay3, HIGH);
delay(i);
digitalWrite(relay4, LOW);
delay(i);
digitalWrite(relay4, HIGH);
delay(i);
digitalWrite(relay5, LOW);
delay(i);
digitalWrite(relay5, HIGH);
delay(i);
digitalWrite(relay6, LOW);
delay(i);
digitalWrite(relay6, HIGH);
delay(i);
digitalWrite(relay7, LOW);
delay(i);
digitalWrite(relay7, HIGH);
delay(i);
digitalWrite(relay8, LOW);
delay(i);
digitalWrite(relay8, HIGH);
i = i/2;
}
else{
i = 1000;
}
}








Sketch pentru PIR

// [Link]
infrared-sensor-with-arduino/
// [Link]
// [Link]
[Link]

#define pir A0
#define led 13

void setup() {
[Link](9600);
pinMode(pir, INPUT);
pinMode(led, OUTPUT);
}

void loop() {
int val = analogRead(pir);
float val1 = val*5.00/1023.00;
digitalWrite(led, LOW);
if (val <650) {
[Link](val);
[Link]("/1023 = ");
[Link](val1);
[Link]("V - No motion"); //if the value read is low, there was
no motion

}
else {
[Link](val);
[Link]("/1023 = ");
[Link](val1);
[Link]("V - Motion!"); //if the value read was high, there was
motion
digitalWrite(led, HIGH);
}
delay(500);
}



Pentru senzori de temperatura
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 10 on the Arduino
#define ONE_WIRE_BUS 10
#define TEMPERATURE_PRECISION 12

// Setup a oneWire instance to communicate with any OneWire devices (not ju
st Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// arrays to hold device addresses
DeviceAddress rightThermometer, midleThermometer, leftThermometer;


void setup(void)
{
// start serial port
[Link](9600);
[Link]("Dallas Temperature IC Control Library use by niq_ro");
[Link]("---------------------------------------------------");

// Start up the library
[Link]();
DeviceAddress rightThermometer = { 0x28, 0xAC, 0x7A, 0xD4, 0x4, 0x0, 0x0,
0x7E };
DeviceAddress midleThermometer = { 0x28, 0xF5, 0xFB, 0x58, 0x5, 0x0, 0x0,
0xA0 };
DeviceAddress leftThermometer = { 0x28, 0xCB, 0xF0, 0x58, 0x5, 0x0, 0x0,
0x2E };


// method 1: by index
if () [Link]("Unable to
find address for Device 0");
if () [Link]("Unable to
find address for Device 1");
if () [Link]("Unable to
find address for Device 2");


// show the addresses we found on the bus
[Link]("Device 0 Address: ");
printAddress(rightThermometer);
[Link]();

[Link]("Device 1 Address: ");
printAddress(midleThermometer);
[Link]();

[Link]("Device 2 Address: ");
printAddress(leftThermometer);
[Link]();


// set the resolution to 9..12 bit
[Link](rightThermometer, TEMPERATURE_PRECISION);
[Link](midleThermometer, TEMPERATURE_PRECISION);
[Link](leftThermometer, TEMPERATURE_PRECISION);

/*
[Link]("Device 0 Resolution: ");
[Link]([Link](rightThermometer), DEC);
[Link]();

[Link]("Device 1 Resolution: ");
[Link]([Link](midleThermometer), DEC);
[Link]();

[Link]("Device 2 Resolution: ");
[Link]([Link](leftThermometer), DEC);
[Link]();
*/
}


// function to print a device address
void printAddress(DeviceAddress device)
{
for (uint8_t i = 0; i < 8; i++)
{
// zero pad the address if necessary
if (device[i] < 16) [Link]("0");
[Link](device[i], HEX);
}
[Link](" - ");
}

// function to print the temperature for a device
void printTemperature(DeviceAddress device)
{
float tempC = [Link](device);
[Link]("Temp C: ");
if (tempC == -127.00) {
[Link]("Error");
} else {
[Link](tempC);
[Link](" Temp F: ");
[Link](DallasTemperature::toFahrenheit(tempC));
}
}
// function to print a device's resolution
void printResolution(DeviceAddress device)
{
[Link]("Resolution: ");
[Link]([Link](device));
[Link]();
}

// main function to print information about a device
void printData(DeviceAddress device)
{
[Link]("Address: ");
printAddress(device);
[Link](" ");
printTemperature(device);
[Link]();
}

void loop(void)
{
DeviceAddress rightThermometer = { 0x28, 0xAC, 0x7A, 0xD4, 0x4, 0x0, 0x0,
0x7E };
DeviceAddress midleThermometer = { 0x28, 0xF5, 0xFB, 0x58, 0x5, 0x0, 0x0,
0xA0 };
DeviceAddress leftThermometer = { 0x28, 0xCB, 0xF0, 0x58, 0x5, 0x0, 0x0,
0x2E };

// call [Link]() to issue a global temperature
// request to all devices on the bus
[Link]("---------------------------------------");
[Link](" ");
[Link]("Requesting temperatures...");
[Link]();
[Link]("DONE");
[Link]("---------------------------------------");
[Link](" ");

// print the device information
[Link]("Device DS18B20 (right) ");
printData(rightThermometer);
[Link]("---------------------------------------");
[Link]("Device MAX31820 (center) ");
printData(midleThermometer);
[Link]("---------------------------------------");
[Link]("Device MAX31820 (left) ");
printData(leftThermometer);
[Link]("---------------------------------------");
delay(3000);
}


Variator de tensiune pentru bec cu Arduino (VII)

/*
AC Light Control
Updated by Robert Twomey <rtwomey@[Link]>
Thanks to [Link]
and [Link]
adapted sketch by niq_ro from
[Link]
[Link]
[Link]

IR Remote Kit Test
Uses [Link] IR Infrared Remote Control Kit 2
[Link]
based on code by Ken Shirriff - [Link]
Get Library at: [Link]

Bluetooth:
// adapted sketch from [Link]
*/

#include <LiquidCrystal.h>
// use LiquidCrystal.h library for alphanumerical display 1602
LiquidCrystal lcd(13,12,11,10,9,8);
/* -------------------
| LCD | Arduino |
-------------------
LCD RS pin to digital pin 13 | RS | D13 |
LCD Enable pin to digital pin 12 | E | D12 |
LCD D4 pin to digital pin 11 | D4 | D11 |
LCD D5 pin to digital pin 10 | D5 | D10 |
LCD D6 pin to digital pin 9 | D6 | D9 |
LCD D7 pin to digital pin 8 | D7 | D8 |
LCD R/W pin to ground | R/W | GND |
-------------------
*/

#include "IRremote.h"
//-----( Declare Constants )-----
int receiver = 7; // pin 1 of IR receiver to Arduino digital pin 7
//-----( Declare objects )-----
IRrecv irrecv(receiver); // create instance of 'irrecv'
decode_results results; // create instance of 'decode_results'
//-----( Declare Variables )-----


#include <TimerOne.h> // Avaiable from
[Link]

volatile int i=0; // Variable to use as a counter
volatile boolean zero_cross=0; // Boolean to store a "switch" to tell us if we
have crossed zero
int AC_pin = 3; // Output to Opto Triac
int buton1 = 4; // first button at pin 4
int buton2 = 5; // second button at pin 5
int dim2 = 0; // led control
int dim = 128; // Dimming level (0-128) 0 = on, 128 = 0ff
int pas = 8; // step for count;
// version: 4m7 (15.04.2013 - Craiova, Romania) -
16 steps, 4 button & LED blue to red (off to MAX)
// version: 7m6.1 (23.01.2014 - Craiova, Romania) - 16 steps, 2 button & LCD1602

int freqStep = 75; // This is the delay-per-brightness step in microseconds.

char incomingByte; // incoming data from serial 9bluetooth)

void setup() { // Begin setup

[Link](9600); // initialization

[Link](); // Start the IR receiver (classic remote)

pinMode(buton1, INPUT); // set buton1 pin as input
pinMode(buton2, INPUT); // set buton1 pin as input
pinMode(AC_pin, OUTPUT); // Set the Triac pin as output
attachInterrupt(0, zero_cross_detect, RISING); // Attach an Interupt to Pin 2
(interupt 0) for Zero Cross Detection
[Link](freqStep); // Initialize TimerOne library
for the freq we need
[Link](dim_check, freqStep);
// Use the TimerOne Library to attach an interrupt

[Link](16, 2); // set up the LCD's number of columns and rows:
[Link](); // clear the screen
[Link](2, 0); // put cursor at colon 0 and row 0
[Link]("16 steps AC"); // print a text
[Link](0, 1); // put cursor at colon 0 and row 1
[Link]("dimmer for bulb"); // print a text
delay (3000);
[Link](); // clear the screen
[Link](1, 0); // put cursor at colon 0 and row 0
[Link]("this sketch is"); // print a text
[Link](1, 1); // put cursor at colon 0 and row 1
[Link]("made by niq_ro"); // print a text
delay (3000);
[Link](); // clear the screen
}

void zero_cross_detect() {
zero_cross = true; // set the boolean to true to tell our dimming
function that a zero cross has occured
i=0;
digitalWrite(AC_pin, LOW);
}

// Turn on the TRIAC at the appropriate time
void dim_check() {
if(zero_cross == true) {
if(i>=dim) {
digitalWrite(AC_pin, HIGH); // turn on light
i=0; // reset time step counter
zero_cross=false; // reset zero cross detection
}
else {
i++; // increment time step counter
}
}
}


//-----( Declare User-written Functions )-----
void translateIR() // takes action based on IR code received

// describing Car MP3 IR codes
{
switch([Link])
{
case 0xFFA25D:
[Link](" CH- ");
break;

case 0xFF629D:
[Link](" CH ");
break;

case 0xFFE21D:
[Link](" CH+ ");
break;

case 0xFF22DD:
{
[Link](" PREV ");
dim=128;
}
break;

case 0xFF02FD:
{
[Link](" NEXT ");
dim=0;
}
break;

case 0xFFC23D:
[Link](" PLAY/PAUSE ");
break;

case 0xFFE01F:
{
[Link](" VOL- ");
if (dim<127)
{
dim = dim + pas;
if (dim>127)
{
dim=128; // in vechiul sketch era 127
}
}
}
break;

case 0xFFA857:
{
[Link](" VOL+ ");
{
if (dim>5)
{
dim = dim - pas;
if (dim<0)
{
dim=0; // in vechiul sketch era 1
}
}
}
}
break;

case 0xFF906F:
[Link](" EQ ");
break;

case 0xFF6897:
{
[Link](" 0 ");
// analogWrite(ledr, 0);
// analogWrite(leda, 0);
// analogWrite(ledv, 0);
}
break;

case 0xFF9867:
[Link](" 100+ ");
break;

case 0xFFB04F:
[Link](" 200+ ");
break;

case 0xFF30CF:
{
[Link](" 1 ");
// analogWrite(leda, 255);
}
break;

case 0xFF18E7:
{
[Link](" 2 ");
// analogWrite(ledv, 255);
}
break;

case 0xFF7A85:
{
[Link](" 3 ");
// analogWrite(ledr, 255);
}
break;

case 0xFF10EF:
{
[Link](" 4 ");
// analogWrite(leda, 122);
}
break;

case 0xFF38C7:
{
[Link](" 5 ");
// analogWrite(ledv, 122);
}
break;

case 0xFF5AA5:
{
[Link](" 6 ");
// analogWrite(ledr, 122);
}
break;

case 0xFF42BD:
{
[Link](" 7 ");
// analogWrite(leda, 0);
}
break;

case 0xFF4AB5:
{
[Link](" 8 ");
// analogWrite(ledv, 0);
}
break;

case 0xFF52AD:
{
[Link](" 9 ");
// analogWrite(ledr, 0);
}
break;

default:
[Link](" other button ");

}

}

void blustuf()
{
incomingByte = [Link](); // read byte
if(incomingByte == '0') {
}
if(incomingByte == '1') {
}
if(incomingByte == '2') {
}
if(incomingByte == '3') {
}
if(incomingByte == '4') {
}
if(incomingByte == '5') {
}
if(incomingByte == '6') {
}
if(incomingByte == '7') {
}
if(incomingByte == 'a') { //step up
if (dim<127)
{
dim = dim + pas;
if (dim>127)
{
dim=128;
}
}
}

if(incomingByte == 's') { //step down
if (dim>5)
{
dim = dim - pas;
if (dim<0)
{
dim=0;
}
}
}

if(incomingByte == 'w') { // power is 100%
dim=0;
}
if(incomingByte == 'z') { // power is 0% (off)
dim=128;
}
}

void stelute()
{
if (dim2<1) [Link]("----------------");
else
if (dim2<9) [Link]("*---------------");
else
if (dim2<17) [Link]("-*--------------");
else
if (dim2<25) [Link]("--*-------------");
else
if (dim2<33) [Link]("---*------------");
else
if (dim2<41) [Link]("----*-----------");
else
if (dim2<49) [Link]("-----*----------");
else
if (dim2<57) [Link]("------*---------");
else
if (dim2<65) [Link]("-------*--------");
else
if (dim2<73) [Link]("--------*-------");
else
if (dim2<81) [Link]("---------*------");
else
if (dim2<89) [Link]("----------*-----");
else
if (dim2<97) [Link]("-----------*----");
else
if (dim2<105) [Link]("------------*---");
else
if (dim2<113) [Link]("-------------*--");
else
if (dim2<121) [Link]("--------------*-");
else
if (dim2>127) [Link]("---------------*");
}


void loop() {
digitalWrite(buton1, HIGH);
digitalWrite(buton2, HIGH);

if ([Link]() > 0) blustuf(); // if bluetooth is present

if (digitalRead(buton1) == LOW)
{
if (dim<127)
{
dim = dim + pas;
if (dim>127)
{
dim=128; // in vechiul sketch era 127
}
}
}
if (digitalRead(buton2) == LOW)
{
if (dim>5)
{
dim = dim - pas;
if (dim<0)
{
dim=0; // in vechiul sketch era 1
}
}
}
while (digitalRead(buton1) == LOW) { }
delay(10); // waiting little bit...
while (digitalRead(buton2) == LOW) { }
delay(10); // waiting little bit...


// remote
if ([Link](&results)) // have we received an IR signal?
{
translateIR();
[Link](); // receive the next value
}

delay (100);
[Link](2, 0); // put cursor at colon 0 and row 0
[Link]("power is "); // print a text
[Link](100*(128-dim)/128);
[Link]("% "); // print a text

[Link](0, 1); // put cursor at colon 0 and row 1

dim2=128-dim; // variable use for graphics
stelute();
}