void set_number(const struct pin_t *pins, uint8_t number)
{
set_pin(&pins[0], number & 0x1);
set_pin(&pins[1], number & 0x2);
set_pin(&pins[2], number & 0x4);
set_pin(&pins[3], number & 0x8);
}
uint16_t usr_measure(void)
{
static bool led = true;
volatile uint32_t result;
//enable USR
set_pin(USR_EN_PIN);
if (led)
{
set_pin(BRD_LED_PIN);
led = false;
}
else
{
clear_pin(BRD_LED_PIN);
led = true;
}
//delay 20us
nrf_delay_us(20);
NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled;
NRF_ADC->EVENTS_END = 0;
NRF_ADC->TASKS_START = 1;
while (NRF_ADC->EVENTS_END == 0);
//unenable USR
clear_pin(USR_EN_PIN);
result = NRF_ADC->RESULT;
NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled;
return result;
}
int ping_ultrasonic(int echo, int trig, int max_distance) //max_distance in cm
{//ping HC-SR04 ultrasonic range finder, 10us trigger pulse, sends eight 40kHz pulses
//int start_time;
int max_time; //max_time in system cycles
int flight_time;
//char message[100];
//sprintf(message, "bump");
//NU32_WriteUART1(message);
max_time = max_distance * 2320; //Distance(cm) = Time(us)/58, 40 core cycles per us, 58*40=2320
//start_time = ReadCoreTimer();
WriteCoreTimer(0);
set_pin(trig, HIGH);
while(ReadCoreTimer() < 1600){ //400 cycles at 40MHz, 10us trigger pulse
}
set_pin(trig, LOW);
//NU32_WriteUART1(message);
while(!get_pin(echo)){
}
//NU32_WriteUART1(message);
//start_time = ReadCoreTimer();
WriteCoreTimer(0);
while(get_pin(echo) && (ReadCoreTimer() < max_time)){
}
//flight_time = ReadCoreTimer() - start_time;
flight_time = ReadCoreTimer();
//sprintf(message, "%d\n", flight_time);
//NU32_WriteUART1(message);
return flight_time / 2320;
}
void LiquidCrystal::begin()
{
configure_as_output(rs_pin);
configure_as_output(enable_pin);
configure_as_output(rw_pin);
for(int i = 0; i < 4; i++)
configure_as_output(data_pins[i]);
set_pin(rs_pin, LOW);
set_pin(enable_pin, LOW);
set_pin(rw_pin, LOW);
write_bits(0x03);
etk::sleep_us(4500);
write_bits(0x03);
etk::sleep_us(500);
write_bits(0x03);
etk::sleep_us(250);
write_bits(0x02);
etk::sleep_ms(2);
write_bits(0x02);
etk::sleep_us(150);
write_bits(LCD_2LINE);
etk::sleep_us(150);
command(LCD_DISPLAYCONTROL);
clear();
command(LCD_ENTRYMODESET | LCD_ENTRYLEFT);
display();
}
void LiquidCrystal::pulse()
{
etk::sleep_us(1);
set_pin(enable_pin, HIGH);
etk::sleep_us(1);
set_pin(enable_pin, LOW);
etk::sleep_us(100);
}
void init_am27c(void) {
init_am27c_ports();
set_pin(P_PGM, PGM, 1);
set_pin(P_CE, CE, 0);
set_pin(P_OE, OE, 1);
am27c_set_addr(0x0000);
}
int main(void)
{
clock_setup();
spi2.begin();
configure_as_output({PB, 0});
set_pin({PB, 0}, true);
etk::sleep_ms(300);
//configure chip select pin
auto cs = gpio_pin(PA, 8);
configure_as_output(cs);
set_pin(cs, true);
//start LCD screen
lcd.begin();
etk::sleep_ms(500);
while(true)
{
lcd.set_cursor(0, 0);
lcd.print("Temp: ");
set_pin(cs, false);
union spidata
{
char bytes[4];
int32 data;
};
spidata data;
data.bytes[3] = spi2.read();
data.bytes[2] = spi2.read();
data.bytes[1] = spi2.read();
data.bytes[0] = spi2.read();
set_pin(cs, true);
lcd.set_cursor(2, 6);
int32 v = data.data;
if (v & 0x80000000)
v = 0xFFFFC000 | ((v >> 18) & 0x00003FFFF);
else
v >>= 18;
real_t deg_c = v;
deg_c *= 0.25;
lcd.print(deg_c, " C");
etk::sleep_ms(500);
}
void ht1632_write(uns8 mem_addr, uns8 data) {
uns8 count;
clear_pin(ht1632_cs1_port, ht1632_cs1_pin);
// send WR command
// send 1
set_pin (ht1632_data_port, ht1632_data_pin);
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// send 0
clear_pin (ht1632_data_port, ht1632_data_pin);
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// send 1
set_pin (ht1632_data_port, ht1632_data_pin);
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// write mem addr, bits 6 -> 0
for(count = 0 ; count < 7 ; count++) {
if (test_bit(mem_addr, 6)) {
set_pin(ht1632_data_port, ht1632_data_pin);
} else {
clear_pin(ht1632_data_port, ht1632_data_pin);
}
//change_pin_var(ht1632_data_port, ht1632_data_pin, test_bit(mem_addr, 6));
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// shift mem addr along
mem_addr = mem_addr << 1;
}
// write data, bits 0 -> 3 (different from mem addr format)
for(count = 0 ; count < 4 ; count++) {
change_pin_var(ht1632_data_port, ht1632_data_pin, test_bit(data, 0));
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// shift mem addr along
data = data >> 1;
}
// reset CS
// set_pin(ht1632_cs1_port, ht1632_cs1_pin);
// delay_ms(1);
// clear_pin(ht1632_cs1_port, ht1632_cs1_pin);
set_pin(ht1632_cs1_port, ht1632_cs1_pin);
}
void ht1632_fill2(uns8 colour) {
uns16 count;
ht1632_send_command(HT1632_CMD_LEDS_OFF);
clear_pin(ht1632_cs1_port, ht1632_cs1_pin);
// send WR command
// send 1
set_pin (ht1632_data_port, ht1632_data_pin);
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// send 0
clear_pin (ht1632_data_port, ht1632_data_pin);
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// send 1
set_pin (ht1632_data_port, ht1632_data_pin);
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// send mem address of zero
clear_pin(ht1632_data_port, ht1632_data_pin);
// write mem addr, bits 6 -> 0
for(count = 0 ; count < 7 ; count++) {
//change_pin_var(ht1632_data_port, ht1632_data_pin, test_bit(mem_addr, 6));
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// shift mem addr along
}
if (colour) {
set_pin(ht1632_data_port, ht1632_data_pin);
} else {
clear_pin(ht1632_data_port, ht1632_data_pin);
}
// we need to toggle 384 times
for(count = 0 ; count < 384 ; count++) {
// pulse wr
clear_pin(ht1632_wr_port, ht1632_wr_pin);
set_pin (ht1632_wr_port, ht1632_wr_pin);
// shift mem addr along
}
// reset CS
set_pin(ht1632_cs1_port, ht1632_cs1_pin);
ht1632_send_command(HT1632_CMD_LEDS_ON);
}
unsigned char am27c_get_data(unsigned short addr) {
unsigned char data = 0x00;
am27c_set_addr(addr);
delay_us(1);
set_pin(P_OE, OE, 0);
delay_us(1);
data = read_data();
set_pin(P_OE, OE, 1);
return data;
}
/*
* For mgcoge3ne boards, the mgcoge3un control is controlled from
* a GPIO line on the PPC CPU. If bobcatreset is set the line
* will toggle once what forces the mgocge3un part to restart
* immediately.
*/
static void handle_mgcoge3un_reset(void)
{
char *bobcatreset = getenv("bobcatreset");
if (bobcatreset) {
if (strcmp(bobcatreset, "true") == 0) {
puts("Forcing bobcat reset\n");
set_pin(0, 0x00000004, 3); /* clear PD29 (reset arm) */
udelay(1000);
set_pin(1, 0x00000004, 3);
} else
set_pin(1, 0x00000004, 3); /* don't reset arm */
}
}
void sure_2416_setup() {
//serial_print_str("Setting up 2416\n");
make_output(sure_2416_cs1_port, sure_2416_cs1_pin);
make_output(sure_2416_data_port, sure_2416_data_pin);
make_output(sure_2416_wr_port, sure_2416_wr_pin);
make_output(sure_2416_rd_port, sure_2416_rd_pin);
set_pin(sure_2416_wr_port, sure_2416_wr_pin);
set_pin(sure_2416_rd_port, sure_2416_rd_pin);
set_pin(sure_2416_cs1_port, sure_2416_cs1_pin);
}
void HardwareSerial::end() {
//set the pins to read (high Z)
if(port==0) {
set_pin(0,0); //TX0->GPIO
set_pin(1,0); //RX0->GPIO
gpio_set_read(0);
gpio_set_read(1);
} else {
set_pin(8,0); //TX1->GPIO
set_pin(9,0); //RX1->GPIO
gpio_set_read(8);
gpio_set_read(9);
}
}
void mrf24j40_setup_io() {
#ifndef __PIC32MX__
make_input(mrf24j40_int_port, mrf24j40_int_pin);
set_pin(mrf24j40_cs_port, mrf24j40_cs_pin); // keep high
make_output(mrf24j40_cs_port, mrf24j40_cs_pin);
#endif
#ifdef __PIC32MX__
SPI_init(); // init SPI default (2 on PIC32-PINGUINO)
// only called here for test
// will be called later in main32.c
#ifndef PIC32_PINGUINO_220
//pinmode(13,OUTPUT); // CLK
//pinmode(11,OUTPUT); // SDO
//pinmode(12,INPUT); // SDI
ZIGRESETOUT; // macro for RESET
ZIGCSOUT; // macro for CS
ZIGINTIN; // interrupt (not yet implemented)
#else
ZIGRESETOUT; // macro for RESET
ZIGCSOUT; // macro for CS
#endif
ZIGRESET=0;
ZIGCS=1;
ZIGRESET=1;
Delayms(100);
#endif
}
uns8 mrf24j40_long_addr_read(uns16 addr){
uns8 result;
#ifndef __PIC32MX__
clear_pin(mrf24j40_cs_port, mrf24j40_cs_pin);
addr = addr & 0b0000001111111111; // <9:0> bits
addr = addr << 5;
set_bit(addr, 15); // long addresss
spi_hw_transmit(addr >> 8);
spi_hw_transmit(addr & 0x00ff);
result = spi_hw_receive();
set_pin(mrf24j40_cs_port, mrf24j40_cs_pin);
#endif
#ifdef __PIC32MX__
ZIGCS=0;
addr=((addr<<1)&0x7FE)|0x800;
addr<<=4;
SPI_write(addr>>8);
SPI_write(addr);
result=SPI_read();
ZIGCS=1;
#endif
return result;
}
void mrf24j40_long_addr_write(uns16 addr, uns8 data){
#ifndef __PIC32MX__
clear_pin(mrf24j40_cs_port, mrf24j40_cs_pin);
addr = addr & 0b0000001111111111; // <9:0> bits
addr = addr << 5;
set_bit(addr, 15); // long addresss
set_bit(addr, 4); // set for write
spi_hw_transmit(addr >> 8 );
spi_hw_transmit(addr & 0x00ff);
spi_hw_transmit(data);
set_pin(mrf24j40_cs_port, mrf24j40_cs_pin);
#endif
#ifdef __PIC32MX__
ZIGCS=0;
addr=((addr<<1)&0x7FF)|0x801;
addr<<=4;
SPI_write(addr>>8);
SPI_write(addr);
SPI_write(data);
ZIGCS=1;
#endif
}
bool switchOnVibration(uint8_t time)
{
set_pin(VIBRATING_MOTOR_PIN);
vibratingTime = time * 10;
startingTime = vabrationCnt;
return 0;
}
void LiquidCrystal::send(uint8 cmd, bool mode)
{
set_pin(rs_pin, mode);
etk::Bits<uint8> b(cmd);
for (int i = 4; i < 8; i++)
set_pin(data_pins[i-4], b.read_bit(i));
pulse();
for (int i = 0; i < 4; i++)
set_pin(data_pins[i], b.read_bit(i));
pulse();
busy_wait();
}
int main(int argc, char *argv[])
{
int pin;
if(argc < 2)
{
printf("USAGE: setlp0pin pin#\n");
exit(1);
}
pin = atoi(argv[1]);
if (pin_init_user(LPT1) < 0)
exit(0);
pin_output_mode(LP_DATA_PINS | LP_SWITCHABLE_PINS);
if(pin < 0) // clear requested
{
pin = pin * -1;
clear_pin(LP_PIN[pin]);
printf("pin# %d cleared\n", pin);
}
else
{
set_pin(LP_PIN[pin]);
printf("pin# %d set. Run \"setlp0pin -%d\" to clear pin# %d\n", pin, pin, pin);
}
return 0;
}
void rf01_init(void)
{
unsigned char i;
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
/* Configure PD12, PD13, PD14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = SDI | SCK| CS;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SDO;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
//GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOB, &GPIO_InitStructure);
set_pin(GPIOB,CS);
for (i=0; i<11; i++)
/*** !!!!!!!!!!!!!!!!!!!!!!!!! DELAY ******************/
delay_ms(10); // wait until POR done
rf01_trans(0xC2E0); // AVR CLK: 10MHz
rf01_trans(0xC42B); // Data Filter: internal
rf01_trans(0xCE88); // FIFO mode
rf01_trans(0xC6F7); // AFC settings: autotuning: -10kHz...+7,5kHz
rf01_trans(0xE000); // disable wakeuptimer
rf01_trans(0xCC00); // disable low duty cycle
/* Configure PD12, PD13, PD14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
#if RF01_UseIRQ == 1
// jeœli obs³uga na przerwaniach
RF01_status.Rx = 0;
RF01_status.New = 0;
RFM01Irq_Init();
#endif
blinkLED();
}
void set_event(uint8_t event_number)
{
uint8_t which_pin = events[event_number].pin;
actual_events[which_pin] = event_number;
switch(which_pin)
{
case EXP0_PC2:
case EXP1_PD4:
case EXP2_PD7:
case EXP3_PB0:
set_pin(which_pin, events[event_number].pin_state);
break;
case PWM0_PD6:
case PWM1_PD5:
// not implemented yet case PWM2_PB1:
// not implemented yet case PWM3_PD3:
run_pwm(which_pin, &events[event_number]);
break;
default:break;
}
int32_t time = current_time();
// event_time
char formatted_date[30];
timeToString(time, formatted_date);
send_string(formatted_date);
send_string(" ");
print_event(event_number);
}
void LiquidCrystal::write_bits(uint8 value)
{
etk::Bits<uint8> b(value);
for (int i = 0; i < 4; i++)
set_pin(data_pins[i], b.read_bit(i));
pulse();
}
int set_abstract_pin_PWM_normalized(uint8_t pin, float normPwm)
{
if (normPwm < 0.0 || normPwm > 1.0)
return 0; //invalid pwm value!
if (pin < 0 || pin > MAX_PINS)
return 0;
set_PWM_values(pin, normPwm);
if (normPwm == 0.0)
set_pin(teensyPin[pin].port, teensyPin[pin].pin, 0);
else if (normPwm == 1.0)
set_pin(teensyPin[pin].port, teensyPin[pin].pin, 1);
return 1;
}
void sure_2416_send_command(uns8 command) {
uns8 count;
clear_pin(sure_2416_cs1_port, sure_2416_cs1_pin);
// send command
// send 1
set_pin (sure_2416_data_port, sure_2416_data_pin);
// pulse wr
clear_pin(sure_2416_wr_port, sure_2416_wr_pin);
set_pin (sure_2416_wr_port, sure_2416_wr_pin);
// send 0
clear_pin (sure_2416_data_port, sure_2416_data_pin);
// pulse wr
clear_pin(sure_2416_wr_port, sure_2416_wr_pin);
set_pin (sure_2416_wr_port, sure_2416_wr_pin);
// send 0
clear_pin (sure_2416_data_port, sure_2416_data_pin);
// pulse wr
clear_pin(sure_2416_wr_port, sure_2416_wr_pin);
set_pin (sure_2416_wr_port, sure_2416_wr_pin);
// command bits 7 - 0
for(count = 0 ; count < 8 ; count++) {
if (test_bit(command, 7)) {
set_pin(sure_2416_data_port, sure_2416_data_pin);
} else {
clear_pin(sure_2416_data_port, sure_2416_data_pin);
}
//change_pin_var(sure_2416_data_port, sure_2416_data_pin, test_bit(command, 7));
// pulse wr
clear_pin(sure_2416_wr_port, sure_2416_wr_pin);
set_pin (sure_2416_wr_port, sure_2416_wr_pin);
// shift mem addr along
command = command << 1;
}
// the don't care pulse
clear_pin(sure_2416_wr_port, sure_2416_wr_pin);
set_pin (sure_2416_wr_port, sure_2416_wr_pin);
// reset CS??
// don't think we need this
// set_pin(sure_2416_cs1_port, sure_2416_cs1_pin);
// delay_ms(1);
// clear_pin(sure_2416_cs1_port, sure_2416_cs1_pin);
set_pin(sure_2416_cs1_port, sure_2416_cs1_pin);
}
void sendSync()
{
set_pin(DATA_PIN);
sleeptime.tv_nsec = SLOT_TIME_X1;
nanosleep(&sleeptime,NULL);
clr_pin(DATA_PIN);
sleeptime.tv_nsec = SLOT_TIME_X31;
nanosleep(&sleeptime,NULL);
}
void pin_inv_old(uint32_t num)
{
uint32_t i;
uint32_t pin_act;
pin_act = (~gpio0->read) & DMX_PIN;
set_pin(pin_act, DMX_PIN);
for(i=0;i<num;i++)
sleept1();
}
int set_abstract_pin_PWM(uint8_t pin, uint8_t pwmPercent)
{
if (pwmPercent < 0 || pwmPercent > 100)
return 0; //invalid percentage yo!
teensyPin[pin].pwmPercent = pwmPercent;
float pwmDec;
pwmDec = (float)pwmPercent / 100;
set_PWM_values(pin, pwmDec);
if (pwmPercent == 0)
set_pin(teensyPin[pin].port, teensyPin[pin].pin, 0);
else if (pwmPercent == 100)
set_pin(teensyPin[pin].port, teensyPin[pin].pin, 1);
return 1;
}
void init_ultrasonic(int echo, int trig)
{
set_pin_mode(echo, IN);
set_pin_mode(trig, OUT);
set_pin(trig, LOW);
//TRISEbits.TRISE8 = 1; // ECHO to A2, NU32 input pin
//TRISEbits.TRISE9 = 0; // TRIG to A3, NU32 output pin
//LATEbits.LATE9 = 0; // start off
}
/** Send _buff to SIPO */
void _send_buffer()
{
for (int8_t i = SPWM_CHANNELS - 1; i >= 0; i--)
{
#if (SPWM_INVERT)
set_pin(SPWM_DATA, !_buff[i]); /* Common anode */
#else
set_pin(SPWM_DATA, _buff[i]); /* Common cathode */
#endif
// send a CLK pulse
pin_high(SPWM_CLK);
pin_low(SPWM_CLK);
}
// send a STR pulse
pin_high(SPWM_STR);
pin_low(SPWM_STR);
}
void LiquidCrystal::busy_wait()
{
bool busy = true;
configure_as_input(data_pins[3]);
set_pin(rs_pin, LOW);
set_pin(rw_pin, HIGH);
while(busy)
{
set_pin(enable_pin, HIGH);
etk::sleep_us(1);
busy = read_pin(data_pins[3]);
set_pin(enable_pin, LOW);
}
set_pin(rw_pin, LOW);
configure_as_output(data_pins[3]);
}
