Pi4Micronaut Documentation

@Controller("/pushButton")
public class PushButtonController {
    private static final Logger log = LoggerFactory.getLogger(PushButtonController.class); 
    private final PushButtonHelper pushButtonHelper;
    private final LEDHelper ledHelper;

    public PushButtonController(@Named("button-input-3") DigitalInput pushButton,
                                @Named("led") DigitalOutput led) {
        this.pushButtonHelper = new PushButtonHelper(pushButton);
        this.ledHelper = new LEDHelper(led);
    }

    @Get("/init")
    public void initController(){
        pushButtonHelper.addEventListener(e ->{
            if(pushButtonHelper.isPressed){
                try {
                    ledHelper.switchState();
                } catch (Exception ex) {
                    log.error("Failed to switch LED state.", ex);
                }
            }
        });
    }
}

@Controller("/slideSwitch")
public class SlideSwitchController {
    private final SlideSwitchHelper slideSwitchHelper;
    private final SlideSwitchHelper slideSwitchHelper2;

    public SlideSwitchController(@Named("slide-switch-input")DigitalInput slideSwitch, 
                                    @Named("slide-switch-input-2")DigitalInput slideSwitch2) {
        this.slideSwitchHelper = new SlideSwitchHelper(slideSwitch);
        this.slideSwitchHelper2 = new SlideSwitchHelper(slideSwitch2);
    }

    @Get("/switch1")
    public boolean checkSwitch1(){
        return slideSwitchHelper.isOn;
    }

    @Get("/switch2")
    public boolean checkSwitch2(){
        return slideSwitchHelper2.isOn;
    }
}

@Controller("/rotaryEncoder")
public class RotaryEncoderController {
    private final RotaryEncoderHelper encoderHelper;

    public RotaryEncoderController(@Named("rotary-encoder") MultiPinConfiguration rotaryEncoder){
        this.encoderHelper = new RotaryEncoderHelper(rotaryEncoder);
    }

    @Get("/value")
    public int getEncoderValue(){return encoderHelper.getEncoderValue();}
}

@Controller("/rfid")
public class RfidController {
    private final RFidHelper rfidHelper;

    public RfidController(@Named("rfid") SpiConfig spi, Context pi4jContext){
        this.rfidHelper = new RFidHelper(spi, 25, pi4jContext);
    }

    @Post("/write/{value}")
    public void writeToCard(String value){
        rfidHelper.writeToCard(value);
    }

    @Get("/read")
    public String readFromCard(){
        Object data = rfidHelper.readFromCard();
        return data.toString();
    }
}

@Controller("/ultraSound")
public class UltraSonicSensorController {
    private final UltraSonicSensorHelper ultraSonicSensorHelper;

    public UltraSonicSensorController(@Named("ultra-sonic-trig") DigitalOutput trig,
                                      @Named("ultra-sonic-echo") DigitalInput echo) {
        this.ultraSonicSensorHelper = new UltraSonicSensorHelper(trig,echo);

    }

    /**
     * Enables the ultrasonic sensor
     */
    @Get("/enable")
    public String enableUltraSonicSensor() {
        this.ultraSonicSensorHelper.startMeasuring();
        return "Ultra Sonic Sensor Enabled \nIf the distance is constantly Zero, make sure the sensor field of view is clear \n";
    }

    /**
     * Returns distance from object in centimeters
     */
    @Get("/distance/cm")
    public String getDistanceInCentimeter() {
        return this.ultraSonicSensorHelper.getDistanceInCentimeter() + " cm\n";
    }

    /**
     * Returns distance from object in meters
     */
    @Get("/distance/m")
    public String getDistanceInMeter() {
        return this.ultraSonicSensorHelper.getDistanceInMeters() + " m\n";
    }

    /**
     * Disables ultrasonic sensor
     */
    @Get("/disable")
    public String disableUltrasoundSensor() {
        this.ultraSonicSensorHelper.stopMeasuring();
        return "Ultra Sonic Sensor Disabled";
    }
}

@Controller("/touchSwitch")
public class TouchSwitchController {
    private static final Logger log = LoggerFactory.getLogger(TouchSwitchController.class);
    private final TouchSwitchHelper touchSwitchHelper;
    private final LEDHelper ledHelper;

    public TouchSwitchController(@Named("touch-switch-input") DigitalInput touchSwitch,
                                 @Named("led2") DigitalOutput led) {
        this.touchSwitchHelper = new TouchSwitchHelper(touchSwitch);
        this.ledHelper = new LEDHelper(led);
    }

    @Get("/enable")
    public void enableTouchSwitch() {
        touchSwitchHelper.addEventListener(e -> {
            try {
                if (touchSwitchHelper.isTouched) {
                    ledHelper.ledOn();
                } else {
                    ledHelper.ledOff();
                }
            } catch (Exception ex) {
                log.error("Error switching LED state", ex);
            }
        });
    }

    @Get("/disable")
    public void disableTouchSwitch() {
        touchSwitchHelper.removeEventListener();
    }
}

@Controller("/pirSensor")
public class PIRSensorController {
    private final PIRSensorHelper pirSensorHelper;
    private final RGBLEDHelper rgbledHelper;

@Controller("/photoResistor")
public class PhotoResistorController {
    private static final Logger log = LoggerFactory.getLogger(PhotoResistorController.class);
    private final LEDHelper ledHelper;
    private final PhotoResistorHelper photoResistorHelper;

    public PhotoResistorController(@Named("photo-resistor-input")DigitalInput photoResistorIN,
                                   @Named("photo-resistor-output")DigitalOutput photoResistorOUT,
                                   @Named("led")DigitalOutput led ) {
        this.photoResistorHelper = new PhotoResistorHelper(photoResistorIN, photoResistorOUT);
        this.ledHelper = new LEDHelper(led);

    }

    @Get("/enable")
    public int enableLightSensor(){
        photoResistorHelper.initialize();
        photoResistorHelper.addEventListener(e -> {
            try {
                if (photoResistorHelper.isDark) {
                    ledHelper.ledOn();
                } else {
                    ledHelper.ledOff();
                }
            } catch (Exception ex) {
                log.error("Error switching LED state", ex);
            }
        });
        return photoResistorHelper.getDark();

    }

    @Get("/getDarkness")
    public int dark() {
        return photoResistorHelper.getDark();
    }

    @Get("/disable")
    public void disableLightSensor() {
        photoResistorHelper.removeEventListener();
    }

    @Post("/threshold/{i}")
    public String setThreshold(@Positive int i) {
        photoResistorHelper.setDarknessThreshold(i);
        return ("Darkness threshold set to "+ i + "\n");
    }

}

@Controller("/tiltSwitch")
public class TiltSwitchController {
    private static final Logger log = LoggerFactory.getLogger(TiltSwitchController.class);
    private final TiltSwitchHelper tiltSwitchHelper; // controls the tilt switch
    private final LEDHelper ledHelper; // controls the LED

    public TiltSwitchController(@Named("tilt-switch-input")DigitalInput tiltSwitch,
                                @Named("led2")DigitalOutput led) {
        this.tiltSwitchHelper = new TiltSwitchHelper(tiltSwitch);
        this.ledHelper = new LEDHelper(led);
    }

    // The 'enable' method adds an event listener that listens for changes in the tilt switch
    // If it is tilted, the LED turns on and off otherwise
    @Get("/enable")
    public void enableTiltSwitch() {
        tiltSwitchHelper.addEventListener(e -> {
            try {
                if (tiltSwitchHelper.isTilted) {
                    ledHelper.ledOn();
                } else {
                    ledHelper.ledOff();
                }
            } catch (Exception ex) {
                log.error("Error switching LED state", ex);
            }
        });
    }

    // The disable method removes the event listener
    @Get("/disable")
    public void disableTiltSwitch() {
        tiltSwitchHelper.removeEventListener();
    }
}

@Controller("/microSwitch")
public class MicroSwitchController { 
    private static final Logger log = LoggerFactory.getLogger(MicroSwitchController.class);
    private final MicroSwitchHelper microSwitchHelper;
    private final LEDHelper ledHelper1;
    private final LEDHelper ledHelper2;

    public MicroSwitchController(@Named("micro-switch") DigitalInput microSwitch,
                                 @Named("led") DigitalOutput led1,
                                 @Named("led2") DigitalOutput led2) {
        this.microSwitchHelper = new MicroSwitchHelper(microSwitch);
        this.ledHelper1 = new LEDHelper(led1);
        this.ledHelper2 = new LEDHelper(led2);
    }
    //enables the micro switch. The LEDs will switch states as the switch is pressed
    @Get("/enable")
    public void enableMicroSwitch() {
        microSwitchHelper.addEventListener(e -> {
            try { 
                if (microSwitchHelper.isPressed) {
                    ledHelper1.ledOff();
                    ledHelper2.ledOn();
                } else {
                    ledHelper1.ledOn();
                    ledHelper2.ledOff();
                }
            } catch (Exception ex) {
                log.error("Error switching LED state", ex);
            }
        });
    }
    //disable the micro switch
    @Get("/disable")
    public void disableMicroSwitch() {
        microSwitchHelper.removeEventListener();
    }
}

@Controller("/passive-buzzer")
public class PassiveBuzzerController {
    private final PassiveBuzzerHelper passiveBuzzerHelper;

    protected int passBuzzFreq = 440;
    protected int passBuzzDC = 50;

    public PassiveBuzzerController(@Named("passive-buzzer") Pwm passiveBuzzerOutput){
        this.passiveBuzzerHelper = new PassiveBuzzerHelper(passiveBuzzerOutput);
    }

    /**
     * Enables passive buzzer
     */
    @Get("/enable")
    public void enablePassiveBuzzer(){

        passiveBuzzerHelper.passiveBuzzerOn(passBuzzDC, passBuzzFreq);

    }

    /**
     * Disables passive buzzer
     */
    @Get("/disable")
    public void disablePassiveBuzzer(){

        passiveBuzzerHelper.passiveBuzzerOff();

    }

    /**
     *
     * Displays the current frequency of the passive buzzer.
     */
    @Get("/showFreq")
    public void passiveBuzzerFreq(){

        passiveBuzzerHelper.getFrequency();

    }

    /**
     *
     *  Takes one file arg, function will allow use to set their own frequencies
     *  to be played by the passive buzzer. In order for the frequencies to be played
     *  the user must do the following:
     *  - Place their frequencies into a text file with the frequencies separated by commas
     *  - use the scp command to copy the file over to the raspberrypi
     *    - (i.e.: scp C:\Users\CompName\filename.txt name@raspberrypiname.local:/home/CompName)
     *  - Once file is copied over to the pi use the curl -X POST command to play the file
     *    - (i.e.: curl -X POST "http://localhost:8080/passive-buzzer/setFreq/filename.txt"
     */

    @Post("/setFreq/{frequenciesFile}")
    public void defineFrequency(String frequenciesFile){
        passiveBuzzerHelper.setFrequencies(new File(frequenciesFile));
    }

    /**
     * Validates the functionality of the passive buzzer
     */
    @Get("/passBuzz")
    public void singlePassiveBuzz(){
        passiveBuzzerHelper.passiveBuzzTone();
    }

    /**
     * Ensures that the passive buzzer can cycle through different frequencies
     */
    @Get("/freqIter")
    public void passiveFreqIter(){
        passiveBuzzerHelper.toneIterator();
    }

    /**
     * Calls toneSequence function to play a pre-defined song.
     */
    @Get("/playPiSeq")
    public void playPiTone(){

        passiveBuzzerHelper.piToneSequence();

    }
}

@Controller("/active-buzzer")
public class ActiveBuzzerController {
    private final ActiveBuzzerHelper activeBuzzerHelper;

    public ActiveBuzzerController(@Named("active-buzzer") Pwm activeBuzzerOutput){
        this.activeBuzzerHelper = new ActiveBuzzerHelper(activeBuzzerOutput);
    }

    /**
     * Enables the active buzzer
     */
    @Get("/enable")
    public void enableActiveBuzzer(){

        activeBuzzerHelper.activeBuzzerOn();

    }

    /**
     * Disables the active buzzer
     */
    @Get("/disable")
    public void disableActiveBuzzer(){

        activeBuzzerHelper.activeBuzzerOff();

    }

    /**
     * Emits a beep sound from the active buzzer.
     */
    @Get("/beepTone")
    public void playBeepTone(){

        activeBuzzerHelper.beep();

    }

    /**
     * Emits an intermittent tone from the active buzzer for a duration of 20 seconds.
     * 10 seconds of sound and 10 seconds of silence
     */
    @Get("/intermittentTone")
    public void playIntermittentTone(){

        activeBuzzerHelper.intermittentTone();

    }

    /**
     * Tests the active buzzer by emitting the word "pi" in morse code.
     */
    @Get("/morseCode")
    public void morseCodeTest(){

        activeBuzzerHelper.morseCodeTone();
    }
}

@Controller("/servoMotor")
public class ServoMotorController {
    private final ServoMotorHelper servoMotorHelper;

    public ServoMotorController(@Named("servo-motor")Pwm servoMotor) {
        this.servoMotorHelper = new ServoMotorHelper(servoMotor);
    }

    @Get("/enable")
    public void enableServoMotor() {
        servoMotorHelper.enable();
    }

    @Get("/disable")
    public void disableServoMotor() {
        servoMotorHelper.disable();
    }

    @Get("/setAngle/{angle}")
    public void setAngle(int angle) {
        servoMotorHelper.setAngle(angle);
    }
}