[text] paste 3

Viewer

  1. Basic led blink
  2.  
  3. int led_red = 0;
  4. int led_yellow = 1;
  5. int led_green = 2; 
  6. void setup() {
  7.  
  8.   pinMode(led_red, OUTPUT);
  9.   pinMode(led_yellow, OUTPUT);
  10.   pinMode(led_green, OUTPUT);
  11. }
  12.  
  13. void loop() {
  14.  
  15.   digitalWrite(led_red, LOW); 
  16.   digitalWrite(led_yellow, LOW);
  17.   digitalWrite(led_green, HIGH);
  18.   delay(2000);     
  19.  
  20.   digitalWrite(led_red, LOW);   
  21.   digitalWrite(led_yellow, HIGH);
  22.   digitalWrite(led_green, LOW);
  23.   delay(1000);   // espera 1 segundo 
  24.   
  25.    digitalWrite(led_red, HIGH);  
  26.   digitalWrite(led_yellow, LOW);
  27.   digitalWrite(led_green, LOW);
  28.   delay(3000);    
  29. }
  30.  
  31.  
  32. Push button
  33.  
  34. const int buttonPin = 2;  // the number of the pushbutton pin
  35. const int ledPin = 13;    // the number of the LED pin
  36.  
  37. // variables will change:
  38. int buttonState = 0;  // variable for reading the pushbutton status
  39.  
  40. void setup() {
  41.   // initialize the LED pin as an output:
  42.   pinMode(ledPin, OUTPUT);
  43.   // initialize the pushbutton pin as an input:
  44.   pinMode(buttonPin, INPUT);
  45. }
  46.  
  47. void loop() {
  48.   // read the state of the pushbutton value:
  49.   buttonState = digitalRead(buttonPin);
  50.  
  51.   // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  52.   if (buttonState == HIGH) {
  53.     // turn LED on:
  54.     digitalWrite(ledPin, HIGH);
  55.   } else {
  56.     // turn LED off:
  57.     digitalWrite(ledPin, LOW);
  58.   }
  59. }
  60.  
  61.  
  62.  
  63. LED blink with POT
  64.  
  65.  
  66. #define LED_PIN 11
  67. #define POTENTIOMETER_PIN A1
  68. void setup()
  69. {
  70.  pinMode(LED_PIN, OUTPUT);
  71. }
  72. void loop()
  73. {
  74.  int potentiometerValue = analogRead(POTENTIOMETER_PIN);
  75.  int brightness = potentiometerValue / 4;
  76.  analogWrite(LED_PIN, brightness);
  77. }
  78.  
  79.  
  80.  
  81. Dist using ultrasonic sensor & objects
  82.  
  83.  
  84. int trigger = 12; //KUNING TRIG
  85. int echo = 13; //PIN 13 ECHO
  86. int led = 8;
  87.  
  88. long duration = 0;
  89. int cm = 0;
  90. int inch = 0;
  91.  
  92. void setup() {
  93.   // put your setup code here, to run once:
  94.   Serial.begin(9600);
  95.   pinMode(trigger, OUTPUT);
  96.   pinMode(echo, INPUT);
  97.   pinMode(led, OUTPUT);
  98. }
  99.  
  100. void loop() {
  101.   // put your main code here, to run repeatedly:
  102.   digitalWrite(trigger, LOW);
  103.   digitalWrite(trigger, HIGH);
  104.   digitalWrite(trigger, LOW);
  105.  
  106.   duration = pulseIn(echo, HIGH);
  107.   cm = duration*0.034/2;
  108.   inch = duration*0.0133/2;
  109.  
  110.   if (inch < 50){
  111.     digitalWrite(led, HIGH);
  112.   } else {
  113.     digitalWrite(led, LOW);
  114.   }
  115.  
  116.   if (inch < 100 ) {
  117.     Serial.print("Inches: ");
  118.     Serial.println(inch);
  119.     Serial.print("Cm: ");
  120.     Serial.println(cm);
  121.   }
  122.   delay(500);
  123. }
  124.  
  125.  
  126.  
  127. 2-way traffic
  128.  
  129. // Define pin numbers
  130. #define trigPin 9
  131. #define echoPin 10
  132. #define red1Pin 2
  133. #define yellow1Pin 3
  134. #define green1Pin 4
  135. #define red2Pin 5
  136. #define yellow2Pin 6
  137. #define green2Pin 7
  138.  
  139. void setup() {
  140.   // Initialize pins
  141.   pinMode(trigPin, OUTPUT);
  142.   pinMode(echoPin, INPUT);
  143.   pinMode(red1Pin, OUTPUT);
  144.   pinMode(yellow1Pin, OUTPUT);
  145.   pinMode(green1Pin, OUTPUT);
  146.   pinMode(red2Pin, OUTPUT);
  147.   pinMode(yellow2Pin, OUTPUT);
  148.   pinMode(green2Pin, OUTPUT);
  149. }
  150.  
  151. void loop() {
  152.   // Measure distance
  153.   long duration, distance;
  154.   digitalWrite(trigPin, LOW);
  155.   delayMicroseconds(2);
  156.   digitalWrite(trigPin, HIGH);
  157.   delayMicroseconds(10);
  158.   digitalWrite(trigPin, LOW);
  159.   duration = pulseIn(echoPin, HIGH);
  160.   distance = (duration * 0.0343) / 2; // Speed of sound is 343 m/s
  161.   
  162.   // Traffic light control logic
  163.   if (distance < 50) { // Adjust threshold as needed
  164.     // Vehicles detected, switch lights
  165.     digitalWrite(green1Pin, LOW);
  166.     digitalWrite(yellow1Pin, HIGH);
  167.     delay(2000);
  168.     digitalWrite(yellow1Pin, LOW);
  169.     digitalWrite(red1Pin, HIGH);
  170.     
  171.     digitalWrite(green2Pin, HIGH);
  172.     digitalWrite(red2Pin, LOW);
  173.     delay(5000);
  174.   } else {
  175.     // No vehicles detected, normal light sequence
  176.     digitalWrite(red1Pin, LOW);
  177.     digitalWrite(yellow1Pin, HIGH);
  178.     delay(2000);
  179.     digitalWrite(yellow1Pin, LOW);
  180.     digitalWrite(green1Pin, HIGH);
  181.     
  182.     digitalWrite(green2Pin, LOW);
  183.     digitalWrite(yellow2Pin, HIGH);
  184.     delay(2000);
  185.     digitalWrite(yellow2Pin, LOW);
  186.     digitalWrite(red2Pin, HIGH);
  187.     
  188.     delay(5000);
  189.   }
  190. }
  191.  
  192.  
  193.  
  194. 4-way traffic light
  195.  
  196.  
  197. int d_red =10;
  198. int d_yellow =9;
  199. int d_green =8;
  200. int r_red =4;
  201. int r_yellow =3;
  202. int r_green =2;
  203. int l_red =13;
  204. int l_yellow =12;
  205. int l_green =11;
  206. int u_red =7;
  207. int u_yellow =6;
  208. int u_green =5;
  209. void setup()
  210. {
  211. pinMode(d_red, OUTPUT);
  212. pinMode(d_yellow, OUTPUT);
  213. pinMode(d_green, OUTPUT);
  214. pinMode(r_red, OUTPUT);
  215. pinMode(r_yellow, OUTPUT);
  216. pinMode(r_green, OUTPUT);
  217. pinMode(l_red, OUTPUT);
  218. pinMode(l_yellow, OUTPUT);
  219. pinMode(l_green, OUTPUT);
  220. pinMode(u_red, OUTPUT);
  221. pinMode(u_yellow, OUTPUT);
  222. pinMode(u_green, OUTPUT);
  223. }
  224. void loop()
  225. {
  226. changeLights();
  227. }
  228. void changeLights()
  229. {
  230. //Start (all yellow)
  231. digitalWrite(u_red,LOW);
  232. digitalWrite(d_red,LOW);
  233. digitalWrite(r_red,LOW);
  234. digitalWrite(l_green,LOW);
  235. digitalWrite(u_yellow,HIGH);
  236. digitalWrite(d_yellow,HIGH);
  237. digitalWrite(r_yellow,HIGH);
  238. digitalWrite(l_yellow,HIGH);
  239. delay(5000);
  240.  
  241. //upper lane go
  242. digitalWrite(u_yellow,LOW);
  243. digitalWrite(d_yellow,LOW);
  244. digitalWrite(r_yellow,LOW);
  245. digitalWrite(l_yellow,LOW);
  246. digitalWrite(u_green,HIGH);
  247. digitalWrite(r_red,HIGH);
  248. digitalWrite(l_red,HIGH);
  249. digitalWrite(d_red,HIGH);
  250. delay(10000);
  251.  
  252. //ALL YELLOW
  253. digitalWrite(u_yellow,HIGH);
  254. digitalWrite(d_yellow,HIGH);
  255. digitalWrite(r_yellow,HIGH);
  256. digitalWrite(l_yellow,HIGH);
  257. digitalWrite(u_green,LOW);
  258. digitalWrite(r_red,LOW);
  259. digitalWrite(l_red,LOW);
  260. digitalWrite(d_red,LOW);
  261. delay(5000);
  262.  
  263. //RIGHT LANE GO
  264. digitalWrite(u_yellow,LOW);
  265. digitalWrite(d_yellow,LOW);
  266. digitalWrite(r_yellow,LOW);
  267. digitalWrite(l_yellow,LOW);
  268. digitalWrite(u_red,HIGH);
  269. digitalWrite(l_red,HIGH);
  270. digitalWrite(d_red,HIGH);
  271. digitalWrite(r_green,HIGH);
  272. delay(10000);
  273.  
  274. //ALL YELLOW ON
  275. digitalWrite(u_yellow,HIGH);
  276. digitalWrite(d_yellow,HIGH);
  277. digitalWrite(r_yellow,HIGH);
  278. digitalWrite(l_yellow,HIGH);
  279. digitalWrite(u_red,LOW);
  280. digitalWrite(l_red,LOW);
  281. digitalWrite(d_red,LOW);
  282. digitalWrite(r_green,LOW);
  283. delay(5000);
  284.  
  285. //DOWN LANE GO
  286. digitalWrite(u_yellow,LOW);
  287. digitalWrite(d_yellow,LOW);
  288. digitalWrite(r_yellow,LOW);
  289. digitalWrite(l_yellow,LOW);
  290. digitalWrite(u_red,HIGH);
  291. digitalWrite(l_red,HIGH);
  292. digitalWrite(r_red,HIGH);
  293. digitalWrite(d_green,HIGH);
  294. delay(10000);
  295.  
  296. //ALL YELLOW
  297. digitalWrite(u_yellow,HIGH);
  298. digitalWrite(d_yellow,HIGH);
  299. digitalWrite(r_yellow,HIGH);
  300. digitalWrite(l_yellow,HIGH);
  301. digitalWrite(u_red,LOW);
  302. digitalWrite(l_red,LOW);
  303. digitalWrite(r_red,LOW);
  304. digitalWrite(d_green,LOW);
  305. delay(5000);
  306.  
  307. //LEFT LANE GO
  308. digitalWrite(u_yellow,LOW);
  309. digitalWrite(d_yellow,LOW);
  310. digitalWrite(r_yellow,LOW);
  311. digitalWrite(l_yellow,LOW);
  312. digitalWrite(u_red,HIGH);
  313. digitalWrite(d_red,HIGH);
  314. digitalWrite(r_red,HIGH);
  315. digitalWrite(l_green,HIGH);
  316. delay(10000);
  317.  
  318. }
  319.  
  320.  
  321. Obstacle avoidance
  322.  
  323.  
  324. const int trigPin=13;
  325. const int echoPin=12;
  326. const int in1=2;
  327. const int in2=3;
  328. const int in3=4;
  329. const int in4=5;
  330.  
  331. void setup(){
  332.   pinMode(trigPin, OUTPUT);
  333.   pinMode(echoPin, INPUT);
  334.   pinMode(in1, OUTPUT);
  335.   pinMode(in2, OUTPUT);
  336.   pinMode(in3, OUTPUT);
  337.   pinMode(in4, OUTPUT);
  338.   Serial.begin(9600);
  339. }
  340. long duration;
  341. int distance;
  342. void loop(){
  343.   digitalWrite(trigPin, LOW);
  344.   delay(2);
  345.   digitalWrite(trigPin, HIGH);
  346.   delay(10);
  347.   digitalWrite(trigPin, LOW);
  348.   duration=pulseIn(echoPin, HIGH);
  349.   distance=duration*0.034/2;
  350.   Serial.println(distance);
  351.  
  352.   if(distance<50) {
  353.     digitalWrite(in1, HIGH);
  354.     digitalWrite(in2, LOW);
  355.     digitalWrite(in3, LOW);
  356.     digitalWrite(in4, LOW);
  357.   }
  358.   else{
  359.     digitalWrite(in1, HIGH);
  360.     digitalWrite(in2, LOW);
  361.     digitalWrite(in3, HIGH);
  362.     digitalWrite(in4, LOW);
  363.   }
  364.   delay(200);
  365. }
  366.  
  367.  
  368.  
  369.  
  370.  
  371. Home automation using bluetooth HC-05
  372.  
  373.  
  374.  int tx=1;
  375. int rx=0;
  376. int r=11;
  377. int reds=0;
  378. int bs=0;
  379. int gs=0;
  380. int b=12;
  381. int g=6;
  382. int ser;
  383. int relay1=8;
  384. int relay2=9;
  385.  
  386. void setup() {
  387.   // put your setup code here, to run once:
  388. pinMode(r,OUTPUT);
  389. pinMode(g,OUTPUT);
  390. pinMode(b,OUTPUT);
  391. pinMode(relay1,OUTPUT);
  392. pinMode(relay2,OUTPUT); 
  393. Serial.begin(9600);
  394. }
  395.  
  396. void loop() {
  397.   // put your main code here, to run repeatedly:
  398.  
  399.  
  400.  
  401.  
  402.   
  403.  if(Serial.available()>0)
  404. {ser=Serial.read();
  405. Serial.println(ser);
  406.  
  407.  if(reds== 0 && ser ==255 )
  408. {
  409.   digitalWrite(r,HIGH);
  410.   digitalWrite(relay1,HIGH );
  411.   Serial.println("BULB 1 ON");
  412.   ser = 0;
  413.   reds = 1;
  414.   }
  415. if(ser == 255 && reds== 1 )
  416. {
  417.   digitalWrite(r,LOW);
  418.   digitalWrite(relay1,LOW );
  419.    Serial.println("BULB 1 OFF");
  420.     ser = 0;
  421.   reds = 0;
  422.   }
  423.   
  424.  if( bs== 0 && ser ==254 )
  425. {
  426.   digitalWrite(b,HIGH);
  427.   digitalWrite(relay2,HIGH );
  428.   Serial.println("BULB 2 ON");
  429.   ser = 0;
  430.   bs = 1;
  431.   }
  432. if(  bs== 1 && ser ==254)
  433. {
  434.   digitalWrite(b,LOW);
  435.   digitalWrite(relay2,LOW );
  436.     Serial.println("BULB 2 OFF");
  437.     ser = 0;
  438.   bs = 0;
  439.   } 
  440.  
  441. if(gs== 0 && ser== 249 )
  442. {
  443.   digitalWrite(g,HIGH);
  444.   ser = 0;
  445.   gs = 1;
  446.   }
  447. if(gs== 1 && ser == 249 )
  448. {
  449.   digitalWrite(g,LOW);
  450.     ser = 0;
  451.   gs = 0;
  452.   }
  453.  
  454. }
  455.  
  456. }
  457.  

Editor

You can edit this paste and save as new:


File Description
  • paste 3
  • Paste Code
  • 29 Apr-2024
  • 8.93 Kb
You can Share it: