代做ESE 123 Prelab 9 Stopwatch代做留学生SQL 程序

2024.11.15 - 首页 >> Database

ESE 123

Prelab 9

Stopwatch

Objec&ves:

In this prelab we will:

• Learn how to divide integer numbers

• Learn about IF condi@onal construct in C

• Learn how to write code to read pushbuBons

Integer division:

C is a typed language − numbers can be of an integral type (i.e. integers in all their various ﬂavors − char, int, long, etc.), or of a ﬂoa@ng point type (ﬂoat, double, and the like). The ‘/‘ division operator acts diﬀerently depending on its arguments. If at least one argument is a ﬂoa@ng point number, the ‘/‘ operator will return a ﬂoa@ng point results. For instance 5.2 / 4 would return a ﬂoa@ng point result (1.3) because 5.2 is a ﬂoat.

Recall that most numbers can not be represented perfectly as ﬂoa@ng point numbers. For instance, 1/3 cannot be represented perfectly as a ﬁnite length decimal number. The closest we can do is 0.333 where the bar indicates repea@ng digits. Not so obvious is that 1/5 can be perfectly represented as a decimal number (0.2), but not as a binary ﬂoat (0.00110011). The closest representa@on of 0.2 in a 32 bit binary ﬂoat is

0.20000000298023223876953125. This means that:

5/1 × 5

Is not going to be exactly equal to 1. This can cause real problems in programming where you might have a loop that increments by 0.2 each @me and you expect the result to be exactly equal to 1 a\er ﬁve passes. Addi@onally, ﬂoa@ng point numbers take more space to store and take longer to process than integers.

There are advantages to handling the division of integers exactly. That is why C includes two mathema@cal operators for integer division: integer division produces an integer quo@ent and the modulo func&on returns the remainder of a division.

Integer division means that the dividend is divided by the divisor and any frac@onal part is simply thrown away. 15/3 is 5 in integer division, but 16/3 and 17/3 are also 5 in integer division.

The modulo func@on, denoted by the ‘%’ operator ignores the quo@ent, but returns the remainder. 15%3 is 0 because there is no remainder. 16%3 is 1, 17%3 is 2, and 18%3 is back to 0.

We have seen that the ‘/‘ operator returns a ﬂoat if either argument is a ﬂoat. If both arguments are integral types the ‘/‘ operator performs integer division.

Checking bu:ons:

A look at the schema@c diagram at the end of this document shows three buBons SW1 (labeled UP), SW2 (OK), and SW3 (DOWN). These are all connected to PORTE of the microcontroller. We have set up the microcontroller to make these inputs with a weak pull-up. This means that there is a resistor connected internally to +5V in the microcontroller so that the input will read as a logical 1 if nothing else is going on.

However, pushing the buBons can change that. The buBons are conﬁgured to short the input to ground thus forcing the input to a logical 0.

The switches are connected to the three least signiﬁcant bits of PORTE: PE2 (DOWN), PE1 (OK), and PE0 (UP). We wish to check the condi@on of one switch at a @me and ignore the other bits of PORTE.

A two input AND logical func@on takes two bits in and generates one bit out. The output bit is TRUE (logical 1) if both of the inputs are TRUE. If any input is FALSE (logical 0) the output is FALSE.

The arithme@c logic unit (ALU) on our chip is 8 bits wide. That means that it contains 8 separate AND gates. Each AND gate takes one input from one operand and the other from the corresponding bit of the other operand.

Say we want to see if the UP buBon is pressed. This is connected to PE0 − the least signiﬁcant bit of PORTE. If it is pressed PE0 will be a logical 0. If it is not pressed PE0 will be a logical 1.

If the UP buBon is pressed (PORTE_IN bit 0 is low) and we perform. this AND opera@on:

PORTE_IN 0b11011110

AND 0b00000001

0b00000000

The result is zero. Now suppose the buBon is the released and PORTE_IN bit 0 will be high:

PORTE_IN 0b11011111

AND 0b00000001

0b00000001

There are the only two possibili@es if we AND with PORTE_IN with 0b00000001. Zero if the buBon is presses and non-zero if it is released. The other bits of PORTE_IN have no bearing on the result.

This is called masking and it allows us to use the AND opera@on to ignore everything except for the bit or bits that interest us. If we were interested in isola@ng the OK buBon (PORTE_IN bit 1) we would AND PORTE_IN with 0b00000010 and the result would strictly depend on the OK buBon − we would get 0b00000000 if the buBon was pressed and 0b00000010 if not.

In C the bitwise AND operator is denoted with a single & symbol (the logical AND operator is denoted with two && symbols). The C code to mask the OK buBon would be:

PORTE_IN & 0b00000010

IF structure:

C can make decisions. You might want to check for equality in an IF structure. In this case you’ll need the ‘==‘ operator. In C the ‘=‘ operator is an assignment operator (it takes the data on its right side and stores it into the memory loca@on on the le\ side). The ‘==‘ is a rela@onal operator, it returns TRUE if the things on its right and le\ sides have the same value. If we wanted to check to see if a variable called test is equal to one:

There are @mes where you may need an ELSE clause. The code following the ELSE

executes only if the preceding IF was NOT performed. This allows us to run diﬀerent

code depending on the state of something. In this example, we are checking to see if a buBon is pressed:

In this case we are checking the status of the UP buBon (PE0). PORTE_IN is ANDed with 0b00000001 so that only the rightmost bit of PORTE_IN (PE0) has any eﬀect. If this

buBon is pressed the code following the IF will run. The ELSE code will run if the buBon is released. The ELSE code is op@onal.

You can test for OK buBon presses by just ANDing with a diﬀerent constant. Use 0b00000010 for the OK buBon and 0b00000100 for the DOWN buBon.

You may place any C statement inside an IF statement. This includes … other IF statements. Consider the example below:

In the example above, the IF statement for b is inside the IF statement for a. If a is not equal to 1, the value of b will not be checked. If a is equal to 1, then if b is checked and, if it is equal to 1, the code in the nested IF statement will run. This arrangement is useful if you want something to happen only if two condi@ons are TRUE. If either a or b is not equal to 1, nothing happens.

Report:

Write a report with the answers to the following ques@ons:

1. What is 75 / 54 using integer division? (2 points)

2. What is 75 % 54? (2 points)

3. The modulo operator can be useful in an IF statement. Imagine that char variable X has already been declared. Write an IF statement that subtracts 1 from X if X is odd. Note that X%2 will be 1 if X is odd and 0 if X is even. (4 points)

4. Con@nuing with the previous ques@on, write an IF…ELSE statement that adds 2 to X if X is even, and subtracts 1 if X is odd. (4 points)

5. Write C masking code that will return a 0 if the DOWN buBon is pressed, and anything else if it is released (see the schema@c diagram at the end this document). (2 points)

6. Assume a char variable called hr has been declared. Write a C IF statement that subtracts 1 from hr if the DOWN buBon is pressed. (4 points)