ECE5725 Project

Work Distribution

Project group picture

Haotian Tan

ht499@cornell.edu

Hardware design and assembly, including the spinner and mirror holders. I also worked on the motor control system, including the ESC setup and initial testing of the laser projection system.

Weixuan Sun

ws495@cornell.edu

Software Architecture and Design, including the initial setup of the Raspberry Pi and the development of the laser control logic. I also worked on the integration of the IR sensors and the synchronization of the laser pulses with the mirror positions.

Code Appendix

RPI

#!/usr/bin/env python3
# Lab Section: Monday Group 4
# Date       : 05/16/25
# Members    : Haotian Tan(ht499), Weixuan Sun(ws495)




import os, sys, time, math, collections
import pigpio, pygame


BTM_PIN, LASER_PIN                  = 27, 4
BTN_UP_PIN, BTN_DN_PIN, BTN_QT_PIN = 17, 22, 23


FACETS_PER_REV = 12          
AVG_SAMPLES    = 12          
FPS            = 30          
SWEEP_SCALE    = 0.10        
DUTY_STEP      = 0.01        
STALL_MS       = 500        
SLIDER_H, SLIDER_M           = 20, 20


# pigpio initialisation
pi = pigpio.pi()
if not pi.connected:
    sys.exit("pigpiod not running – start with: sudo pigpiod")


for pin in (BTM_PIN, BTN_UP_PIN, BTN_DN_PIN, BTN_QT_PIN):
    pi.set_mode(pin, pigpio.INPUT)
    pi.set_pull_up_down(pin, pigpio.PUD_UP)  # buttons are active‑LOW


pi.set_mode(LASER_PIN, pigpio.OUTPUT)
pi.write(LASER_PIN, 0)  # laser starts OFF


# PiTFT setup
os.environ.setdefault("SDL_VIDEODRIVER", "fbcon")
os.environ.setdefault("SDL_FBDEV", "/dev/fb0")
pygame.init(); screen = pygame.display.set_mode((0, 0))  # full‑screen
W, H = screen.get_size()


font_big   = pygame.font.SysFont(None, 40, bold=True)
font_small = pygame.font.SysFont(None, 26)
WHITE, GREEN, GREY, BLACK = (255,)*3, (80,255,80), (60,60,60), (0,0,0)




RADAR_C = (30, (H - SLIDER_H)//2)  # radar centre (x,y)
RADAR_R = 20                       # radar radius
TEXT_X  = RADAR_C[0] + RADAR_R + 10
TEXT_Y  = RADAR_C[1]


rows_us       = collections.deque(maxlen=AVG_SAMPLES)
last_tick     = None              
last_edge     = time.monotonic()  


duty          = 0.0  
pulse_us      = 0    
rpm           = 0.0  
row_us        = 0.0  


btn_up = btn_dn = False
running = True
current_wave = None  


# Graphics helper
def draw(angle: float) -> None:
    screen.fill(BLACK)


    # radar sweep
    end = (RADAR_C[0] + RADAR_R*math.cos(math.radians(angle)),
           RADAR_C[1] + RADAR_R*math.sin(math.radians(angle)))
    pygame.draw.circle(screen, GREY, RADAR_C, RADAR_R, 1)
    pygame.draw.line(screen, GREEN, RADAR_C, end, 2)


    # RPM + period text
    hud = font_big.render(f"{rpm:6.1f} RPM   {row_us:7.1f} µs", True, WHITE)
    screen.blit(hud, hud.get_rect(midleft=(TEXT_X, TEXT_Y)))


    # duty slider
    slider = pygame.Rect(SLIDER_M, H-SLIDER_H-8, W-2*SLIDER_M, SLIDER_H)
    knob_x = slider.left + int(slider.width*duty)


    pygame.draw.rect(screen, GREY, slider, 1)
    fill = slider.copy(); fill.width = knob_x-slider.left
    pygame.draw.rect(screen, GREEN, fill)
    pygame.draw.circle(screen, WHITE, (knob_x, slider.centery), SLIDER_H//2-2)


    label = font_small.render(f"Laser {duty*100:3.0f}%  ({pulse_us:4d} µs)", True, WHITE)
    screen.blit(label, label.get_rect(midleft=(slider.left, slider.top-24)))
    pygame.display.flip()




# measure the rotation time and helps to adjust the laser length
def facet_cb(_gpio, level, tick):
    global last_tick, rpm, row_us, last_edge, pulse_us, current_wave


    if level != pigpio.HIGH:  # ignore falling edges / noise
        return


    # period measurement
    if last_tick is not None:
        dt = pigpio.tickDiff(last_tick, tick)
        rows_us.append(dt)
        row_us = sum(rows_us) / len(rows_us)
        rpm = 60000000 / (row_us * FACETS_PER_REV)
    last_tick, last_edge = tick, time.monotonic()


    # stop previous wave
    pi.wave_tx_stop()
    pi.write(LASER_PIN, 0)


    # build and send new pulse to control the laser length dynamically
    if rows_us:
        pulse_len = int(rows_us[-1] * duty)
        pulse_us = pulse_len
        if pulse_len:
            seq = [pigpio.pulse(1<= 0:
                pi.wave_send_once(wid)
                current_wave = wid


pi.callback(BTM_PIN, pigpio.RISING_EDGE, facet_cb)




# turning the laser length up
def btn_up_cb(gpio, level, tick):
    global btn_up
    if level == pigpio.LOW:     # button pressed
        btn_up = True
    elif level == pigpio.HIGH:  # button released
        btn_up = False


# turning the laser length down
def btn_dn_cb(gpio, level, tick):
    global btn_dn
    if level == pigpio.LOW:
        btn_dn = True
    elif level == pigpio.HIGH:
        btn_dn = False


# quit button
def btn_qt_cb(gpio, level, tick):
    global running
    if level == pigpio.LOW:  # only act on press
        running = False


# register button callbacks for controlling laser length and quit
pi.callback(BTN_UP_PIN, pigpio.EITHER_EDGE, btn_up_cb)
pi.callback(BTN_DN_PIN, pigpio.EITHER_EDGE, btn_dn_cb)
pi.callback(BTN_QT_PIN, pigpio.FALLING_EDGE,  btn_qt_cb)




# Main loop
clock = pygame.time.Clock()
angle = 0.0


while running:
    clock.tick(FPS)                 # fixed frame duration


    if btn_up:
        duty = min(duty + DUTY_STEP, 1.0)
    if btn_dn:
        duty = max(duty - DUTY_STEP, 0.0)


    # zero readout if stalled
    if time.monotonic() - last_edge > STALL_MS/1000:
        rpm = row_us = pulse_us = 0


    # update radar sweep
    angle = (angle + rpm*6*SWEEP_SCALE/FPS) % 360
    draw(angle)


    for evt in pygame.event.get():
        if evt.type in (pygame.QUIT, pygame.KEYDOWN):
            running = False


Arduino:
#define TOP_PIN   2
#define BTM_PIN   4
#define LASER_PIN 3


const unsigned long PULSE_WIDTH_US = 1000;   // laser on time
const int  FACETS_PER_REV = 12;
const int  TARGET_INDEX   = 3;               // only one mirror on


int  facet_idx       = 0;
bool last_top_state  = HIGH;
bool last_btm_state  = HIGH;


void setup() {
  pinMode(TOP_PIN,  INPUT_PULLUP);
  pinMode(BTM_PIN,  INPUT_PULLUP);
  pinMode(LASER_PIN, OUTPUT);


  Serial.begin(115200);
}


void loop() {
  bool top_now = digitalRead(TOP_PIN);
  bool btm_now = digitalRead(BTM_PIN);


  // full revolution marker
  if (last_top_state == HIGH && top_now == LOW) {
    facet_idx = 0;
    Serial.println(F("new revolution"));
  }


  // mirror marker
  if (last_btm_state == HIGH && btm_now == LOW) {
    Serial.print(F("[BTM] mirror "));
    Serial.print(facet_idx);


    if (facet_idx == TARGET_INDEX) {
      Serial.print(F(" fire laser"));
      digitalWrite(LASER_PIN, HIGH);
      delayMicroseconds(PULSE_WIDTH_US);
      digitalWrite(LASER_PIN, LOW);
    }


    Serial.println();
    facet_idx = (facet_idx + 1) % FACETS_PER_REV;
  }


  last_top_state = top_now;
  last_btm_state = btm_now;
}
              

Arduino

#define TOP_PIN    2          // One full-rotation sync sensor
#define BTM_PIN    4          // Reflector-per-facet sensor (12 per revolution)
#define LASER_PIN  3
#define PULSE_WIDTH_US 1000
#define TARGET_INDEX 3        // Which facet index to fire the laser (0~11)

int trigger_count = 0;
bool last_btm_state = HIGH;
bool last_top_state = HIGH;

void setup() {
  pinMode(TOP_PIN, INPUT_PULLUP);
  pinMode(BTM_PIN, INPUT_PULLUP);
  pinMode(LASER_PIN, OUTPUT);

  Serial.begin(115200);
  Serial.println("Synchronized single-pulse laser test");
}

void loop() {
  bool current_top = digitalRead(TOP_PIN);
  bool current_btm = digitalRead(BTM_PIN);

  // If TOP sensor triggers (start of a full revolution), reset counter
  if (last_top_state == HIGH && current_top == LOW) {
    trigger_count = 0;
    Serial.println("[TOP] Reset trigger count");
  }

  // If BTM sensor detects a reflector facet
  if (last_btm_state == HIGH && current_btm == LOW) {
    Serial.print("[BTM] Reflector #");
    Serial.print(trigger_count);

    if (trigger_count == TARGET_INDEX) {
      Serial.print(" → Laser ON");
      digitalWrite(LASER_PIN, HIGH);
      delayMicroseconds(PULSE_WIDTH_US);
      digitalWrite(LASER_PIN, LOW);
    }

    Serial.println();
    trigger_count = (trigger_count + 1) % 12;
  }

  last_top_state = current_top;
  last_btm_state = current_btm;
}