/*
* main.c
*/
void main() {
init_pins();
init_button();
init_adc();
init_wdt();
WDT_delay = CURRENT_DELAY;
BCSCTL1 = CALBC1_8MHZ;
DCOCTL = CALDCO_8MHZ;
LCD_setup();
_bis_SR_register(GIE); // enable interrupts
// initialize LCD and say hello a few times :-)
LCD_init();
LCD_send_string((char*)msg);
while(1){
LCD_put(0x80+40); // cursor to line 2, first position
snprintf(hex, 20, HEX, (int)colourArray[1], (int)colourArray[2], (int)colourArray[0]);
LCD_send_string(hex);
}
_bis_SR_register(LPM0_bits);
//delay(0); // maximum delay
}
void main(void)
{
init_pins();
init_oscillator();
SPI1_Initialize();
float temp = 0;
// Set all pins RD1-7 to inputs, RD0 (MSB is set to output)
//TRISD = 0b11111110;
// RC2 is PWM pin
TRISCbits.RC2 = 0;
configure_adc();
configure_pwm();
int ticks = 0;
while (1)
{
MAX_7221_INIT();
temp = get_temperature(0);
set_fan_speed(temp);
if(ticks % 125 == 0) {
MAX_7221_WRITE_FLOAT(temp, 3);
ticks = 0;
}
ticks++;
}
}
Uart0::Error Uart0::open() {
if (is_open())
return kPortAlreadyOpen;
/* Initializes the Buffers */
in_buffer_.create("Uart0 Rx Buffer", kBufferSize);
out_buffer_.create("Uart0 Tx Buffer", kBufferSize);
/* Enable the UART0 peripheral. */
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
/* Configure Pins. */
Error pins_ok = init_pins();
if (pins_ok != kOK)
return pins_ok;
/* Configure UART. */
Error uart_ok = config_uart();
if (uart_ok != kOK)
return uart_ok;
/* Change the status */
open_ = true;
g_uart0_object = this;
return kOK;
}
int main(int argc, char** argv) {
// BMXPUPBA = BMXPFMSZ - 0x4000;
// sizeof(presets) = 17820 bits
// 0x5000 = 20480
INTCONbits.MVEC = TRUE; //Multi-vector interrupt mode
asm volatile("ei"); //Autorise les macro-ASM (interruptions)
// memcpy(&presets, flash_adress, sizeof(presets));
init_Menus();
init_pins();
init_lcd();
init_preset();
create_tab_env();
create_tab_frequenz();
create_tab_period();
init_MIDI();
// init_pwm();
init_dac();
update_menu();
while (42)
{
boutons();
processEncodeur();
WDTCONbits.WDTCLR = 1;
}
return (0);
}
int main(int argc, char** argv) {
init_pins();
init_lcd();
lcd_print("SynthyTwo");
lcd_goto(1, 2);
lcd_print("Coming Soon...");
while (42)
;
return (EXIT_SUCCESS);
}
static void __init init_ioports(void)
{
struct device_node *dnode;
struct property *prop;
int len;
init_pins(ARRAY_SIZE(tqm8xx_pins), &tqm8xx_pins[0]);
cpm1_clk_setup(CPM_CLK_SMC1, CPM_BRG1, CPM_CLK_RTX);
dnode = of_find_node_by_name(NULL, "aliases");
if (dnode == NULL)
return;
prop = of_find_property(dnode, "ethernet1", &len);
if (prop == NULL)
return;
/* init FEC pins */
init_pins(ARRAY_SIZE(tqm8xx_fec_pins), &tqm8xx_fec_pins[0]);
}
int main(int argc, char** argv) {
init_pins();
init_preset();
init_lcd();
lcd_print("EA EB EC ED ");
lcd_print("SynthyTwo");
lcd_goto(1, 2);
// lcd_print("Coming Soon...");
while (42)
processEncodeur();
return (0);
}
int main(void) {
init_pins(); //Initializes the leds and the read write enabler pins as outputs
init_USART1(BOTTOM_MOTOR_BAUD); // initialize USART1 baud rate
init_USART2(TOP_BOTTOM_BAUD); // initialize USART2 baud rate
GPIO_SetBits(GPIOD, READ_WRITE_ENABLER); //Turns the read/write pin for rs485 to write mode
Delay(0xFFF); //Delays to give the read/write pin time to initialize
while (1){
//Reads the top packet, converts the top packet to motor packets, and then sends the motor packets to the motor controllers
if(handleTopPacket()) //If the read top packet function was successful, go within the if statement
{
GPIO_ResetBits(GPIOD, BLUE_LED);
//Increments how many times the motor packets have been sent
pollCounter++;
//Waits for twenty packets to be sent to the motors before polling a motor.
if(pollCounter > PACKETS_SENT_BEFORE_POLLED)
{
GPIO_SetBits(GPIOD, RED_LED);
//Sends a packet to poll the motor at pollAddress
pollMotor(pollAddress);
if(!readSlavePacket()) //If we cannot read the packet
{
//TODO
}
//Add the fault data information to the packet we are sending back to the battle station
//Increments through the addresses and goes back to address one after eight time
pollAddress++; //Changes which motor will be polled next
if(pollAddress == 9)
pollAddress = 1;
pollCounter = 0; //Resets the poll counter
}
}
GPIO_ResetBits(GPIOD, GREED_LED); //Turns off the led
GPIO_ResetBits(GPIOD, RED_LED);
}
}
int main(void)
{
// disable global interrupts
cli();
init_pins();
init_timer1();
// reenable global interrupts
sei();
// loop forever while interrupts do the real work
// TODO: sleep cpu here instead of looping
while(1);
}
int main ()
{
// Disable the ADC
disable_adc();
// Watchdog timer reset safety check
wdt_reset_safety();
// Initialise watchdog timer
init_wdt();
// Identify input and output pins
init_pins();
// Buffer for text
char s[20];
// Setup direction and port for debug logging
STX_PORT |= 1<<STX_BIT;
STX_DDR |= 1<<STX_BIT;
// Initialise DSP
int i = 0;
for (; i < MAX_READINGS; i++) readings[i] = 0;
for (;;)
{
// Go to sleep
sleep_avr();
// Read VCC and convert to base 10 number
long vcc = read_vcc();
dsp(vcc);
utoa(average, s, 10);
// Output VCC to soft serial PIN STX_BIT
sputs(s);
sputs("\n\r");
if (average > FULL_CHARGE_MV)
{
init_wdt_05s();
blink();
}
else init_wdt();
}
}
int main(int argc, char** argv) {
//---------- FLASH ------------
// MCHP_FLASH_ENABLE non fonctionnel
// MCHPCONbits.FAEN = 1; non fonctionnel
// while(MCHPCONbits.FCBUSY); non fonctionnel
// NVMCONbits.WR = 1;
// NVMCONbits.NVMOP = ?;
init_pins();
init_preset();
init_Menus();
INTCONbits.MVEC = TRUE; //Multi-vector interrupt mode
asm volatile("ei"); //Autorise les macro-ASM (interruptions)
init_lcd();
create_tab_env();
create_tab_frequenz();
create_tab_period();
init_MIDI();
init_pwm();
init_dac();
/* PMCON = 0;
PMAEN = 0;
PMMODE = 0;
PMADDR = 0;
PMSTAT = 0;
PMDIN = 0;
PMDOUT = 0;
AD1CON1 = 0;
AD1CON2 = 0;
AD1CON3 = 0;
AD1CHS = 0;
AD1CSSL = 0;
U2STA = 0;
U2MODE = 0;*/
update_menu();
while (42) {
boutons();
processEncodeur();
}
return (0);
}
int init(){
uint32_t revision = getBoardRev();
uint32_t offset = ((revision == 0xa01041 || revision == 0xa21041)?0x1F000000:0);
if(revision == 0xa01041)
revision = 0x10;//pi2 has B+ pinout
else if(revision == 0xa21041)
revision = 0x13;//pi2 has B+ pinout
if(revision >= PINMASKS_LEN || !rpi_model_pinmasks[revision]){
fprintf(stderr, "UNKNOWN_REVISION: 0x%08X\n", revision);
return 1;
}
if(map_registers(offset))
return 1;
_board_revision = revision;
init_pins();
srand(time(NULL));
return 0;
}
void uart_init(void)
{
init_pins();
/*
* Setting a baud rate found on p.488 of user guide.
* Initializing the UART is on p.479 of user guide.
*/
UCA0CTL1 |= UCSWRST;
/*
* The following code block sets the clock source as the ACLK which should be running
* at 32.678 kHz.
*
* UCOS16 = 0; UCA0BR0 = 3; UCA0BRF0 = unchanged; UCA0BRS0 = 0x92
*
* TODO : THIS DOESN'T WORK. PERHAPS THE CRYSTAL IS NOT WORKING PROPERLY OR YOU
* ARE MISUNDERSTANDING HOW TO SOURCE FROM THE CRYSTAL.
*/
// UCA0CTL1 |= UCSSEL_1; //set the baud rate clock source to be ACLK
// UCA0BR0 = 3; //clock prescaler
// UCA0BR1 = 0;
// UCA0MCTLW |= 0x9200; //set the whole register in one instruction
/*
* The following code block sets the clock source as the SMCLK which should be running
* at 1 MHz
*
* UCOS16 = 1; UCA0BR0 = 6; UCA0BRF0 = 8; UCA0BRS0 = 0x20; <-- should probably be 0x11
*/
UCA0CTL1 |= UCSSEL_2; //set the baud rate clock source to be SMCLK
UCA0BR0 = 6; //clock prescaler
UCA0BR1 = 0;
UCA0MCTLW |= UCOS16;
UCA0MCTLW |= 0x1180;
UCA0CTL1 &= ~UCSWRST;
}
void bbio::open(){
// GPIO init
init();
init_pins(); // ALL 5 pins are HIGH except for GND
init_DAConvAD5328();
//BBBIO init
iolib_init();
BBBIO_sys_Enable_GPIO(BBBIO_GPIO1);
BBBIO_GPIO_set_dir(BBBIO_GPIO1 ,
port_dout_SPI[0] ,
port_din_SPI[0] | port_clk_SPI[0] | port_cs_SPI[0]);
BBBIO_GPIO_low(BBBIO_GPIO1 ,port_din_SPI[0]);
BBBIO_GPIO_low(BBBIO_GPIO1 ,port_clk_SPI[0]);
BBBIO_GPIO_low(BBBIO_GPIO1 ,port_cs_SPI[0]);
}
int read_my_testcase(char *cells_file,char *nets_file, char *area_file, double *chip_width, double *chip_height)
{
FILE *cells, *area, *nets;
char buffer[MAX_LINE_CHARS] = {0,};
double utilization = 0;
cells = fopen(cells_file, "r");
if (cells == NULL) {
printf("Could not open cells file.");
return 1;
}
while (fgets(buffer, MAX_LINE_CHARS, cells) != NULL) {
create_lists_depending_on_type(buffer);
}
fclose(cells);
area = fopen(area_file, "r");
if(area != NULL) {
fscanf(area,"chip height = %lf chip width = %lf", chip_height, chip_width);
fclose(area);
}
else {
printf("No area file given. Calculating area form circuit.\n");
scanf("%lf", &utilization);
calculate_area(chip_width, chip_height, utilization);
init_pins(*chip_width, *chip_height);
}
nets = fopen(nets_file, "r");
if(nets == NULL) {
printf("Could not open nets file.\n");
return 1;
}
while (fgets(buffer, MAX_LINE_CHARS, nets) != NULL) {
create_net_list(buffer);
}
fclose(nets);
return 0;
}
/**
* @return Return 0 on success and not 1 on failure.
*/
int init(){
RASPBERRY_PI_INFO_T info;
getRaspberryPiInformation(&info);
uint32_t offset = info.peripheralBase - 0x20000000;
if (info.model == RPI_MODEL_B_PI_2 || info.model == RPI_MODEL_ZERO) {
info.revisionNumber = 0x10;
}
if(info.revisionNumber >= PINMASKS_LEN || !rpi_model_pinmasks[info.revisionNumber]){
fprintf(stderr, "UNKNOWN_REVISION: 0x%08X\n", info.revisionNumber);
return 1;
}
if(map_registers(offset))
return 1;
_board_revision = info.revisionNumber;
init_pins();
srand(time(NULL));
return 0;
}
int main (void)
{
init_pins();
char* bt_data = bt_init();
pacer_init (LOOP_POLL_RATE);
pio_output_set(PIO_AUX_ENABLE, 0);
short aux_power = 0;
while (1)
{
pacer_wait ();
pio_output_set(PIO_LED_G, bt_connected());
if (bt_read()) {
process_command(bt_data);
}
}
}
void matrix_init(void) {
debug_enable = true;
debug_matrix = true;
debug_mouse = true;
// Set pinout for right half if pinout for that half is defined
if (!isLeftHand) {
#ifdef MATRIX_ROW_PINS_RIGHT
const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
row_pins[i] = row_pins_right[i];
}
#endif
#ifdef MATRIX_COL_PINS_RIGHT
const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
col_pins[i] = col_pins_right[i];
}
#endif
}
thisHand = isLeftHand ? 0 : (ROWS_PER_HAND);
thatHand = ROWS_PER_HAND - thisHand;
// initialize key pins
init_pins();
// initialize matrix state: all keys off
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
}
debounce_init(ROWS_PER_HAND);
matrix_init_quantum();
}
int main(void) {
debug_init();
init_fcy();
init_pins();
// Start level - inverted
LATBbits.LATB15 = 1;
// Each bit is encoded as:
// 0: High(0.4 us +- 150 ns) then Low(0.85 us +- 150ns)
// 1: High(0.8 us +- 150 ns) then Low(0.45 us +- 150ns)
//
// The timing is very sensitive and jmps and shifts takes a long time.
// I had to rearrange the if statement and put the shifts in the "long"
// part of the bits. The Nop() lengths were timed with the help of an
// oscilloscop.
#define HIGH_LONG() Nop(); Nop(); Nop(); Nop(); Nop(); Nop(); Nop(); Nop(); Nop(); Nop(); Nop(); Nop()
#define HIGH_SHORT() Nop(); Nop(); Nop()
#define LOW_LONG() Nop(); Nop(); Nop(); Nop(); Nop(); Nop()
#define LOW_SHORT()
#define INVERT_BOOL(x) ((x) = (x) == 0)
#define SEND_AND_SHIFT_BIT(value) \
INVERT_BOOL(LATBbits.LATB15); \
if (!(value & 0b10000000)) { \
HIGH_SHORT(); \
INVERT_BOOL(LATBbits.LATB15); \
value <<= 1; \
LOW_LONG(); \
} else { \
value <<= 1; \
HIGH_LONG(); \
INVERT_BOOL(LATBbits.LATB15); \
LOW_SHORT(); \
}
// Get it to shine!
// RGB values for the nine LEDs
// plus three extra values to make shifting of the colors easier.
char ga[9 + 3];
char ra[9 + 3];
char ba[9 + 3];
// Intensity progression. Offset sine curve.
// Use int instead of floats.
// 1000 * (1 + sin(360 / 9 * i) when i = [0..8]
unsigned int intensity_progression[9] = {
1000,
1642,
1984,
1866,
1342,
658,
134,
16,
356
};
#define INTENSITY_MAX 2000
#define AMPLITUDE 30
// Add the intensity curve and let the intensity be shifted between the colors.
int j;
for (j = 0; j < 9; j++) {
unsigned char intensity = (unsigned char) (intensity_progression[j] * AMPLITUDE) / INTENSITY_MAX;
ga[(j + 0) % 9] = intensity;
ra[(j + 3) % 9] = intensity;
ba[(j + 6) % 9] = intensity;
}
while (1) {
int i;
// This part is not really timing sensitive,
// since we want to wait a while between every color shift.
// Shift one LED color at a time.
#define SHIFT 1
// Shift the LED colors
for (i = 8; i >= 0; i--) {
ga[i + SHIFT] = ga[i];
ra[i + SHIFT] = ra[i];
ba[i + SHIFT] = ba[i];
}
// Take care of the colors that were shifted out of the 0..8 first position
// and move them to the begining of the arrays.
for (i = 0; i < SHIFT; i++) {
ga[i] = ga[9 + i];
ra[i] = ra[9 + i];
ba[i] = ba[9 + i];
}
// Delay before updating the LED colors.
delay_ms(100);
// Send the colors to all nine LEDs.
for (j = 0; j < 9; j++) {
char g = ga[j];
char r = ra[j];
char b = ba[j];
// Send and shift the MSB bit for green.
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
SEND_AND_SHIFT_BIT(g);
// Send and shift the MSB bit for red.
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
SEND_AND_SHIFT_BIT(r);
// Send and shift the MSB bit for blue.
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
SEND_AND_SHIFT_BIT(b);
}
// Must wait at least 50 us before trying to send new color bits.
delay_ms(1);
}
while (1);
return 0;
}
int main(int argc, char *argv[])
{
// Handle SIGPIPE
struct sigaction pipeAct;
memset(&pipeAct, 0, sizeof(struct sigaction));
pipeAct.sa_handler = pipeHandler;
if (sigaction(SIGPIPE, &pipeAct, NULL) < 0) {
f**k(FUCK_HARDCORE, "sigaction error: %s\n", fuckerror());
}
init_socket();
init_pins();
while (1) {
if (acceptClient() < 0) continue; // Error on accept
// Read resolution
read(clientSock_fd, &xres, sizeof(uint32_t));
read(clientSock_fd, &yres, sizeof(uint32_t));
// Create input events
struct input_eventx ev_x; // Relative on the x axis
ev_x.type = EV_REL;
ev_x.code = REL_X;
struct input_eventx ev_y; // Relative on the y axis
ev_y.type = EV_REL;
ev_y.code = REL_Y;
struct input_eventx ev_l; // Left mouse button
ev_l.type = EV_KEY;
ev_l.code = BTN_LEFT;
struct input_eventx ev_r; // Right mouse button
ev_r.type = EV_KEY;
ev_r.code = BTN_RIGHT;
struct input_eventx ev_syn; // Sync event
ev_syn.type = EV_SYN;
ev_syn.code = SYN_REPORT;
ev_syn.value = 0;
// Set mouse to (0,0)
ev_x.value = -xres;
ev_y.value = -yres;
if (sendEvent(&ev_x) < 0 || sendEvent(&ev_y) < 0 || sendEvent(&ev_syn) < 0) continue;
int lmb_state = 0, rmb_state = 0;
int x_old = 0, y_old = 0, x = 0, y = 0, px = 0, py = 0, a, b;
int sync, tolerance = 3; // Avoids unwanted mouse jitter
while (1) {
sync = 0;
// Handle button clicks
if (digitalRead(GPIO_LMB) == HIGH && lmb_state == 0) {
ev_l.value = lmb_state = 1;
if (sendEvent(&ev_l) < 0) break;
sync = 1;
}
if (digitalRead(GPIO_LMB) == LOW && lmb_state == 1) {
ev_l.value = lmb_state = 0;
if (sendEvent(&ev_l) < 0) break;
sync = 1;
}
if (digitalRead(GPIO_RMB) == HIGH && rmb_state == 0) {
ev_r.value = rmb_state = 1;
if (sendEvent(&ev_r) < 0) break;
sync = 1;
}
if (digitalRead(GPIO_RMB) == LOW && rmb_state == 1) {
ev_r.value = rmb_state = 0;
if (sendEvent(&ev_r) < 0) break;
sync = 1;
}
// Handle mouse move
a = analogRead(MCP3008_PIN_BASE);
b = analogRead(MCP3008_PIN_BASE + 1);
if ((a - px) > tolerance || (px - a) > tolerance || a == 0 || a == ANALOG_MAX) {
px = a;
x = (int)(px * (xres - 1) / (double)ANALOG_MAX);
ev_x.value = x - x_old;
x_old = x;
if (sendEvent(&ev_x) < 0) break;
sync = 1;
}
if ((b - py) > tolerance || (py - b) > tolerance || b == 0 || b == ANALOG_MAX) {
py = b;
y = (int)(py * (yres - 1) / (double)ANALOG_MAX);
ev_y.value = y - y_old;
y_old = y;
if (sendEvent(&ev_y) < 0) break;
sync = 1;
}
// If anything sent, sync
if (sync && sendEvent(&ev_syn) < 0) break;
usleep(20000);
}
// If any of the code from the while above breaks, move to the next client
continue;
}
// Clean shit
close(clientSock_fd);
close(sock_fd);
return 0;
}
int main(void)
{
unsigned long ulPeriod;
unsigned long ulDelay;
unsigned long recvData = 11;
volatile int status = 0;
char buffer[40];
unsigned int bytesdRead;
FRESULT res;
FIL fileobj;
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
//Initialize pins
init_pins();
//Initialize peripherals
init_periph();
I2CMasterInitExpClk(I2C0_MASTER_BASE, SysCtlClockGet(), false);//false for 100kHz mode
//0x68 is the 7-bit address of the DS1307
I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x68, false);//true for a read action
I2CMasterDataPut(I2C0_MASTER_BASE, 0x10); //first Date/Time Register
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_SINGLE_SEND);
while(I2CMasterBusy(I2C0_MASTER_BASE)){}
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);
while(I2CMasterBusy(I2C0_MASTER_BASE)){}
recvData = I2CMasterDataGet(I2C0_MASTER_BASE);
while(I2CMasterBusy(I2C0_MASTER_BASE)){}
fs_mount();
if(disk_status(0) == 0)
{
status++;
}
else
{
status--;
}
if (status == 1) {
res = f_open(&fileobj, "config.txt", FA_OPEN_EXISTING | FA_READ);
res = f_read(&fileobj, buffer, 6, &bytesdRead);
}
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0);
ulPeriod = SysCtlClockGet() / 10;
ulDelay = ((ulPeriod / 2) / 3) - 4 ;
while(1)
{
// Turn on the LED
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0x01);
// Delay for a bit
SysCtlDelay(ulDelay);
// Turn off the LED
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0x00);
// Delay for a bit
SysCtlDelay(ulDelay);
}
}
// main init function executed 1 time only at boot
void setup(){
init_pins();
init_sd();
load_os_msgs_from_sd();
load_drugs_from_sd();
}
void custom_matrix_init(void) {
pca9555_init(IC1);
pca9555_init(IC2);
init_pins();
}
void uninit(){
init_pins();
unmap_registers();
}
