Elena Racanicchi - Fab Academy 2020

GOALS:

GROUP ASSIGNMENT:
Compare the performance and development workflows for other architectures.

INDIVIDUAL ASSIGNMENT:
1. Read a microcontroller data sheet.
2. Program your board to do something, with as many different programming languages and programming environments as possible.

| MICROCONTROLLER |

ARCHITECTURES

HARVARD Architecture (the one we use) - The programm and the data are in different memory.
VON NEUMAN Architecture - the programm and data are in the same memory and they can modified eachother.

MEMORY

REGISTER = used for operating (add 2 numbers).
(SRAM) Static ram = where you store data that you can have access quickly.
(DRAM) Dinamic ram = is not as fast that sram, but it's denser, used for make bigger memory.
EEPROM (dubleEPROM) = memory that keeps its value after the power is turned off (used for settings). The circuit can write its own memory. The processor can save a value and then remeber it when you turn on power.
FLASH - it is denser, so this is were you store your programs.
FUSE - specific bit of memory in the microcontroller that you programs to set/modify different settings of the microcontroller.

PHERIPHERALS

PORTS = talks to the pins.
A/D (analog to digital converter) = you can measure voltage and turn it into a number.
COMPARATOR = let you compare two voltages and tells you it is greater or lesser than . It is much faster than A/D.
Depending on the microprocessor there can be even a D/A, digital to analog converter, that turns numer to analog signal(voltage) to generate wave forms out.
TIMER = measures times.
COUNTER = they measures count.
PWM (pulse witdh modulation) = to make a light lighter or dimmer, a speaker louder or softer you turn a pin on and off very quickly rather than by variing volatage, because it as more power eith less heat.
USART = to communicate serial port - porta seriale - mnda 0 e 1 in fila.
USB = to communicate parallel port - manda dati tutti insieme.

WORD SIZE

Register talks to the memory and the number of bit in the register is the word size.
Processor with bigger registers can do more works in one operation and address more memory.
Generally, a bigger word size is better, but even a simpliest 8 bit processor can run at 20 Mhertz and it does one instruction every 20 mhertz.
If you want to make audio: audio is 20khertz, for every audio sample you can do a thousand operation, which is enough to do math with a bigger word size. So you can still do lots of things with a 8 bit processor.

AVR

A processor designed around modern compilers (to turn your program into instructions),
rather then design the compilers around the processor they designed the processor around the compilers, this led to a chip small processor with modern architecture.

IN-SYSTEM PROGRAMMING

Once you have a processor, you need to develop it, so you do in-system programming.
When you make your board, you have a header (ISP) on it, and you use it to load the programm into it, so that is in-system programming.
There are are many ways to do that:

You can use the header and connect the programmer.
you can connect the (pads) on the board and don't solder the header onto it, but just hold it and push it onto the board, if you need to programm it just a few times.
You can use clips, rather than having a header, you clipped onto the processor and inject the signal right into it.
You can use pins (pogo pins).

PROGRAMMING LANGUAGES

To program my microcontroller I needed to write a programming code using, of course, a programming language.
Programming languages can be devided into two main categories: high and low level languages.

HIGH LEVEL LANGUAGES ( Python, Micropython, Circuitpython) are closer to natural language so, instead of compiling low level code you write high level command and it interprets it, but the performance is thousand time slower.
LOW LEVEL LANGUAGES (Assembly, C, C++, C#) are closer to machine language, so the syntax really differ from natural languages, is more difficult, cryptic and requires a highly specified competences, but its performance is faster. Together with our Instructor and the class, I decided to use the C language to programm the processor.

| STEPS TO PROGRAM A BOARD |

This week I decided to program the ATtiny45, the board I did during the Electronics Design Week.
I am going to give a quick sum up of the required steps to program a board:

Having a toolchain(which I had dowloaded during Electronics Production), to programm the AVR board.
A firmware: which is the C code I write on my text-editor (Notepad++).
2. A Compiler,(I used AVR GCC. It was already included in the toolchain) to convert the firmware into the machine language (.hex).
In fact, when you write your program in your text-editor, you saved it as a C code, but that is not machine language, so to translate it into machine language you need a Compiler, that translate your code in an file.hex (hexadecimal).
(Optional) You can use a Makefile : a software utility that works as a shortcut for commands. I will cover this part in section 2.
Once you have your file.hex, you have to put it on your board with an hardware programmer (ISP) and a software programmer (avrdude).

| C PROGRAMMING |

BIT TWIDDLING

I understood the bit twiddling (a diffeerent type of approach to write the output pin), from the book VR prgoramming. I hame going to report here the main paragraph:
"The C language instruction for shifting all the bits in a number to the left or right is << or >> .
Bit shift examples:
0b00001110 >> 3= 0b00000001 (Three new zeros were added to the left, and the bits on the right just rolled off the edge.)
0b00001110 << 2= 0b00111000 (Two new bits, both zeros, are rolled in from the right.)"
The bit-shift roll:
1 = 0b00000001
(1 << 0) = 0b00000001
(1 << 1) = 0b00000010br> Following this logic, since the pin output for my led was PB4:
Bit shift roll -> PB4/4 = 0b00010000
Bit shift twiddling -> PB4/4 = (1 << 4)

_ WRITING THE CODE __

| MAKEFILE |

I decided to create a Makefile to use as a shortcut for the commands. I downloaded Neil's Makefile from the schedule and I modified it by delating all the commands that I didn't need, leaving just the (PROJECT).hex, (PROJECT).out, and the program-usbtiny for flashing.
I ultemately added the fuses with the shortcut command:program-usbtiny-fuses.


PROJECT= blinkled_ele 
SOURCES=$(PROJECT).c
MMCU=attiny45
F_CPU = 8000000

CFLAGS=-mmcu=$(MMCU) -Wall -Os -DF_CPU=$(F_CPU)

$(PROJECT).hex: $(PROJECT).out
	avr-objcopy -O ihex $(PROJECT).out $(PROJECT).c.hex;\
	avr-size --mcu=$(MMCU) --format=avr $(PROJECT).out
 
$(PROJECT).out: $(SOURCES)
	avr-gcc $(CFLAGS) -I./ -o $(PROJECT).out $(SOURCES)

 program-usbtiny: $(PROJECT).hex
	avrdude -p t45 -P usb -c usbtiny -U flash:w:$(PROJECT).c.hex

 program-usbtiny-fuses: $(PROJECT).hex
	avrdude -p t45 -P usb -c usbtiny -U lfuse:w: 0x62:m

AVR FUSE CALCULATOR

For calculating the fuses, I used a AVR Fuse Calculator.
In device selection , AVR part name, I selected the ATtiny45.

The default parameters settings were automatically selected, and they were all correct, but I choose to dive into each one of them to better understand how to read a datasheet.
I started from the Feature Configuration by selecting the Internal Oscillator 8Mhz [CKSEL=0010 SUT=10]. This default mode was correct, in my case , because I didn't put any resonator (an external clock), but I used the internal oscillator.

I then started reading the ATtiny45 datasheet, and I found a my main, informative table for setting the fuses at page 149. It gave an overview of all the settings to set the fuses.

If we analyze them in order: 7. CKDIV8 = is the System clock prescaler, as note 1 said. I then o the instruction and went to page 31, which led me to page 33. There i found what i wanted: see that the board was shipped with CKDIV8 programmed (0).

6. CKOUT= is the clock output enable, which of course needed to be unprogrammed, because I didn't have an external clock.

5-4. SUT= is the Start-up Times for Internal Calibrated RC Oscillator Clock, and as you can see from the image below, the divice is shipped with settings 10. Since that value is read from right to left, this means that SUT0 is gonna be programmed (0), and SUT1 is going to be umprogrammed (1).

3-0. CKSEL = stands for "clock source setting". I went to page 27 of the datasheet and there I found my correct paramenter:0010.

Once I had the desidered settings programmed, at the bottom of the page, there were the calculated fuses.

| GIT BASH |

After that, I connected with a ribbon cable the programmee board with the programmer I did during the Electronics production week. I connected the programmer with an USB cable, and I plugged the USB cable to the computer.
Then, I opened GIT Bash, I went inside the folder were I had saved the Makefile and the C file, and I typed make -f blinkled_ele.make to create the hex and out file. The command converts my program into the hex code.

 $ make -f blinkled_ele.make
avr-gcc -mmcu=attiny45 -Wall -Os -DF_CPU=8000000 -I./ -o blinkled_ele.out blinkled_ele.c
avr-objcopy -O ihex blinkled_ele.out blinkled_ele.c.hex;\
        avr-size --mcu=attiny45 --format=avr blinkled_ele.out
AVR Memory Usage
----------------
Device: attiny45

Program:      98 bytes (2.4% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)

After that the hex and out file appeared inside my folder.

After that, I typed make -f blinkled_ele.make program-usbtiny to flash the hex file, and everythink went successfully.

 $ make -f blinkled_ele.make program-usbtiny
avr-objcopy -O ihex blinkled_ele.out blinkled_ele.c.hex;\
        avr-size --mcu=attiny45 --format=avr blinkled_ele.out
AVR Memory Usage
----------------
Device: attiny45

Program:      98 bytes (2.4% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)


avrdude -p t45 -P usb -c usbtiny -U flash:w:blinkled_ele.c.hex

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9206
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "blinkled_ele.c.hex"
avrdude: input file blinkled_ele.c.hex auto detected as Intel Hex
avrdude: writing flash (98 bytes):

Writing | ################################################## | 100% 0.09s

avrdude: 98 bytes of flash written
avrdude: verifying flash memory against blinkled_ele.c.hex:
avrdude: load data flash data from input file blinkled_ele.c.hex:
avrdude: input file blinkled_ele.c.hex auto detected as Intel Hex
avrdude: input file blinkled_ele.c.hex contains 98 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.06s

avrdude: verifying ...
avrdude: 98 bytes of flash verified

avrdude done.  Thank you.

Ultimately, I typed make -f blinkled_ele.make program-usbtiny-fuses to program the fuses.

 $ make -f blinkled_ele.make program-usbtiny-fuses
avr-objcopy -O ihex blinkled_ele.out blinkled_ele.c.hex;\
        avr-size --mcu=attiny45 --format=avr blinkled_ele.out
AVR Memory Usage
----------------
Device: attiny45

Program:      98 bytes (2.4% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)


avrdude -p t45 -P usb -c usbtiny -U lfuse:w:0x62:m

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9206
avrdude: reading input file "0x62"
avrdude: writing lfuse (1 bytes):

Writing | ################################################## | 100% 0.01s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0x62:
avrdude: load data lfuse data from input file 0x62:
avrdude: input file 0x62 contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100% 0.00s

avrdude: verifying ...
avrdude: 1 bytes of lfuse verified

avrdude done.  Thank you.

And the led blinked!

| ADAFRUIT HUZZAH32 FEATHER ESP32 |

Since for my final project I will be used an ESP32, I starting experimenting with a Adafruit Huzzah Feather module. Using a BLE scan Arduino sketch ( you can find a more detailed and implemented sketch documentation on the Final Project - Programming page) I wrote a code that paired each LED to a Beacon and made turn-on the LED whose Beacon was the nearest.

As you can see form the video demostration below, the LEDs turn on a little bit late, and I think it wa because I gave to muh delay at the end of the code an even the scanning phase was too long. For my final project code, I will try to give less delays and a quicker scanner time.

______________ EMBEDDED PROGRAMMING ______________