Difference between revisions of "SJ One Board"

int main(void)
{
    /* Assume we attached our P1.20 to the MOSFETs GATE pin
     * You can use any pin defined at gpio.hpp file and locate that pin
     * on your board. Use "Ctrl+Shift+R" and search for "gpio.hpp" file.
     */
    GPIO pin20(P1_20);   /* Use P1.20 as General Purpose Input/Output (GPIO) */
    pin20.setAsOutput(); /* Use this pin as OUTPUT */
 
    pin20.setHigh(); /* Turn on voltage to 3.3v */
    pin20.setLow();  /* Turn off voltage to 0v  */
}

#include "gpio.hpp"
#include "utilities.h"

int main(void)
{
    /* Assume we attached our P1.20 to the buzzer */
    GPIO buzzer(P1_20);   /* Use P1.20 as General Purpose Input/Output (GPIO) */
    buzzer.setAsOutput(); /* Use this pin as OUTPUT */
 
    while (1) {
        /* Beep for one second */
        for (int i = 0; i < 1000; i+=2) {
            delay_ms(1);
            buzzer.setHigh();
            delay_ms(1);
            buzzer.setLow();
        }
    }

    /* 2nd option: Use a PWM */
}

#include "gpio.hpp"
#include "utilities.h"

int main(void)
{
    /* Assume we attached our P1.20 to out motion sensor's output pin */
    GPIO motion(P1_20);   /* Use P1.20 as General Purpose Input/Output (GPIO) */
    motion.setAsInput();
    motion.enablePullUp();
 
    while(1) {
        /* Get average of one second */
        int count = 0;
        for (int i = 0; i < 1000; i++) {
            /* If output is low, then motion has been detected, but it could be false positive */
            if (!motion.read()) {
                count++;
            }
            delay_ms(1);
        }

        /* Test and calibrate yourself: */
        bool motionDetected = (count > 50);
    }
}

#include "io.hpp"

void led_sw()
{    
    if (SW.getSwitch(1)) { /* Check if button 1 is pressed */
        LE.on(1);          /* Turn on LED # 1              */
        LD.setNumber(1);   /* LED display will show "1"    */
    }
    else {
        LE.setAll(0); /* Turn off all LEDs */
        LD.clear();   /* Clear the display */
    }
}

#include "io.hpp"

void sensors()
{
    int light_value = LS.getRawValue();

    int tilt_x = AS.getX();
    int tilt_y = AS.getY();
    int tilt_z = AS.getZ();

    int temperature_f = TS.getFarenheit();
}

/* Read this include file for more info */
#include "lpc_pwm.hpp"

/**
 * You can control up to 6 servos with hardware signals (and more with sw)
 * Each signal is mapped to from P2.0 to P2.5
 */
void motor_control()
{
    /* Use 1Khz PWM.  Each PWM shares the 1st frequency you set */
    PWM motor1(PWM::pwm1, 1000);
    PWM motor2(PWM::pwm2, 0);

    /* Set to 50% motor speed */
    motor1.set(50);
    motor2.set(50);
}
void servo_control()
{
    /* Use 50Hz PWM for servos.  Each PWM will be 50Hz */
    PWM servo1(PWM::pwm1, 50);
    PWM servo2(PWM::pwm2, 0);

    servo1.set(5.0);  ///< Set to left position
    servo2.set(10.0); ///< Set to right position
}

#include "io.hpp"

void file_io()
{
    /* Option 1 : C library I/O (less efficient) 
     * 0: is for SPI Flash
     * 1: is for SD Card
     */
    FILE *fd = fopen("0:myfile.txt", "r");
    char line[128] = { 0 };
    if (fd) {
        fgets(line, sizeof(line)-1, fd);
        fclose(fd);
    }


    /* Option 2 : Use "storage" object (more efficient)
     * This option doesn't require 'ENABLE_C_FILE_IO'
     */
    
    /* Write "hello" to "myfile.txt" */
    Storage::write("0:myfile.txt", "hello", 5, 0))

    /* Read the size of data array from myfile.txt
     * Not using 0: or 1: will default to 0: (SPI Flash)
     */
    char data[16] = { 0 };
    Storage::read("myfile.txt", data, sizeof(data)-1, 0));
}

#include "uart2.hpp"
#include "uart3.hpp"

void uart()
{
    Uart2& u2 = Uart2::getInstance();
    Uart3& u3 = Uart3::getInstance();

    u2.init(38400); /* Init baud rate */
    u3.init(19200); /* Init baud rate */

    u2.putline("Hello World\n");
    u3.putline("Hello World\n");

    /* Reference the documentation of Uart2 or Uart3 header file for more functions.
     * Most of the functionality is in a base class called uart_dev.cpp
     */
}

#include “adc0.h”
 
int main(void)
{
    int reading = 0;
 
    /* The only thing that is needed is ADC input pin selection
     * ADC0 is already initialized before main() is called
     */
    LPC_PINCON->PINSEL3 |=  (3 << 28); // Select ADC-4 on P1.30
 
    while(1) {
        reading = adc0_get_reading(4); // Read the value of ADC-4
        printf("\nADC Reading: %d", reading);
 
        delay_ms(1000);
    }
 
    return 0;
}

/* Add this on top of main()
 * Read "scheduler.task" for more documentation
 * Read "examples.cpp" for more examples.
 */
class myTask : public scheduler_task
{
    public:
        myTask (uint8_t priority) : scheduler_task("mytask", 512*8, priority) {
        }

        /* this function will be called in a loop by FreeRTOS */
        bool run(void *p)
        {
            puts("Hello");
            vTaskDelay(1000);
            return true; /* Returning false will suspend the task */
        }
};

int main(void)
{
   // ...
   /* Add your new task here */
   scheduler_add_task(new myTask(PRIORITY_LOW));
   // ...
   scheduler_start(false);
   // ...
}

/* At terminal.cpp, add the following code at the taskEntry() function */
bool terminalTask::taskEntry()
{
    // ...

    CMD_HANDLER_FUNC(myCmdHandler);
    cp.addHandler(myCmdHandler,   "newcmd",  "This is help message. 'newcmd test' will display: 'OK'");

    // ...
    return true;
}




/* ----------------------------------------------
 * Your source file, such as "my_source.cpp"
 * We will add our command handler function here
 */
#include "command_handler.hpp"

CMD_HANDLER_FUNC(myCmdHandler)
{
    /* cmdParams is a str passed to you after user's command, ie: "newcmd test"
     * output is a UartDev base class that you can use to output a reply message
     * See "handlers.cpp" for more examples
     */
    if(cmdParams == "test") {
        output.printf("OK!\n");
    }
    else {
        output.printf("ERROR for my command\n");
    }
}

#ifndef MY_NEW_FILE_H__
#define MY_NEW_FILE_H__

/* need the C++ header */
#ifdef __cplusplus
extern "C"
#endif



/* Now include your function headers */



#ifdef __cplusplus
}
#endif
#endif /* end MY_NEW_FILE_H__ */