Skip to content

Commit 5f74730

Browse files
author
Daniel Rosner
committed
add slides for lecture 01 and 02
1 parent fd879eb commit 5f74730

11 files changed

Lines changed: 444 additions & 9 deletions

File tree

‎slides/lectures/acs_cc/01/slides.md‎

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,113 @@ src: ../../resources/processor/slides.md
7070

7171
<!-- MCUs -->
7272

73+
---
74+
75+
# Hello World on AVR in C
76+
77+
```c
78+
79+
#include <avr/io.h>
80+
#include <util/delay.h>
81+
82+
#define F_CPU 12000000UL //MCU clock frequency
83+
84+
int main()
85+
{
86+
DDRC = (1 << PC0); //Set pin 0 of PORT C as output
87+
//DDRC = Data Direction Register for PORT C
88+
while(1)
89+
{
90+
PORTC ^= (1 << PC0); //Toggle pin 0 of PORT C (XOR)
91+
_delay_ms(500);
92+
}
93+
}
94+
95+
```
96+
97+
> Note: the above code can toggle an LED on / off every 500ms
98+
99+
---
100+
101+
# Let's go lower level
102+
```c
103+
104+
//00000000 <__vectors>:
105+
//__vectors():
106+
0: 0c 94 3e 00 jmp 0x7c ; 0x7c <__ctors_end> //reset
107+
4: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
108+
8: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
109+
c: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
110+
10: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
111+
14: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
112+
18: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
113+
1c: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
114+
20: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
115+
24: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
116+
28: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
117+
118+
................................................
119+
120+
60: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
121+
64: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
122+
68: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
123+
6c: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
124+
70: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
125+
74: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
126+
78: 0c 94 48 00 jmp 0x90 ; 0x90 <__bad_interrupt>
127+
0000007c <__ctors_end>:
128+
129+
130+
```
131+
132+
---
133+
134+
# Next code
135+
136+
```c
137+
138+
//__trampolines_start():
139+
7c: 11 24 eor r1, r1 ; r1 = 0 //program jumps here at reset
140+
7e: 1f be out 0x3f, r1 ; SREG = r1
141+
80: cf ef ldi r28, 0xFF ; 255
142+
82: d8 e0 ldi r29, 0x08 ; 8
143+
84: de bf out 0x3e, r29 ; SPH = 0x8 //stack pointer on the last RAM address - 0x08FF for 328P
144+
86: cd bf out 0x3d, r28 ; SPL = 0xFF. //stack Pointer High and Low - to get a 16b address on a 8bit MCU
145+
88: 0e 94 4a 00 call 0x94 ; 0x94 <main>
146+
8c: 0c 94 59 00 jmp 0xb2 ; 0xb2 <_exit> 00000090
147+
148+
//<__bad_interrupt>: __vector_22():
149+
90: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>. //any interrupt triggers a reset
150+
151+
152+
```
153+
154+
---
155+
156+
# We get to the code
157+
158+
```c
159+
160+
94: 38 9a sbi 0x07, 0 ; DDRC = 0x01 //DDRC |= (1 << PC0);
161+
162+
96: 91 e0 ldi r25, 0x01 ; r25 = 1
163+
98: 88 b1 in r24, 0x08 ; r24 = PORTC //from here PORTC ^= (1 << PC0);
164+
9a: 89 27 eor r24, r25 ; r24 = r24 ^ 1
165+
9c: 88 b9 out 0x08, r24 ; PORTC = r24
166+
167+
9e: 2f e9 ldi r18, 0x9F ; 159 //from here _delay_ms():
168+
a0: 36 e8 ldi r19, 0x86 ; 134
169+
a2: 81 e0 ldi r24, 0x01 ; 1
170+
a4: 21 50 subi r18, 0x01 ; 1
171+
a6: 30 40 sbci r19, 0x00 ; 0
172+
a8: 80 40 sbci r24, 0x00 ; 0
173+
aa: e1 f7 brne .-8 ; 0xa4 <main+0x10>
174+
ac: 00 c0 rjmp .+0 ; 0xae <main+0x1a>
175+
ae: 00 00 nop b0: f3 cf rjmp .-26 ; 0x98 <main+0x4> //jumps back to the loop (98)
176+
177+
178+
```
179+
73180
---
74181
src: ../../resources/mcu/slides.md
75182
---

‎slides/lectures/acs_cc/02/slides.md‎

Lines changed: 28 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -34,18 +34,37 @@ Lecture 2
3434
- Embedded Rust Stack
3535
- embassy-rs
3636

37+
<!-- Bitwise -->
38+
39+
---
40+
src: ../../resources/bitwise/slides.md
41+
---
42+
43+
---
44+
src: ../../resources/bitwise/c_bit.md
45+
---
46+
47+
3748
<!-- MMIO -->
3849

3950
---
4051
src: ../../resources/mmio/slides.md
4152
---
4253

43-
<!-- Bitwise -->
54+
<!-- general obs on GPIO -->
4455

4556
---
46-
src: ../../resources/bitwise/slides.md
57+
src: ../../resources/sio/gpio_intro.md
4758
---
4859

60+
<!-- AVR GPIO with C -->
61+
62+
63+
---
64+
src: ../../resources/sio/gpio_avr.md
65+
---
66+
67+
4968
<!-- SIO -->
5069

5170
---
@@ -64,7 +83,14 @@ src: ../../resources/rust-embedded/slides.md
6483
src: ../../resources/embassy-rs/slides.md
6584
---
6685

86+
87+
<!-- embassy-rs -->
88+
6789
---
90+
src: ../../resources/signals/digital_v2.md
91+
92+
---
93+
6894
---
6995
# Conclusion
7096
we talked about

‎slides/lectures/resources/bitwise/c_bit.md‎

Lines changed: 119 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,119 @@
1+
# Bitwise Ops - in C
2+
3+
## Set the `1` on position `bit` of `register` in C
4+
5+
```c
6+
unsigned int set_bit(unsigned int register_value, unsigned char bit) {
7+
// assume register_value is 0b1000, bit is 2
8+
// 1 << 2 is 0b0100
9+
// 0b1000 | 0b0100 is 0b1100
10+
return register_value | (1 << bit);
11+
}
12+
```
13+
14+
## Set multiple bits
15+
16+
```c
17+
unsigned int set_bits(unsigned int register_value, unsigned int bits) {
18+
// assume register_value is 0b1000, bits is 0b0111
19+
// 0b1000 | 0b0111 is 0b1111
20+
return register_value | bits;
21+
}
22+
```
23+
24+
---
25+
26+
# (test code)
27+
28+
```c
29+
30+
#include <stdio.h>
31+
32+
void print_binary(unsigned int num) {
33+
for (int i = sizeof(num) * 8 - 1; i >= 0; i--) {
34+
printf("%c", (num & (1 << i)) ? '1' : '0');
35+
}
36+
printf("\n"); //prints "num" number in binary format
37+
}
38+
39+
unsigned int set_bits(unsigned int register_value, unsigned int bits) {
40+
return register_value | bits;
41+
}
42+
43+
int main() {
44+
unsigned int reg = 0b1000;
45+
unsigned int bits_to_set = 0b0011;
46+
47+
unsigned int result = set_bits(reg, bits_to_set);
48+
49+
printf("Register before: "); print_binary(reg);
50+
printf("Bits to set: "); print_binary(bits_to_set);
51+
printf("Result after: "); print_binary(result);
52+
return 0;
53+
}
54+
55+
```
56+
57+
58+
---
59+
60+
# Combined operation for value extraction in C
61+
62+
```c
63+
#include <stdio.h>
64+
void print_binary(const char *label, unsigned int num) {
65+
printf("%s: ", label);
66+
for (int i = 31; i >= 0; i--) {
67+
printf("%c", (num & (1 << i)) ? '1' : '0');
68+
}
69+
printf("\n");
70+
}
71+
72+
int main() {
73+
unsigned int large_id = 0b11001010111111000000111101101101;
74+
unsigned int mask = 0b00000000000000000000111111111111;
75+
unsigned int extracted_bits = (large_id >> 20) & mask;
76+
77+
print_binary("Original_", large_id);
78+
print_binary("Mask_____", mask);
79+
print_binary("Extracted", extracted_bits);
80+
81+
return 0;
82+
}
83+
//RESULT
84+
//Original_: 11001010111111000000111101101101
85+
//Mask_____: 00000000000000000000111111111111
86+
//Extracted: 00000000000000000000110010101111
87+
88+
```
89+
---
90+
91+
# With nice formating
92+
93+
```c
94+
95+
#include <stdio.h>
96+
void print_binary(const char *label, unsigned int num) {
97+
printf("%s: ", label);
98+
for (int i = 31; i >= 0; i--) {
99+
printf("%c", (num & (1 << i)) ? '1' : '0');
100+
if (i % 4 == 0 && i != 0) { printf("_"); }
101+
}
102+
printf("\n");
103+
}
104+
int main() {
105+
unsigned int large_id = 0b11001010111111000000111101101101;
106+
unsigned int mask = 0b00000000000000000000111111111111;
107+
unsigned int extracted_bits = (large_id >> 20) & mask;
108+
109+
print_binary("Original_", large_id);
110+
print_binary("Mask_____", mask);
111+
print_binary("Extracted", extracted_bits);
112+
113+
return 0;
114+
}
115+
//RESULTS
116+
//Original_: 1100_1010_1111_1100_0000_1111_0110_1101
117+
//Mask_____: 0000_0000_0000_0000_0000_1111_1111_1111
118+
//Extracted: 0000_0000_0000_0000_0000_1100_1010_1111
119+
```

‎slides/lectures/resources/bitwise/slides.md‎

Lines changed: 67 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@ layout: section
55
How to set and clear bits
66

77
---
8-
---
8+
99
# Set bit
10-
set the `1` on position `bit` of `register`
10+
## set the `1` on position `bit` of `register`
1111

1212
```rust {all|2|3|4|1,5,6}
1313
fn set_bit(register: usize, bit: u8) -> usize {
@@ -29,9 +29,9 @@ fn set_bits(register: usize, bits: usize) -> usize {
2929
```
3030

3131
---
32-
---
32+
3333
# Clear bit
34-
set the `0` on position `bit` of `register`
34+
### Set the `0` on position `bit` of `register`
3535

3636
```rust {all|2|3|4|4,5|1,6,7}
3737
fn clear_bit(register: usize, bit: u8) -> usize {
@@ -55,9 +55,10 @@ fn clear_bits(register: usize, bits: usize) -> usize {
5555
```
5656

5757
---
58-
---
58+
5959
# Flip bit
60-
flip the bit on position `bit` of `register`
60+
61+
### Flip the bit on position `bit` of `register`
6162

6263
```rust {all|2|3|4|1,5,6}
6364
fn flip_bit(register: usize, bit: u8) -> usize {
@@ -77,3 +78,63 @@ fn flip_bits(register: usize, bits: usize) -> usize {
7778
register ^ bits
7879
}
7980
```
81+
82+
---
83+
84+
# Let's see a combined operation for value extraction
85+
86+
``` rust
87+
fn print_binary(label: &str, num: u32) {
88+
println!("{}: {:032b}", label, num);
89+
}
90+
91+
fn main() {
92+
let large_id: u32 = 0b1100_1010_1111_1100_0000_1111_0110_1101;
93+
let mask: u32 = 0b0000_0000_0000_0000_0000_1111_1111_1111;
94+
let extracted_bits = (large_id >> 20) & mask;
95+
96+
// Print values in binary
97+
print_binary("Original_", large_id);
98+
print_binary("Mask_____", mask);
99+
print_binary("Extracted", extracted_bits);
100+
}
101+
102+
//RESULT
103+
Original_: 11001010111111000000111101101101
104+
Mask_____: 00000000000000000000111111111111
105+
Extracted: 00000000000000000000110010101111
106+
107+
```
108+
109+
---
110+
111+
# With nice formating
112+
113+
``` rust
114+
fn format_binary(num: u32) -> String {
115+
(0..32)
116+
.rev()
117+
.map(|i| {
118+
if i != 31 && i % 4 == 3 {
119+
format!("_{}", (num >> i) & 1)
120+
} else {
121+
format!("{}", (num >> i) & 1)
122+
}
123+
})
124+
.collect::<Vec<_>>()
125+
.join("")
126+
}
127+
fn print_binary(label: &str, num: u32) { println!("{}: {}", label, format_binary(num));}
128+
fn main() {
129+
let large_id: u32 = 0b1100_1010_1111_1100_0000_1111_0110_1101;
130+
let mask: u32 = 0b0000_0000_0000_0000_0000_1111_1111_1111;
131+
let extracted_bits = (large_id >> 20) & mask;
132+
print_binary("Original_", large_id);
133+
print_binary("Mask_____", mask);
134+
print_binary("Extracted", extracted_bits);
135+
}
136+
//RESULTS:
137+
Original_: _1100_1010_1111_1100_0000_1111_0110_1101
138+
Mask_____: _0000_0000_0000_0000_0000_1111_1111_1111
139+
Extracted: _0000_0000_0000_0000_0000_1100_1010_1111
140+
```

0 commit comments

Comments
 (0)