void TLC5940_SetGS_And_GS_PWM(void) {
uint8_t firstCycleFlag = 0;
if (outputState(VPRG_PORT, VPRG_PIN)) {
setLow(VPRG_PORT, VPRG_PIN);
firstCycleFlag = 1;
}
uint16_t GSCLK_Counter = 0;
uint8_t Data_Counter = 0;
setLow(BLANK_PORT, BLANK_PIN);
for (;;) {
if (GSCLK_Counter > 4095) {
setHigh(BLANK_PORT, BLANK_PIN);
pulse(XLAT_PORT, XLAT_PIN);
if (firstCycleFlag) {
pulse(SCLK_PORT, SCLK_PIN);
firstCycleFlag = 0;
}
break;
} else {
if (!(Data_Counter > TLC5940_N * 192 - 1)) {
if (gsData[Data_Counter])
setHigh(SIN_PORT, SIN_PIN);
else
setLow(SIN_PORT, SIN_PIN);
pulse(SCLK_PORT, SCLK_PIN);
Data_Counter++;
}
}
pulse(GSCLK_PORT, GSCLK_PIN);
GSCLK_Counter++;
}
}
void TLC5940_Init(void) {
setOutput(GSCLK_DDR, GSCLK_PIN);
setOutput(SCLK_DDR, SCLK_PIN);
setOutput(DCPRG_DDR, DCPRG_PIN);
setOutput(VPRG_DDR, VPRG_PIN);
setOutput(XLAT_DDR, XLAT_PIN);
setOutput(BLANK_DDR, BLANK_PIN);
setOutput(SIN_DDR, SIN_PIN);
setLow(GSCLK_DDR, GSCLK_PIN);
setLow(SCLK_PORT, SCLK_PIN);
setLow(DCPRG_PORT, DCPRG_PIN);
setHigh(VPRG_PORT, VPRG_PIN);
setLow(XLAT_PORT, XLAT_PIN);
setHigh(BLANK_PORT, BLANK_PIN);
// CTC with OCR0A as TOP
TCCR0A = (1 << WGM01);
// clk_io/1024 (From prescaler)
TCCR0B = ((1 << CS02) | (1 << CS00));
// Generate an interrupt every 4096 clock cycles
OCR0A = 3;
// Enable Timer/Counter0 Compare Match A interrupt
TIMSK0 |= (1 << OCIE0A);
}
int PS2Emu::devRead(unsigned char *ret) {
unsigned char data = 0x00;
unsigned char p = 0x01;
// wait for the host to release the clock
while (digitalRead(dat) == HIGH);
while (digitalRead(clk) == LOW);
// read start bit
delayMicroseconds(cell/2);
setLow(clk);
delayMicroseconds(cell);
setHigh(clk);
delayMicroseconds(cell/2);
// read data bits
for (int i=0; i<8; i++) {
if (digitalRead(dat) == HIGH) {
data = data | (1 << i);
p = p ^ 1;
}
delayMicroseconds(cell/2);
setLow(clk);
delayMicroseconds(cell);
setHigh(clk);
delayMicroseconds(cell/2);
}
// read parity bit
if (digitalRead(dat) != p) {
return PARITY;
}
delayMicroseconds(cell/2);
setLow(clk);
delayMicroseconds(cell);
setHigh(clk);
delayMicroseconds(cell/2);
// send 'ack' bit
setLow(dat);
delayMicroseconds(cell/2);
setLow(clk);
delayMicroseconds(cell);
setHigh(clk);
setHigh(dat);
// the Arduino has large pull-up resistors so give the data line
// some time to release
delayMicroseconds(100);
*ret = data;
return SUCCESS;
}
void loop(void)
{
setHigh(LED);
delayMs(500);
setLow(LED);
delayMs(500);
}
void TLC5940_Init(void) {
setOutput(GSCLK_DDR, GSCLK_PIN);
setOutput(SCLK_DDR, SCLK_PIN);
setOutput(DCPRG_DDR, DCPRG_PIN);
setOutput(VPRG_DDR, VPRG_PIN);
setOutput(XLAT_DDR, XLAT_PIN);
setOutput(BLANK_DDR, BLANK_PIN);
setOutput(SIN_DDR, SIN_PIN);
setLow(GSCLK_PORT, GSCLK_PIN);
setLow(SCLK_PORT, SCLK_PIN);
setLow(DCPRG_PORT, DCPRG_PIN);
setHigh(VPRG_PORT, VPRG_PIN);
setLow(XLAT_PORT, XLAT_PIN);
setHigh(BLANK_PORT, BLANK_PIN);
}
btSIter *btSetFullRangeIter(btSIter *iter, bt *btr, bool asc, cswc_t *w) {
cswc_t W; // used in setHigh()
if (!btr->root || !btr->numkeys) return NULL;
if (!w) w = &W;
ai_obj *aL = &w->wf.alow, *aH = &w->wf.ahigh;
if (!assignMinKey(btr, aL) || !assignMaxKey(btr, aH)) return NULL;
btk_t btk;
bool med;
uint32 ksize;
SETITER8R(iter, btr, asc, iter_leaf, iter_leaf_rev, iter_node, iter_node_rev);
siter->scan = 1;
setHigh(siter, asc ? aH : aL, btr->s.ktype);
char *bkey = createBTKey(asc ? aL : aH,
&med, &ksize, btr, &btk); //DEST 030
if (!bkey) goto frangeiter_err;
bt_n *x = NULL;
int i = -1;
uchar *stream = setIter(btr, bkey, siter, asc ? aL : aH, &x, &i, asc);
destroyBTKey(bkey, med); /* DESTROYED 030 */
if (!stream && siter->missed) return siter;//IILMISS
if (!streamToBTEntry(stream, siter, x, i)) goto frangeiter_err;
if (btr->dirty_left) siter->missed = 1; // FULL means 100% FULL
return siter;
frangeiter_err:
btReleaseRangeIterator(siter);
return NULL;
}
/** Main program entry point. This routine configures the hardware required by the application, then
* enters a loop to run the application tasks in sequence.
*/
int main(void)
{
SetupHardware();
setOut(LED_PIN);
puts_P(PSTR( "Still Image Host Demo running.\r\n" ));
// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
sei();
uint32_t count = 0;
for (;;)
{
Camera_Task();
USB_USBTask();
if(count++ >= 1000)
{
count = 0;
if(isOut(LED_PIN) && !isHigh(LED_PIN))
{
setHigh(LED_PIN);
}
else
{
setLow(LED_PIN);
}
}
}
}
btSIter *btGetXthIter(bt *btr, ai_obj *alow, ai_obj *ahigh, long oofst, bool asc) {
ulong ofst = (ulong)oofst; //DEBUG_GET_XTH_ITER
if (!btr->root || !btr->numkeys) return NULL;
CR8ITER8R(btr, asc, iter_leaf, iter_leaf_rev, iter_node, iter_node_rev);
setHigh(siter, asc ? ahigh : alow, btr->s.ktype);
if (XthIterFind(siter, alow, ahigh, ofst, asc, btr)) siter->empty = 0;
return siter;
}
NESNumber& NESNumber::operator *= (float k) {
float result = this->toFloat() * k;
NESNumber shadow = NESNumber::fromFloat(result);
setHigh(shadow.getHigh());
setLow(shadow.getLow());
return *this;
}
// Set direction for Right Motor 0 forward, 1 backward
void setDirectionMotorR(uint8_t dir){
if(dir){
setLow(PORTD, BRIDGE_A4);
TCCR1A &= ~(1 << 4);
}else{
setHigh(PORTD, BRIDGE_A4);
TCCR1A |= 1 << 4;
}
}
int PS2Emu::hostWrite(unsigned char data) {
unsigned char p = 0x01;
// inhibit device transmission
setLow(clk);
delayMicroseconds(100);
// send request to communicate with device
setLow(dat);
//delayMicroseconds(cell/2); // could be wrong
setHigh(clk);
// send data
for (int i=0; i<8 ; i++) {
while (digitalRead(clk) == HIGH);
if (data & (1 << i)) {
setHigh(dat);
p = p ^ 1;
} else {
setLow(dat);
}
while (digitalRead(clk) == LOW);
}
// send parity bit
while (digitalRead(clk) == HIGH);
if (p) {
setHigh(dat);
} else {
setLow(dat);
}
while (digitalRead(clk) == LOW);
// send stop bit
while (digitalRead(clk) == HIGH);
setHigh(dat);
while (digitalRead(clk) == LOW);
// eat the 'ack' bit
while (digitalRead(clk) == HIGH);
while (digitalRead(clk) == LOW);
return SUCCESS;
}
void TLC5940_ClockInDC(void) {
setHigh(DCPRG_PORT, DCPRG_PIN);
setHigh(VPRG_PORT, VPRG_PIN);
uint8_t Counter = 0;
for (;;) {
if (Counter > TLC5940_N * 96 - 1) {
pulse(XLAT_PORT, XLAT_PIN);
break;
} else {
if (dcData[Counter])
setHigh(SIN_PORT, SIN_PIN);
else
setLow(SIN_PORT, SIN_PIN);
pulse(SCLK_PORT, SCLK_PIN);
Counter++;
}
}
}
char battery_status()
{
char stat = 0;
setIn(CHARGE_STATUS_PIN);
setHigh(CHARGE_STATUS_PIN);
_delay_ms(10);
if(!getPin(CHARGE_STATUS_PIN)) stat = 1;
setLow(CHARGE_STATUS_PIN);
_delay_ms(10);
if(getPin(CHARGE_STATUS_PIN)) stat = 2;
return stat;
}
btSIter *btGetFullXthIter(bt *btr, long oofst, bool asc, cswc_t *w, long lim) {
ulong ofst = (ulong)oofst;
cswc_t W; // used in setHigh()
if (!btr->root || !btr->numkeys) return NULL;
if (!w) w = &W;
ai_obj *aL = &w->wf.alow, *aH = &w->wf.ahigh;
if (!assignMinKey(btr, aL) || !assignMaxKey(btr, aH)) return NULL;
CR8ITER8R(btr, asc, iter_leaf, iter_leaf_rev, iter_node, iter_node_rev);
setHigh(siter, asc ? aH : aL, btr->s.ktype);
if (btScionFind(siter, btr->root, ofst, btr, asc, w, lim)) siter->empty = 0;
return siter;
}
GPIO::GPIO(LPC1758_GPIO_Type gpioId) :
mPortNum(gpioId >> __PNSB),
mPinNum(gpioId & (0xFF >> (8 - __PNSB))) // Should result in (gpioId & 0x1F) if __PNSB is value of 5
{
uint32_t gpioMemBases[] = { LPC_GPIO0_BASE, LPC_GPIO1_BASE, LPC_GPIO2_BASE, LPC_GPIO3_BASE, LPC_GPIO4_BASE};
mpOurGpio = (LPC_GPIO_TypeDef*) gpioMemBases[mPortNum];
// Select GPIO configuration
volatile uint32_t *pinsel = &(LPC_PINCON->PINSEL0);
pinsel += (2 * mPortNum);
*pinsel &= ~(3 << (2*mPinNum));
}
/** @{ Simple functions*/
void GPIO::setAsInput(void) { mpOurGpio->FIODIR &= ~(1 << mPinNum); }
void GPIO::setAsOutput(void) { mpOurGpio->FIODIR |= (1 << mPinNum); }
bool GPIO::read(void) const { return !!(mpOurGpio->FIOPIN & (1 << mPinNum)); }
void GPIO::setHigh(void) { mpOurGpio->FIOSET = (1 << mPinNum); }
void GPIO::setLow(void) { mpOurGpio->FIOCLR = (1 << mPinNum); }
void GPIO::set(bool on) { (on) ? setHigh() : setLow(); }
/** @} */
void GPIO::enablePullUp()
{
volatile uint32_t *pinmode = &(LPC_PINCON->PINMODE0);
pinmode += (2 * mPortNum);
*pinmode &= ~(3 << (2*mPinNum));
}
void GPIO::enablePullDown()
{
volatile uint32_t *pinmode = &(LPC_PINCON->PINMODE0);
pinmode += (2 * mPortNum);
*pinmode |= (3 << (2*mPinNum));
}
void GPIO::disablePullUpPullDown()
{
volatile uint32_t *pinmode = &(LPC_PINCON->PINMODE0);
pinmode += (2 * mPortNum);
*pinmode &= ~(3 << (2*mPinNum));
*pinmode |= (2 << (2*mPinNum));
}
void GPIO::enableOpenDrainMode(bool openDrain)
{
volatile uint32_t *pinmode_od = &(LPC_PINCON->PINMODE_OD0);
pinmode_od += mPortNum;
if(openDrain) {
*pinmode_od |= (1 << mPinNum);
}
else {
*pinmode_od &= ~(1 << mPinNum);
}
}
char hardware_flashlight(char on)
{
setOut(LED_PIN);
if(on)
{
setLow(LED_PIN);
return 1;
}
setHigh(LED_PIN);
return 0;
}
int main(void) {
TLC5940_Init();
TLC5940_ClockInDC();
setHigh(DDRC,PC3);
setHigh(PORTC,PC3);
// Enable Gndefined reference to `_delay_ms'lobal Interrupts
sei();
for (;;) {
gsData[12*15]=1;
_delay_ms(1000);
gsData[12*12]=1;
_delay_ms(1000);
gsData[12*15]=0;
_delay_ms(1000);
gsData[12*12]=0;
_delay_ms(1000);
// gsData[12*14]=1;
// _delay_ms(1000);
// gsData[12*11]=1;
// _delay_ms(1000);
// gsData[12*14]=0;
// _delay_ms(1000);
// gsData[12*11]=0;
// _delay_ms(1000);
// gsData[12*13]=1;
// _delay_ms(1000);
// gsData[12*10]=1;
// _delay_ms(1000);
// gsData[12*13]=0;
// _delay_ms(1000);
// gsData[12*10]=0;
// _delay_ms(1000);
}
return 0;
}
void hardware_init(void)
{
setOut(POWER_HOLD_PIN); // Hold PWR on
setLow(POWER_HOLD_PIN);
#ifdef POWER_AUX_PIN
setOut(POWER_AUX_PIN); // Hold AUX PWR on
setLow(POWER_AUX_PIN);
#endif
#ifdef USB_ENABLE_PIN
setOut(USB_ENABLE_PIN); // Hold AUX PWR on
setLow(USB_ENABLE_PIN);
#endif
setOut(LED_PIN); // Red Flashlight
setHigh(LED_PIN); // off
setOut(IR_PIN); // IR Transmitter
setHigh(IR_PIN); // off
hardware_USB_Enable();
hardware_USB_SetDeviceMode();
}
bool HSV::load() {
std::ifstream infile;
char data[100];
infile.open(DIRECTORY + name + FILE_EXTENSION);
if (infile.is_open()) {
infile >> data;
infile.close();
std::string content(data);
std::vector<std::string> v = splitString(content, ';');
setLow(std::stoi(v[0]), std::stoi(v[1]), std::stoi(v[2]));
setHigh(std::stoi(v[3]), std::stoi(v[4]), std::stoi(v[5]));
return true;
} else {
void
TPinOpenDrain<WatchDog_T, Port_T, Bit_T>::powerUp(void)
{
// GPIOx Peripheral clock enable. Multiple calls are not harmful.
RCC_APB2PeriphClockCmd((RCC_APB2Periph_GPIOA << GPIO_PortNo), ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
// Configure pin in output push/pull mode
GPIO_InitStructure.GPIO_Pin = GPIO_BitMask;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
GPIO_Init(GPIO_Address, &GPIO_InitStructure);
// start pin as high
setHigh();
}
void IR::high38(unsigned int time)
{
uint16_t count = 0;
cli();
while (count <= time / (1000 / 38))
{
setLow(IR_PIN);
_delay_us((1000 / 38 / 2));
setHigh(IR_PIN);
_delay_us((1000 / 38 / 2));
count++;
}
sei();
}
bool IoGPIO::save(Image & image, JSON & data)
{
// ------------------------
// Trigger the GPIO pin
for(int i = 0; i < m_periods; i++)
{
// ---------------------------
// Put pin high for some time
setHigh();
usleep(m_periodTime);
setLow();
usleep(m_periodTime);
}
return true;
}
void PlotLine::copy (PlotLine *d)
{
d->getColor(color);
setType(d->getType());
d->getLabel(label);
setScaleFlag(d->getScaleFlag());
setColorFlag(d->getColorFlag());
d->getData(data);
d->getDateList(dateList);
setHigh(d->getHigh());
setLow(d->getLow());
}
void hardware_off(void)
{
if(battery_status() == 0)
{
// If USB is used, detach from the bus
USB_Detach();
// Disable all interrupts
cli();
// Shutdown
setHigh(POWER_HOLD_PIN);
for(;;);
}
else // Plugged in
{
// Charging screen //
chargingScreen();
}
}
btSIter *btSetRangeIter(btSIter * iter, bt *btr, ai_obj *alow, ai_obj *ahigh, bool asc) {
if (!btr->root || !btr->numkeys) return NULL;
btk_t btk;
bool med;
uint32 ksize; //bt_dumptree(btr, btr->ktype);
SETITER8R(iter, btr, asc, iter_leaf, iter_leaf_rev, iter_node, iter_node_rev);
setHigh(siter, asc ? ahigh : alow, btr->s.ktype);
char *bkey = createBTKey(asc ? alow : ahigh,
&med, &ksize, btr, &btk); //D032
if (!bkey) goto rangeiter_err;
bt_n *x = NULL;
int i = -1;
uchar *stream = setIter(btr, bkey, siter, asc ? alow : ahigh, &x, &i, asc);
destroyBTKey(bkey, med); /* DESTROYED 032 */
if (!streamToBTEntry(stream, siter, x, i)) goto rangeiter_err;
return siter;
rangeiter_err:
btReleaseRangeIterator(siter);
return NULL;
}
void hardware_off(void)
{
hardware_flashlight(0);
if(battery_status() == 0)
{
//if(timer.cableIsConnected())
//{
// menu.message(STR("Error: Cable"));
//}
//else
//{
shutter_off();
// Save the current time-lapse settings to nv-mem
timer.saveCurrent();
// If USB is used, detach from the bus
USB_Detach();
// Shutdown bluetooth
bt.disconnect();
bt.sleep();
// Disable all interrupts
cli();
// Shutdown
setHigh(POWER_HOLD_PIN);
FOREVER;
//}
}
else // Plugged in
{
// Charging screen //
clock.sleeping = 1;
menu.spawn((void *) batteryStatus);
}
}
bool IoGPIO::save(Image & image, JSON & data)
{
if(throttle.canExecute())
{
// ------------------------
// Trigger the GPIO pin
LINFO << "IoGPIO: triggering GPIO pin " + helper::to_string(m_pin);
for(int i = 0; i < m_periods; i++)
{
// ---------------------------
// Put pin high for some time
setHigh();
usleep(m_periodTime);
setLow();
usleep(m_periodTime);
}
}
return true;
}
void lcdInit(const unsigned short int* param)
{
rs = *param;
param++;
rw = *param;
param++;
en = *param;
param++;
pwr = *param;
param++;
ioStart = *param;
pinMode(rs, OUTPUT);
pinMode(rw, OUTPUT);
pinMode(en, OUTPUT);
pinMode(pwr, OUTPUT);
pinMode(ioStart, OUTPUT);
pinMode(ioStart + 1, OUTPUT);
pinMode(ioStart + 2, OUTPUT);
pinMode(ioStart + 3, OUTPUT);
setHigh(pwr);
}
int main() {
uchar i;
setHigh(DDRB, PORTB0); // make PB0 output port
setHigh(PORTB, PORTB0); // indicate that the micro-controller is active
// motor frequency timer
TCCR1B |= 1 << CS12;
// motor output pins
setHigh(DDRD,PORTD4);
setHigh(DDRD,PORTD5);
setHigh(DDRD,PORTD6);
setHigh(DDRD,PORTD7);
wdt_enable(WDTO_1S); // enable 1s watchdog timer
usbInit();
usbDeviceDisconnect(); // enforce re-enumeration
for(i = 0; i<250; i++) { // wait 500 ms
wdt_reset(); // keep the watchdog happy
_delay_ms(2);
}
usbDeviceConnect();
sei(); // Enable interrupts after re-enumeration
initMotor();
while(1) {
wdt_reset(); // keep the watchdog happy
usbPoll();
/*motor functions*/
motor();
}
return 0;
}
NESNumber::NESNumber(const double& value) {
NESNumber converted = NESNumber::fromDouble(value);
setHigh(converted.getHigh());
setLow(converted.getLow());
}