Lab_5.txt.rtfLab_05Design an application that reads the .docx

Lab_5.txt.rtf
/*
Lab_05
Design an application that reads the status of pin 2 that is
attached to a switch.
This status of pin 2 should be reflected on pin 3 with a LED.
Please utilize structured programming methodology.
9/10/2014
*/
const int buttonPin = 2; // the pin that the pushbutton is
attached to
const int ledPin = 3; // the pin that the LED is attached to
// Variables will change:
int buttonState = 0; // current state of the button
void setup()
{
// initialize the button pin as a output:
pinMode(buttonPin, OUTPUT);
// initialize the LED as an input:
pinMode(ledPin, INPUT);
Serial.begin(9600);
}
int main()

{
setup();
while(1)
{
buttonState = function_in();
function_out(buttonState);
}
return 0;
}
int function_in(void)
{
int bs=digitalRead(buttonPin);
return bs;
}
void function_out(int buttonState_1)
{
// check if the pushbutton is pressed
// if it is, the pushbuttonState is HIGH:
if (buttonState_1 == HIGH)
{
// turn LED on:
digitalWrite(ledPin, HIGH);
}
else
{
// turn LED off:
digitalWrite(ledPin, LOW);
}
}
Lab_06.txt.rtf

/*
Lab_06
Repeating lab_04 with standard C format
more formalized
Label definition with formal function declaration
function calls
body of functions clearly demarcated
9/10/2014
*/
// constants won’t change. They’re used here to
// set pin numbers:
// the # define construct is a compiler pre-processor directive.
// the value is substituted for the name, wherever the name
occurs
//in the source code. So, something like:
# define buttonPin 2 // the number of the pushbutton pin
# define ledPin 3 // the number of the led pin
// function declarations
void setup(void);
int function_in(void);
void function_out(int);
int main()
{
int buttonState = 0; // variable for reading for the
pushbutton status
setup();
while(1)
{

// function call without arguments:
// function call without argument
}
return 0;
}
{
int bs = digitalRead(buttonPin);
return bs;
}
void function_out( int buttonState_1)
{
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if(buttonState_1==HIGH)
{
// trun LED on:
}
else
{
// turn LED off:
}
}
Lab_07.txt
/*
Lab_07
The applcation is going to blink first leds attched 3 times
and then make next 3 led five times.

Date: 09/15/2014
*/
// Pin 13 has an LED connected on most Arduino boards.
// Pin 12 has the LED on Teensy 2.0
// Pin 11 has the LED on Teensy++ 2.0
// Pin 8 has the LED on Teensy++ 2.0
// give it a name:
int led13 = 13;
int led12 = 12;
int led11 = 11;
int led10 = 10;
int led9 = 9;

int led8= 8;
int main()
{
initial();
while(1)
{
function_1();
}
}
void step()
{
init();
pinMode(led8, OUTPUT);

}
int function_1()
{
for (int i = 0; i<3; i ++)
{
function_01();
}
for (int i = 0; i<5; i ++)
{
function_02();
}
}
void function_01()
{

digitalWrite(led8, HIGH); // turn the LED on (HIGH is the
voltage level)
voltage level)
voltage level)
delay(1000);
digitalWrite(led8, LOW); // turn the LED on (HIGH is the
voltage level)
voltage level)
voltage level)

}
void function_02()
{
voltage level)
voltage level)
voltage level)
delay(1000); // wait for a second
voltage level)

voltage level)
voltage level)
delay(1000); // wait for a second
}
__MACOSX/._Lab_07.txt
Lab_15.txt
/*
Lab N0 15
Design an application that will recive the analog single
from a port connected to 0 -5 volts. The center tap of of the port
is connected to ADC0

A(0). The appliction is going to have a control LED connected
and would be off for all the other inputs. capture the analog
signal, conversts the analog value
to digital value and by proper range conersion perform the
above described control of the LED.The staus of the LED is to
be reported on the serial monitor.
Date: 10/06/2104
*/
#include <avr/io.h>
#include <util/delay.h>
#define ledPin 13
void setup(void);

void my_analog (int *, int *);
void my_serial (int *);
void my_fun (int *);
int main()
{
setup();
int sensorPin = A0; // select the input pin for the potentionmeter
int sensorValue = 0; // variable to store the value coming from
the sesor
while(1)
{
my_analog(&sensorPin, &sensorValue);
my_serial(&sensorValue);

my_fun (&sensorValue);
}
}
void setup (void)
{
init();
Serial.begin (9600);
pinMode(ledPin, OUTPUT);
}
void my_analog (int *p1, int *p2)
{
*p2 = analogRead (*p1);
}

void my_fun(int *p22)
{
if(*p22 > 2.0 && *p22 < 3.0)
{
}
else
{
}
}
void my_serial (int *p3)
{
// serial.println(sensorValue);

Serial.print("Voltage:");
Serial.println((*p3 *5.0)/1023);
}
Lab_04.txt.rtf
/*
Lab_04
Design an application that reads the status of pin 2 that is
Please utilize structured programming methodology.
9/08/2014
*/
// set pin numbers:
attached to
// Pin 13: Arduino has an LED connected on pin 13
// Pin 11: Teensy 2.0 has the LED on pin 11
// Pin 6: Teensy+2.0 has the LED on pin 6

// Pin 13: Teensy 3.0 has the LED on pin 13
int buttonState = 0; // variable for reading the pushbutton
status
void setup()
{
// initialize the LED pin as a output:
// initialize the pushbutton as an input:
pinMode(buttonPin, INPUT);
}
void loop()
{
//function call with a single argument
}
{
int bs = digitalRead(buttonPin);
return bs;
}
{
if(buttonState_1 == HIGH)
{

// turn LED on:
}
else
{
// turn LED off:
}
}
Lab_03.txt.rtf
/*
Lab_03
DigitalReadSerial
Design an application that reads the status of button connected
to pin 2.
Every time the user press the button resulting in pin 2 going
HIGH, the application
will send an integer value of 1. Each time the button is
pressesed the application
send serially the next integer value.
9/08/2014
*/
// digital pin 2 has a pushbutton attached to it. Give it a name:
int pushButton = 2;
int t1 = 0;
// the setup routine runs once when you press reset:
void setup() {

// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
// make the pushbutton's pin an input:
pinMode(pushButton, INPUT);
}
// the loop routine runs over and over again forever:
void loop() {
// read the input pin:
int bs = function_01();
function_02(bs);
}
int function_01()
{
int buttonState = digitalRead(pushButton);
return buttonState;
}
int function_02(bs1);
{
if(bs1 == 0)
{
t1++;
Serial.println(t1);
}
delay(100); // delay in between reads for stability
}
lab_5.txt

/*
Lab_05
Desgin an application that reads the status of pin 2 that is
Please utilize stuctureed programming methodology.
9/10/2014
*/
attached to
int buttonState = 0; // current state of the button

void setup()
{
// initialize the button pin as a output:
pinMode(buttonPin, OUTPUT);
// initialize the LED as an input:
pinMode(ledPin, INPUT);
Serial.begin(9600);
}
int main()
{
setup();
while(1)
{

}
return 0;
}
int function_in(){
int bs=digitalRead(buttonPin);
return bs;
}
{
if (buttonState_1== HIGH)
{
}

else
{
}
}
__MACOSX/._lab_5.txt
Lab_14.txt
/*
Lab N0 14
A(0). The appliction is going to capture the analog sgnal
conversts the analog value
to digital value and by proper range conersion display the result
back to serial monitor.

Date: 10/06/2104
*/
#include <avr/io.h>
void setup(void);
int main()
{
setup();

the sesor
while(1)
{
}
}
void setup (void)
{
init();
}

{
}
{
Serial.println((*p3 *5.0)/1023);
delay(500);
}
Lab_08.txt
/*
Lab_08
Repeating lab_04 with standard C format

more formalized
Label definition with formal function declaration
function calls
body of functions clearly demarcated
9/17/2014
*/
#include <avr/io.h>
// set pin numbers:

occurs
# define ledPin 3 // the number of the led pin
void setup(void);
void function_in(int *);
void function_out(int *);
int main()
{
pushbutton status
setup();

while(1)
{
function_in(&buttonState);
function_out(&buttonState);
}
return 0;
}
void function_in(int *p1)
{
*p1=digitalRead(buttonPin);
}
void function_out( int *p2)
{

if(*p2==HIGH)
{
// trun LED on:
}
else
{
// turn LED off:
}
}
void setup()
{
init(); // This must be called first to configure routines
that the core relies on
// initialize the pushbutton pin as an input:
}

Lab_16.txt
/*
Lab N0 16
A(0). The appliction is going to have to display degrees
Fahrenheit and then convert it to degrees Celsius.
Date: 10/08/2104
*/
#include <avr/io.h>

void setup(void);
int main()
{
setup();
the sesor

while(1)
{
}
}
void setup (void)
{
init();
}

{
}
{
float v = (*p3 *5.0)/1023;
float f = (v*100);
float c = (f-32)*(.55556);
Serial.println(v);
Serial.print(f);
Serial.println(" degrees Fahrenheit");
Serial.print(c);
Serial.println(" degrees Celsius");

Serial.println(" ");
delay (2000);
}
Lab_09.txt
/*
Lab_09
Design a project that has two inputs (connected to two switches
A and B)
and four outputs(connected to four LEDs) associated with port
B.
Design the application such that 1) when A is high the LEDs lit
and move Right to Left
and 2) when B is High the LEDs lit and move Left to Right.
Stuctured Program with pointers and proper schematics.

9/22/2014
*/
#include <avr/io.h>
// set pin numbers:
occurs
# define buttonPin2 3 // the number of the pushbutton pin

# define ledPin1 13 // the number of the led pin
void setup(void);
void function1_in(int *);
void function1_out(int *);
void function2_in(int *);
void function2_out(int *);
int main()
{

pushbutton status
int buttonState5 = 0;
setup();
while(1)
{
function1_in(&buttonState);
function1_out(&buttonState);
function2_in(&buttonState5);
function2_out(&buttonState5);
}
return 0;
}
void function1_in(int *p1)
{
*p1=digitalRead(buttonPin);

}
void function1_out( int *p2)
{
if(*p2==HIGH)
{
// trun LED on:
digitalWrite(ledPin1, HIGH);
delay (100);
delay (100);
delay (100);
delay (100);

}
else
{
// turn LED off:
digitalWrite(ledPin1, LOW);
delay(110);
delay (120);
delay (130);
delay (140);
}
}

void function2_in(int *p5)
{
*p5=digitalRead(buttonPin2);
}
void function2_out( int *p10)
{
if(*p10==HIGH)
{
// trun LED on:
delay (100);
delay (100);

delay (100);
delay (100);
}
else
{
// turn LED off:
delay(130);
delay (120);
delay (110);
delay (100);

}
}
void setup()
{
init(); // This must be called first to configure routines
that the core relies on
pinMode(ledPin4, OUTPUT);
// initialize the pushbutton pin as an input:
}
Lab_17.txt
/*
Lab_17
interrupt - External Hardware Interrupt
using interrupts for doing what they do best--

two things at once.
Application that counts binary count on port B,
when INT0 occurs (ARDUINO Pin 2)
Interrupt service rotini will interrupt the on going task of bianry
counting and would flash LED's
connected
on port B and flashing LED's on port B whenever button is
pressed.
after finishing with ISR the main task of counting is resumed.
Date:OCT 22 2014
*/
//———Preamble———//
#include <avr/io.h>
#include <avr/interrupt.h>
//
#include “pinDefines.h“

ISR(INT0_vect)
{/* Run every time there is a change on botton */
int temp = PORTB; // save the count
PORTB = 0x00;
-delay_ms(200);
PORTB = 0x3F;
-delay_ms(200);
PORTB = 0x3F;
-delay_ms(200);
PORTB = temp; //return the count
}
void initInt0(void){
EIMSK = 0x01; //INT0=1 enable INT0
EICRA = 0x01; // ISCOO=1 trigger when button changes */
sei();/* set (global) interrupt enable bit */
}
int main(void)
{
// ———Inits——-//
DDRB = 0x3f; /*all LEDs active*/
DDRD = 0x00; // pd7,pd6 = output, reset input
PORTD = 0x04; // pulpup *, turn pd7, pd6 off
PORTB = 0xFF;
iniInt0();
// ——Event loop——//6
while(1)
{
-delay_ms(500);
PORTB = PORTB -1;
}
return (0); /*This line is never reached */
}

Lab_10.TXT
Lab_10
Use the task of lab 09
the output of moving Left or moving Right
should maintain the existing state even after the inputs are
altered.
In other words the previous state presists even ater the button
is released.
Lab_11.TXT
/*
Lab_11
Demonstration of BITWISE oprators
1) inputs are 00, the 4 outputs are all high.
if inputs are 01, the 4 outputs are: a) reset first and third
outputs, using a BITMASK
if inputs are 10, the 4 outputs are: b) set first and third
outputs, using a BITMASK
if inputs are 01, the 4 outputs are: c) rest first and second
outputs, using a BITMASK, after 5 second
toggle all fours bits.

Circut decription: Use Port B as inputs (pin 14, 15 as PB0, PB1)
Use Port D as output (Pins2,3,4 and 5 as PD0, PD1, PD2, and
PD 3)
Date: 09/29/2014
*/
#define pushButton0 10
#define pushButton1 12
#define led0 10
#define led1 11
#define led2 12
#define led3 13

// function declaraction
void step(void);
void function_int(int*);
void function_out(int*);
int main()
{
setup();
int buttonState = 0; // variable for reading the pushbutton
state
while(1)
{
// function call without arguments
function_in(&buttonState);
function_out(&buttonState);
}

return 0;
}
void function_in(int*p1)
{
*p1 = PINB;
}
void function_out(int *p2)
{
char k1=*p2;
char mask_01 = 0b00000011;
char mask_02 = mask_01 & k1;
// check if the pushbuttonis prressed
//if it is, the buttonState is HIGH:
if (mask_02==00)
{
//turn appropriate LEDs on and off:

PORTD=60; // also could have use 0b00111100
}
else
if (mask_02==01)
if(mask_02==10)
{
//trun appropriate LEDs on and off:
PORTD = 0x3c; // also could have use ob00111100
}
else
// turn appropriate LEDs on and off:
PORTD =0x00110000;
delay(500);
PORTD=0x00000000;
delay(500);
}

void setup()
{
init();// this must be call first to configure routines that the
corte relies on
// initialize the LED pin as an output:
DDRD=0b11111111;
// initiaze the pushbutton pin as input:
DDRB=0b11111100;
}
__MACOSX/._Lab_11.TXT
Lab_12.txt
/*
Lab No: 12
Design an application that would recive a charecter form PC
and then send
the same charecter back to serial monitor on PC.

Date: 10/01/2014
*/
byte characterRead;
void setup() {
// Turn the Serial Protocol ON
Serial.begin(9600);
}
void loop() {
/* check if data has been sent from the computer: */
if (Serial.available()) {
/* read the most recent byte */

characterRead = Serial.read();
/*ECHO the value that was read, back to the serial port. */
Serial.write(characterRead);
}
}
Lab_13.txt
/*
Lab No: 13
Design an application that outputs all the ASCIT characters
charatebt characters.
Date: 10/01/2014
*/

#include <avr/io.h>
void setup(void);
void inputASCII (void);
int main()
{
Setup();
while(1)
{
for(char i =0; i <256; i++)
{
Serial.println(i);
delay(200);

}
}
}
void Setup ()
{
init();
}
Lab_18.txt
/*
Lab_18
Interrupt - external Hardware Interrupt
using Interrupts for doing what they do best --
two things at once.
Apllication that counts binary count on serial monitor,

when INT0occurs (ARDUNIO Pin 2)
Interrupt service Routine will interrupt the on going task of
binary counting and would flash
LED's connected
on port B and serially output Blink.
After finishing with ISR the main task of counting is rsumed.
Date: 10-27-2014
*/
#include <avr/io.h>
void setup (void);
ISR (INT0_vect)
{//Run every time there is a change on button */
int temp = PORTB; // ave count

for (int k = 0; k<4; k++)
{
PORTB = 0x00;
_delay_ms(200);
PORTB = 0xFF;
_delay_ms(200);
Serial.print("Blink");
}
PORTB = temp; //return ht count
}
int main ()
{
int j = 0;
setup();
int sensorPin = A0;
int sensorValue = 0;
while(1)
{

Serial.print(j++);
Serial.print('n');
_delay_ms(200);
++PORTB;
}
}
void setup (void)
{
init();
Serial.begin(9600);
DDRB = 0xff;
DDRD = 0x00;
PORTD = 0xff;
PORTB = 0xFF;
EIMSK = 0x01;
EICRA = 0x01;
sei();

}
Lab_19.txt
/*
Lab_19
Design an application that demonstrates or make use
of the exrnal Hardware Inerrupts coming from INT1.
Design the smpliest applcation that is demonstrable
(as per your defination) running with your perpetual loop.
when interupted this task should be replace by the task defined
in your ISR.
Date: 10-27-2014
*/

#include <avr/io.h>
#include <pinDefines.h>
void setup(void)
{
init();
Serial.begin(9600);
DDRB = 0b11111111; // 0xff;
DDRD = 0b00; // 0x00;
PORTD = 0b11111111; // 0xff;
PORTB = 0b11111111; // 0xff;
EIMSK = 0x02; // |=(1<<INT1); //0b1; // 0x01;
EICRA = 0x05; // 0x01;

sei();
}
ISR(INT1_vect)
{
int temp= PORTB;
for ( int k=0; k < 4; k++)
{
PORTB=0b00011111;
_delay_ms(200);
PORTB=0b00000000; // PORTB=0xFF;
_delay_ms(200);
Serial.print(" Stop ");
// Serial.println();
}
PORTB = temp;

}
int main()
{
int j=0;
setup();
int sensorpin = A0;
int sensorvalue = 0;
while(1)
{
PORTB=0b00000000; // PORTB=0xFF;
_delay_ms(200);
PORTB=0b00000001;
_delay_ms(200);
PORTB=0b00000010;
_delay_ms(200);
PORTB=0b00000100;
_delay_ms(200);
PORTB=0b00001000;

_delay_ms(200);
PORTB=0b00010000;
_delay_ms(200);
}
}
Lab_20.txt
/*
Date: 11-03-2014
Lab_20
*/

#define ledPin 13
void setup()
{
// initialize timer1
noInterrupts(); // disable all interrupts
TCCR1A = 0;
TCCR1B = 0;
TCNT1 = 34286; // preload timer 65536-
16MHz/256/2Hz
TCCR1B |= (1 << CS12); // 256 prescaler
TIMSK1 |= (1 << TOIE1); // enable timer overflow interrupt
interrupts(); // enable all interrupts
}
ISR(TIMER1_OVF_vect) // interrupt service routine that

wraps a user defined function supplied by attachInterrupt
{
TCNT1 = 34286; // preload timer
digitalWrite(ledPin, digitalRead(ledPin) ^ 1);
}
void loop()
{
}
Lab_21.txt
/*
Date: 11-03-2014
Lab_21 "Exam_02"
Design an application that would turn the LED's ON for 5

seconds
evry 60 seconds. "Long time delays using timers"
*/
# include <avr /io.h>
int main ( void )
{
setup();
int ElapsedSeconds = 0;

for (;;)
{
// Check timer value in if statement , true when count
matches 1 second
if ( TCNT1 >= 15624)
{
TCNT1 = 0; // Reset timer value
++ElapsedSeconds;
if (ElapsedSeconds == 60) // Check if one minute has
elapsed
{
PORTB = 0b00111111; // Toggle the LED
}
if (ElapsedSeconds == 65)
{
PORTB = 0b00000000;

ElapsedSeconds = 0; // Reset counter variable
}
}
}
}
void setup(void)
{
DDRB = 0b00111111; // Set LED as output
TCCR1B |= ((1 << CS10 ) | (0 << CS11) | (1 << CS12 )); // Set
up timer at Fcpu /1024
}
Lab_22.txt
/*
Lab_22

Date: 11-05-2014
Design an application would acomplish the task of (utizing
Timer in CTC mode) blinking a
LED connected to a pin of you choice, every 1 second.
*/
int main ( void )
{
setup();
TIFR1 |= (1 << OCF1A);
for (;;)

{
if ( TIFR1 & (1 << OCF1A ))
{
PORTB ^= 0b00000001; // Toggle the LED
TIFR1 = (1 << OCF1A ); // clear the CTC flag ( writing a
logic one to the set flag clears it)
}
}
}
void setup (void)
{

TCCR1B |= ((1 << CS10 ) | (0 << CS11) | (1 << CS12 )); // Set
TCCR1B |= (1 << WGM12 ); // Configure timer 1 for CTC
mode
OCR1A = 15624; // Set CTC compare value to 1Hz at 1
MHz AVR clock , with a prescaler of 1024
}
Lab_23.txt
/*
Lab_23
Date: 11-10-2014

Title: Using Times intrrputs
Design an application that could run a pump that could water
your particular
pet plant so many second evey (your prctical value) that is esaly
demonstrable.
comment your code
*/
/*
Lab_23
Name: Ayman Alshahabiah
Date: 11-10-2014
Title: Using Times intrrputs
Design an application that could run a pump that could water
your particular
pet plant so many second evey (your prctical value) that is esaly
demonstrable.
comment your code

*/
# include <avr / interrupt .h>
void setup (void)
{
DDRB |= (1 << 0); // Set LED as output
mode
//TODO : Enable CTC interrupt
// TODO : Enable global interrupts
OCR1A = 15624; // Set CTC compare value to 1Hz at 1 MHz
AVR clock , with a prescaler of 64
TCCR1B |= ((1 << CS10 ) | (1 << CS12)); // Start timer at Fcpu
/64
TIMSK1 |= (1 << OCIE1A );
sei();

}
int main (void)
{
setup();
for (;;)
{
}
}
ISR ( TIMER1_COMPA_vect )
{
static int ElapsedSeconds=0;
++ElapsedSeconds;

if (ElapsedSeconds == 1)//heck if one minute has
elapsed
{
PORTB = 0b100000;// Toggle the LED
}
if (ElapsedSeconds == 4)
{
PORTB = 0b000000;
ElapsedSeconds = 0; // Reset counter variable
}
}

Lab_24.txt
/*
Lab 24
Timer Interrupt task Analog with main Task.
Design an applicataion that would be:
1) Performing the main taskof counting on ther serial monitor
once every 0.5 seconds
2) Timer interrupt task would be triggered once every 10
seconds and this will announce
on the serial monitor by saying "Timer Interrupt".
Date : 11-12-2014
*/

# include <avr / interrupt .h>
# include <util/delay.h>
int main ( void )
{
int R = 0;
sei (); // Enable global interrupts
OCR1A = 62499; // Set CTC compare value to 1Hz at 1 MHz
TCCR1B |= (1 << WGM12 );
TIMSK1 |= (1 << OCIE1A ); // Enable CTC interrupt
TCCR1B |= ((1 << CS12)); // Set up timer at Fcpu /256
setup();
for (;;)

{
Serial.println(R);
R++;
_delay_ms(500);
}
}
ISR ( TIMER1_COMPA_vect )
{
static int count = 0;
++count;
if ( count ==10)
{
Serial.println("Timer interrupt");
count = 0;

}
}
void setup(void)
{
Serial.begin(9600);
}
Lab_25.txt
/*

Lab_25
Date: 11-17-2014
Utilize timer intrurpt as means to achived p.w.m that intrupts
would controls
a DC motor.
*/
int main ( void )

{
setup();
TIFR1 |= (1 << OCF1A);
for (;;)
{
if ( TIFR1 & (1 << OCF1A ))
{
PORTB ^= 0b00000001; // Toggle the LED
}
}

}
void setup (void)
{
TCCR1B |= ((1 << CS10 ) | (0 << CS11) | (1 << CS12 )); // Set
mode
OCR1A =9; // Set CTC compare value to 1Hz at 1 MHz
}

Lab_26.txt
/*
Lab_26
Date: 11-19-2014
Utilizing one of the timers intrurpt to achived p.w.m that would
controls
a 12 volts D.C motor reuminine at 1/3 speed (4 volts).
*/

int main ( void )
{
setup();
TIFR1 |= (1 << OCF1A);
for (;;)
{
if ( TIFR1 & (1 << OCF1A ))
{
PORTB ^= 0b00000001; // Toggle the motor

}
}
}
void setup (void)
{
TCCR1B |= ((1 << CS10 ) | (0 << CS11) | (1 << CS12 )); // Set
mode
OCR1A =9; // Set CTC compare value to 1Hz at 1 MHz
}

Lab_5.txt.rtfLab_05Design an application that reads the .docx

More Related Content

Similar to Lab_5.txt.rtfLab_05Design an application that reads the .docx

More from DIPESH30

Recently uploaded

Lab_5.txt.rtfLab_05Design an application that reads the .docx