Sasha Fratini

Studente MSc in Ingegneria Elettronica

Processi a semiconduttore, progettazione di IC digitali e MEMS, firmware embedded e radar FMCW per l'automotive.

Scarica CV Contattami GitHub LinkedIn

Competenze

Competenze maturate tra corsi magistrali, laboratori, camera bianca e tirocinio di tesi.

  • Processi a semiconduttore

    Process flow di fabbricazione e attività in camera bianca: deposizione di film sottili (CVD, PVD) e di fotoresist. Progettazione di rivestimenti ottici a film sottile e simulazione TCAD.

    Process flow · CVD · PVD · Fotoresist · Synopsys Sentaurus TCAD

  • Progettazione digitale

    Descrizione hardware in VHDL, sintesi su FPGA con Quartus Prime e verifica funzionale in ModelSim. Basi di VLSI design e architettura delle CPU.

    VHDL · FPGA · Quartus Prime · ModelSim · VLSI · CPU architecture

  • MEMS

    Progettazione di dispositivi MEMS e simulazione multifisica agli elementi finiti con COMSOL Multiphysics.

    MEMS design · COMSOL Multiphysics

  • Sistemi embedded

    Firmware in C per STM32 (HAL, LL, CubeMX), SoC BLE TI CC26xx e SoC radar TI mmWave, con particolare attenzione all'ottimizzazione dei consumi.

    STM32 · TI CC26xx BLE · TI mmWave · Low-power firmware

  • Elaborazione dei segnali

    Radar FMCW per l'automotive: progetto della chirp, clustering DBSCAN delle detection e tracking degli oggetti.

    FMCW radar · DBSCAN · Object tracking

  • Programmazione

    C per firmware embedded, Python per algoritmi e prototipazione, MATLAB/Simulink per simulazione e ottimizzazione numerica, VHDL per la descrizione hardware.

    C · Python · MATLAB/Simulink · VHDL

  • CAD elettronico

    Progettazione di PCB in Cadence OrCAD; utilizzo di Cadence Presto e AutoCAD.

    Cadence OrCAD · Cadence Presto · AutoCAD

  • Lingue

    Italiano madrelingua; inglese di livello B2 (QCER), con corsi di lingua a New York (2019) e Bournemouth (2018).

    Italiano · English B2 CEFR

Progetti

Codice, grafici e schemi tratti dai repository GitHub.

ecobin · sensore BLE · 2026

Monitoraggio del riempimento via BLE

Sensore per cestini smart: un sensore a ultrasuoni misura il livello dei rifiuti e un SoC TI CC26xx lo trasmette via Bluetooth Low Energy a un'app Android. Progettazione della PCB in Cadence OrCAD e firmware C a bassissimo consumo, ripartito tra core ARM e Sensor Controller.

C · Kotlin · github.com/bobbisasha/prj13_board_firmware

Collegamenti tra il SoC TI CC26xx e il sensore a ultrasuoni A02YYUW e formato del frame UART Collegamenti · sensore ↔ SoC TI CC26xx SoC BLE · ARM + Sensor Controller DIO2 DIO1 DIO5 GND A02YYUW sensore a ultrasuoni TX RX VCC GND UART RX · 9600 baud UART TX · non usato VCC · attivo solo in lettura massa comune Frame UART 0xFF header MSB LSB checksum
Scheda del sensore EcoBin
project13_boardFW/Application/simple_peripheral.c estratto 
static void scTaskAlertCallback(void) {
  static uint8_t packet[4];
  static uint8_t packetIndex = 0;

  scifClearAlertIntSource();

  uint32_t count = scifUartGetRxFifoCount();
  while (count > 0) {
    uint8_t b = (uint8_t)scifUartRxGetChar();
    count--;

    if (packetIndex == 0) {
      if (b == 0xFF) {
        packet[0] = b;
        packetIndex++;
      }
    } else {
      packet[packetIndex++] = b;
      if (packetIndex == 4) {
        if (((packet[0] + packet[1] + packet[2]) & 0xFF) == packet[3]) {
          scSensorPayload[0] = packet[1];
          scSensorPayload[1] = packet[2];
          scSensorPayload[2] = 0;
          scSensorPayload[3] = 0;
          scSensorPayload[4] = 0;
          Event_post(syncEvent, SBP_SC_ALERT_EVT);
        }
        packetIndex = 0;
      }
    }
  }

  scifAckAlertEvents();
  scifOsalEnableTaskAlertInt();
}

Ciclo di misura · schema non in scala

Core ARM deep sleep tick sleep 200 ms FIFO → GATT deep sleep
Sensor Controller UART RX · 9600 baud
Sensore · DIO5 off alimentato off
t₀ · tick t₀ + 200 ms t₀ + 10 s
  • Core ARM in sleep durante l'avvio del sensore, lettura del FIFO già pieno
  • Disconnessione BLE: timer arrestato e sensore spento
EcoBin BLE

Cestino 1

Connesso · live

72%
Distanza
14 cm
Profondità
50 cm

Calcolo nell'app

fullness% = (depth − distance) / depth × 100

Caratteristica BLE CHAR5 · notifiche o polling · modalità demo per emulatore

Schermata dell'app Android EcoBin

poc · fotonica · 2025

Progettazione di film sottili e guide d'onda

Quattro progetti MATLAB del corso di Photonic Optical Components: rivestimenti antiriflesso multistrato per celle solari in GaAs con ottimizzazione pesata sullo spettro AM1.5, filtri Fabry-Pérot e specchi DBR con il metodo delle matrici di trasferimento, combinatore RGB in guida d'onda e perdite di inserzione in giunzioni tra fibre.

MATLAB · con Lorenzo Fiore · github.com/bobbisasha/poc_sf

Riflettività di un ARC quarto d'onda a 5 strati ottimizzato: indici ideali e reali
Riflettività di un ARC a doppio strato in funzione delle lunghezze d'onda di progetto
Trasmissività del filtro Fabry-Pérot TiO2/MgF2 a incidenza normale
Modi guidati per la luce blu nel combinatore RGB in guida d'onda
Distribuzione radiale del modo LP01 in fibra monomodale

stm32 · embedded C · 2024

Firmware bare-metal su ARM Cortex-M4

Esercitazioni su Nucleo-F401RE sviluppate in STM32CubeIDE, prima con driver LL a livello di registro e poi con l'HAL: timer e output compare, interrupt EXTI, acquisizione ADC con uscita USART, misura di frequenza in input capture con regolazione del duty cycle PWM.

C · STM32CubeIDE · github.com/bobbisasha/ST32_LABS

Scheda
Nucleo-F401RE
MCU
STM32F401RET6 · Cortex-M4 fino a 84 MHz
Toolchain
STM32CubeIDE · arm-none-eabi-gcc · ST-LINK
Driver
LL a livello di registro (lab 8–9) · HAL (lab 10)
Periferiche
TIM3 · TIM4 · EXTI · ADC1 · USART2
Seriale
USART2 → ST-LINK Virtual COM · 115200 8-N-1
Scheda Nucleo-F401RE
lab8_timers_interrupts_adc/ex1_2_tim3_timer/main.c estratto 
LL_TIM_WriteReg(TIM3, CR1, LL_TIM_ReadReg(TIM3, CR1) | 0x0001);
LL_TIM_WriteReg(TIM3, CCR2, 40);
LL_TIM_WriteReg(TIM3, CCR1, 200);

while (1)
{
  if ((LL_TIM_ReadReg(TIM3, SR) & 0x0002) == 0x0002) {
    LL_TIM_WriteReg(TIM3, SR, LL_TIM_ReadReg(TIM3, SR) ^ 0x0002);
    LL_GPIO_WriteReg(GPIOA, ODR, LL_GPIO_ReadReg(GPIOA, ODR) ^ 0x0400);
    LL_TIM_WriteReg(TIM3, CCR1, LL_TIM_ReadReg(TIM3, CCR1) + 200);
  }
  if ((LL_TIM_ReadReg(TIM3, SR) & 0x0004) == 0x0004) {
    LL_TIM_WriteReg(TIM3, SR, LL_TIM_ReadReg(TIM3, SR) ^ 0x0004);
    LL_GPIO_WriteReg(GPIOB, ODR, LL_GPIO_ReadReg(GPIOB, ODR) ^ 0x0400);
    LL_TIM_WriteReg(TIM3, CCR2, LL_TIM_ReadReg(TIM3, CCR2) + 40);
  }
}
lab8_timers_interrupts_adc/ex1_4_adc_usart/main.c estratto 
//ENABLE DELL ADC e SWSTART
LL_ADC_WriteReg(ADC1, CR2, LL_TIM_ReadReg(ADC1, CR2) | 0x1);
LL_ADC_WriteReg(ADC1, CR2, LL_TIM_ReadReg(ADC1, CR2) | (1 << 30));
//ENABLE TIM3
LL_TIM_WriteReg(TIM3, CR1, LL_TIM_ReadReg(TIM3, CR1) | 0x0001);

while (1)
{
  // Controlla il bit EOC (End Of Conversion)
  int eoc = LL_ADC_ReadReg(ADC1, SR) & 0x0010;
  if (eoc == 0x0010) {
    // Azzeramento del bit EOC
    LL_ADC_WriteReg(ADC1, SR, LL_ADC_ReadReg(ADC1, SR) | 0x0010);
    // Leggi il valore dal registro dati dell'ADC
    double ridden_value = LL_ADC_ReadReg(ADC1, DR);
    newRef = ((-0.04675*ridden_value)+ 14.374) * ridden_value;
  }
  if ((LL_TIM_ReadReg(TIM3, SR) & 0x0002) == 0x0002) {
    //toggle PB10
    LL_GPIO_WriteReg(GPIOB, ODR, LL_GPIO_ReadReg(GPIOB, ODR) ^ 0x0400);
    //Aggiorno soglia OUTPUT COMPARE
    LL_TIM_WriteReg(TIM3, CCR1, LL_TIM_ReadReg(TIM3, CCR1) + newRef);
    //Azzero il bit 1 dello state register
    LL_TIM_WriteReg(TIM3, SR, LL_TIM_ReadReg(TIM3, SR) & 0xFFFD);
  }
}
lab10_hal_timers_pwm/ex2_1_freq_measure_pwm/main.c estratto 
HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) {
  static last = 0;
  int current;
  if (htim == &htim3) {
    current = htim->Instance->CCR1;
    if (last <= current) {
      period = current - last;
    }
    else {
      period = 65535 - last + current;
    }
    last = current;
    freq = 1/(period/(84*1e4));
    int newDC = 41 + ((freq / 280 )- 22.857);
    newDC = ceil(newDC);
    __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, newDC);
  }
}

esd · VHDL su FPGA · 2024

Logica digitale in VHDL su FPGA

Esercitazioni VHDL del corso di Electronic Systems Design per FPGA Intel/Altera DE1, sviluppate in Quartus con testbench per ModelSim: sommatore ripple-carry a 64 bit, moltiplicatore 4×4, contatori, macchine a stati e un'architettura datapath con unità di controllo.

VHDL · Quartus · ModelSim · github.com/bobbisasha/ESD_LABS

Scheda
Intel/Altera DE1 (serie DE)
Toolchain
Quartus · ModelSim / GHDL
Clock
CLOCK_50 · 50 MHz
I/O
SW · KEY · HEX0–HEX5 · LEDR
Lab
aritmetica · contatori e timer · FSM · datapath + CU
Verifica
testbench *_tb / *_tbench
Scheda FPGA DE1
lab3_arithmetic_circuits/rca_64bit/rca_64bit.vhd estratto 
--CLOCK MANUALE
clk <= KEY(1);
resetn <=KEY(0);

--SALVA NEI REGISTRI D INGRESSO
regA : regn port map (signed(SW(127 downto 64)), clk, resetn, A_sign);
regB : regn port map (signed(SW(63 downto 0)), clk, resetn, B_sign);

A <= std_logic_vector(A_sign);
B <= std_logic_vector(B_sign);

-- Initialize Co(0)
Co(0) <= '0';

--SOMMATORE
sommatore : FOR i IN 0 TO 63 GENERATE
  full_adder_temp: full_adder PORT MAP (Co(i), A(i), B(i), S(i), Co(i+1));
END GENERATE sommatore;

--SALVA IN REGISTRO FINALE
regS : regn port map (signed(S),clk, resetn, uscita_sign);
uscita <= std_logic_vector(uscita_sign);

overflow <= Co(64) xor Co(63);

flip_flop0: flipflop PORT MAP (overflow, clk, resetn, v);
La macchina a stati hello_fsm fa scorrere la scritta HELLO sui display a 7 segmenti HEX5–HEX0 hello_fsm · HEX5–HEX0 HEX5 HEX4 HEX3 HEX2 HEX1 HEX0 H E L_0 L O B B = display vuoto Ogni stato emette una lettera; il registro a 6 stadi la fa scorrere sui display.
lab5_finite_state_machines/hello_fsm/hello_fsm.vhd estratto 
TYPE state_type is (H, E, L,L_0, O, B);

reg0: regn port map (serial_in, clock_local, reset_local, reg_out(2 downto 0));

registri: for i in 1 to 5 generate
reg: regn port map(reg_out((3*i)-1 downto (3*i)-3), clock_local,
                   reset_local, reg_out((3*i)+2 downto 3*i));
end generate;

process(clock_local,reset_local)
Begin
  --reset asincrono
  if(reset_local = '0') then
  current_state <= H;

  elsif(Clock_local'EVENT AND Clock_local = '1') then

  case current_state is
    when H => current_state <= E;
    when E => current_state <= L_0;
    when L_0 => current_state <= L;
    when L => current_state <= O;
    when O => current_state <= B;
    when B => current_state <= H;
  END CASE;
  END IF;
End process;
lab5_finite_state_machines/hello_fsm/SevenSegmentDecoder.vhd rivisto 
-- Codici emessi da hello_fsm: H=001, E=010, L=011, O=100, B=101
-- Segmenti attivi bassi, nell'ordine a..g (0 to 6)
architecture Behavioral of SevenSegmentDecoder is
begin
  process (letter_in)
  begin
    case letter_in is
      when "001" =>  -- H
        segments_out <= "1001000";
      when "010" =>  -- E
        segments_out <= "0110000";
      when "011" =>  -- L
        segments_out <= "1110001";
      when "100" =>  -- O
        segments_out <= "0000001";
      when others => -- B: display spento
        segments_out <= "1111111";
    end case;
  end process;
end architecture Behavioral;
Schema a blocchi del lab 6: memorie, datapath, contatori e unità di controllo a macchina a stati Lab 6 · datapath + unità di controllo MEM A 1024 × 8 Datapath REG 0–3 · shift ADD/SUB 17 bit AVG · HIGH · INB MEM B 1024 × 8 ext_data addr A · 10 bit allarme · 4 bit flag addr B · 10 bit Unità di controllo · FSM enable · select · cs/rd/wr idle → load_A → init → shift 0–3 → average → diff_1 save_high → diff_2 → alrm_count → load_B → shift 0–3 | finish start rst done Monitor per irrigazione: campioni in memoria, medie e differenze, allarme.
lab3_arithmetic_circuits/rca_64bit/rca_64bit_tbench.vhd estratto 
constant CLOCK_PERIOD : time := 5 ns;  -- Periodo del clock

BEGIN process
begin
  for i in 1 to 63 loop
    for j in 1 to 63 loop
      SW_TB(127 DOWNTO 64) <= std_logic_vector(to_signed(i, 64));
      SW_TB(63 DOWNTO 0) <= std_logic_vector(to_signed(j, 64));
      KEY_TB <= "11";
      wait for CLOCK_PERIOD;  -- Aspetta un fronte di clock per ogni coppia di valori
      KEY_TB <= "01";
      wait for CLOCK_PERIOD;
    end loop;
  end loop;
  wait;
end process;

DUT: rca_64bit port map(SW_TB, KEY_TB, LEDR_TB, HEX_TB);

Tutti i repository

Esperienze

  1. Apr 2026 — Set 2026

    ART S.p.A. — Radar Signal Processing Intern (tesi MSc)

    Perugia · Tirocinio di tesi magistrale

    • Pipeline embedded di elaborazione del segnale radar per il rilevamento di oggetti in ambito automotive, su SoC radar Texas Instruments mmWave.
    • Clustering DBSCAN delle detection radar.
    • Algoritmo di tracking event-triggered in Python.
    • Progetto dei parametri della forma d'onda FMCW (chirp).
    • Ottimizzazione dei consumi dell'implementazione embedded.

    TI mmWave · FMCW · DBSCAN · Object tracking · Python · Low power

  2. Set 2025 — Feb 2026

    DET, Politecnico di Torino — Electronics Lab Teaching Assistant

    Dipartimento di Elettronica e Telecomunicazioni · Contratto di collaborazione

    • Supporto alle attività didattiche in camera bianca: deposizione di film sottili (CVD, PVD) e di fotoresist.
    • Assistenza a studenti di laurea triennale e magistrale nei laboratori di elettronica e nell'uso della strumentazione da banco.

    Camera bianca · CVD · PVD · Fotoresist · Strumentazione da banco

  3. Gen 2025 — Giu 2025

    DET, Politecnico di Torino — EMC Teaching Assistant

    Dipartimento di Elettronica e Telecomunicazioni · Contratto di collaborazione

    • Supporto agli studenti di laurea triennale nelle esercitazioni di Compatibilità Elettromagnetica (EMC).
    • Assistenza nei laboratori su modulazione AM/FM e interferenze e sulle interferenze EMC della rete elettrica a 50 Hz.

    EMC · Modulazione AM/FM · Interferenze a 50 Hz

Formazione

  1. Ott 2024 — Dic 2026 (prevista)

    Politecnico di Torino — Laurea Magistrale in Ingegneria Elettronica (LM-29)

    Percorso Nano and Micro Electronics

    • Tesi: rilevamento di oggetti basato su radar per applicazioni automotive, in collaborazione con ART S.p.A.
    • Corsi di VLSI, FPGA e MEMS design; attività in camera bianca.
  2. Ott 2021 — Lug 2024

    Politecnico di Torino — Laurea Triennale in Ingegneria Elettronica (L-8)

Lingue e corsi

  1. Livello

    Inglese — B2 (QCER) · Italiano — madrelingua

  2. 2019

    New York, USA — Corso di lingua inglese

  3. 2018

    Bournemouth, Regno Unito — Corso di lingua inglese

Scarica il CV completo

Contatti

Interessato a posizioni in semiconductor process engineering e nella progettazione di IC digitali e MEMS.

[email protected]
+39 373 548 6612 LinkedIn GitHub Pescara, Italia