/* DO NOT CHANGE ANYTHING IN THE FUNCTION BELOW!!!
*
* It was specially crafted to work with an 8Mhz Atmega328/168 (int. resonator).
*
* */
static inline void GCPad_send(byte *cmd, byte length) {
byte bit = 128;
byte high;
pinModeFast(JOY_DATA_PIN, OUTPUT);
loop:
high = *cmd & bit;
digitalWriteFast(JOY_DATA_PIN, LOW);
if(high) {
digitalWriteFast(JOY_DATA_PIN, HIGH);
bit >>= 1;
if(bit < 1) {
bit = 128;
cmd++;
length--;
} else {
asm volatile ("nop\nnop\nnop\nnop\nnop\n");
}
asm volatile ("nop\nnop\nnop\nnop\n");
} else {
static void ucg_com_arduino_send_generic_SW_SPI(ucg_t *ucg, uint8_t data)
{
uint8_t i = 8;
do
{
if ( data & 128 )
{
digitalWriteFast(ucg->pin_list[UCG_PIN_SDA], 1 );
}
else
{
digitalWriteFast(ucg->pin_list[UCG_PIN_SDA], 0 );
}
// no delay required, also Arduino Due is slow enough
//delayMicroseconds(1);
digitalWriteFast(ucg->pin_list[UCG_PIN_SCL], 1 );
//delayMicroseconds(1);
i--;
digitalWriteFast(ucg->pin_list[UCG_PIN_SCL], 0 );
//delayMicroseconds(1);
data <<= 1;
} while( i > 0 );
}
void adc0_isr(void)
{
uint32_t tmp = ADC0_RA; // read ADC result to clear interrupt
digitalWriteFast(3, HIGH);
delayMicroseconds(1);
digitalWriteFast(3, LOW);
}
extern "C" int main(void)
{
#define ARDUINO
#if !defined(ARDUINO)
// To use Teensy 3.0 without Arduino, simply put your code here.
// For example:
pinMode(13, OUTPUT);
while (1) {
digitalWriteFast(13, HIGH);
delay(100);
digitalWriteFast(13, LOW);
delay(100);
}
#else
// Arduino's main() function just calls setup() and loop()....
setup();
while (1) {
loop();
yield();
}
#endif
}
byte PS2Pad::gamepad_spi(byte send_data) {
byte recv_data = 0;
for(byte i = 0; i < 8; i++) {
digitalWriteFast(CLK_PIN, LOW);
if(send_data & (1 << i)) {
digitalWriteFast(CMD_PIN, HIGH);
} else {
digitalWriteFast(CMD_PIN, LOW);
}
delayMicroseconds(CTRL_CLK);
digitalWriteFast(CLK_PIN, HIGH);
if(digitalReadFast(DAT_PIN)) {
recv_data |= (1 << i);
}
delayMicroseconds(CTRL_CLK);
}
digitalWriteFast(CLK_PIN, HIGH);
delayMicroseconds(CTRL_BYTE_DELAY);
return recv_data;
}
/* Setup pins and initialize SPI hardware */
void pspad_init(void) {
pinModeFast(pinACK, OUTPUT);
digitalWriteFast(pinACK, HIGH);
pinModeFast(pinATT, INPUT);
digitalWriteFast(pinATT, HIGH);
pinModeFast(pinCMD, INPUT);
digitalWriteFast(pinCMD, HIGH);
pinModeFast(pinDAT, OUTPUT);
digitalWriteFast(pinDAT, HIGH);
pinModeFast(pinCLK, INPUT);
digitalWriteFast(pinCLK, HIGH);
SPCR |= (1 << CPOL); // SCK HIGH when idle
SPCR |= (1 << CPHA); // setup data on falling edge of CLK, read on rising edge
// turn on SPI in slave mode
SPCR |= _BV(SPE);
SPCR |= (1 << DORD); // data order to LSB first
// turn on interrupts
SPCR |= _BV(SPIE);
}
void Zetaohm_AD5676::setVoltage(uint16_t output, uint8_t dac )
{
uint8_t buffer[3];
//SPI.beginTransaction(SPISettings(50000000, MSBFIRST, SPI_MODE0));
digitalWriteFast(_cs_pin, LOW); // Begin transmission, bring SYNC line low
buffer[0] = (0x03 << 4) + dac;
buffer[1] = output / 256;
buffer[2] = output % 256;
spi4teensy3::send(buffer, 3 ); // FRAME 1 COMMAND BYTE - Command + DAC Address (C3 C2 C1 C0 A3 A2 A1 A0)
// SPI.transfer(buffer, 3 ); // FRAME 1 COMMAND BYTE - Command + DAC Address (C3 C2 C1 C0 A3 A2 A1 A0)
digitalWriteFast(_cs_pin, HIGH); // End transmission, bring SYNC line high
//SPI.endTransaction();
// digitalWrite(_ldac_pin, HIGH);
//
// digitalWrite(_ldac_pin, LOW);
// digitalWrite(_ldac_pin, HIGH);
// delay(1);
// digitalWriteFast(_cs_pin, LOW); // Begin transmission, bring SYNC line low
// buffer[1] = 0xFF;
// buffer[2] = 0xFF;
// buffer[0] = (0x02 << 4) + dac;
// spi4teensy3::send(buffer, 3 ); // FRAME 1 COMMAND BYTE - Command + DAC Address (C3 C2 C1 C0 A3 A2 A1 A0)
//
// digitalWriteFast(_cs_pin, HIGH); // End transmission, bring SYNC line high
}
int SpiFlash::write(byte* _buf, long _addr, uint16_t _length)
{
// Below if statement checks that device is ready, _address is within device memory, and there won't be a page overflow writing data
if (!checkWriteInProgress() && _length <= PAGE_SIZE && check_address(_addr, _length) && checkPageOverflow(_addr, _length))
{
digitalWriteFast(SS, LOW);
send(PAGE_PROGRAM);
send(_addr >> 16);
send(_addr >> 8);
send(_addr);
#ifdef DEBUG
Serial.println("Writing Data. . .");
#endif
for (int i = 0; i < _length; i++)
{
send(*_buf);
#ifdef DEBUG
//Serial.println(*_buf, BIN);
#endif
_buf++;
}
digitalWriteFast(SS, HIGH);
writeEnable();
return 1; // returns 1 if ok
}
byte SPIPump(byte data) {
byte receivedData=0;
for (int8_t i=7; i>=0; i--) {
receivedData <<= 1;
if (data & (1<<i)) {
digitalWriteFast(WLAN_MOSI, HIGH);
}
else {
digitalWriteFast(WLAN_MOSI, LOW);
}
digitalWriteFast(WLAN_SCK, HIGH);
asm volatile("nop");
asm volatile("nop");
digitalWriteFast(WLAN_SCK, LOW);
if (digitalReadFast(WLAN_MISO)) {
receivedData |= 1;
}
asm volatile("nop");
asm volatile("nop");
}
return(receivedData);
}
// TODO: Make this non-blocking
void shortBeep(){
#ifdef BEEP
digitalWriteFast(BUZZER_PIN, HIGH);
delay(150);
digitalWriteFast(BUZZER_PIN, LOW);
#endif
}
void LiquidCrystalNew_SSPI::writeByte(byte cmd,byte value){
//start send
#if defined(__FASTSWRITE2__)
BLOCK_IRQS();
*portOutputRegister(csport) &= ~ cspin;//low
ENABLE_IRQS();
#elif defined(__FASTSWRITE__)
digitalWriteFast(_cs, LOW);
#else
digitalWrite(_cs, LOW);
#endif
altSPIwrite(_adrs << 1);//in write, in read: SPI.transfer((addr << 1) | 1);
//this 2 byte blocks instruct the chip
altSPIwrite(cmd);
altSPIwrite(value);
// now closing communication...
#if defined(__FASTSWRITE2__)
BLOCK_IRQS();
*portOutputRegister(csport) |= cspin;//hi
ENABLE_IRQS();
#elif defined(__FASTSWRITE__)
digitalWriteFast(_cs, HIGH);
#else
digitalWrite(_cs, HIGH);
#endif
}
// TODO: Make this non-blocking
void longBeep(){
#ifdef BEEP
digitalWriteFast(BUZZER_PIN, HIGH);
delay(350);
digitalWriteFast(BUZZER_PIN, LOW);
#endif
}
void SDcard::init(uint8_t clock_div)
{
//init pins
#ifdef SD_PWR_PIN
pinMode(SD_PWR_PIN, OUTPUT);
digitalWriteFast(SD_PWR_PIN, LOW); //power on
#endif
pinMode(SD_CS_PIN, OUTPUT);
digitalWriteFast(SD_CS_PIN, HIGH); //deselect
pinMode(SD_MISO_PIN, INPUT);
digitalWriteFast(SD_MISO_PIN, HIGH); //pull-up
pinMode(SD_MOSI_PIN, OUTPUT);
pinMode(SD_CLK_PIN, OUTPUT);
#if !defined(SD_SOFTWARE_SPI)
//SS has to be output or input with pull-up
# if (defined(__AVR_ATmega1280__) || \
defined(__AVR_ATmega1281__) || \
defined(__AVR_ATmega2560__) || \
defined(__AVR_ATmega2561__)) //--- Arduino Mega ---
# define SD_SS_PORTBIT (0) //PB0
# elif (defined(__AVR_ATmega644__) || \
defined(__AVR_ATmega644P__)) //--- Arduino 644 ---
# define SD_SS_PORTBIT (4) //PB4
# else //--- Arduino Uno ---
# define SD_SS_PORTBIT (2) //PB2
# endif
if(!(DDRB & (1<<SD_SS_PORTBIT))) //SS is input
{
PORTB |= (1<<SD_SS_PORTBIT); //pull-up on
}
//init hardware spi
switch(clock_div)
{
case 2:
SPCR = (1<<SPE)|(1<<MSTR); //enable SPI, Master, clk=Fcpu/4
SPSR = (1<<SPI2X); //clk*2 = Fcpu/2
break;
case 4:
SPCR = (1<<SPE)|(1<<MSTR); //enable SPI, Master, clk=Fcpu/4
SPSR = (0<<SPI2X); //clk*2 = off
break;
case 8:
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0); //enable SPI, Master, clk=Fcpu/16
SPSR = (1<<SPI2X); //clk*2 = Fcpu/8
break;
case 16:
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0); //enable SPI, Master, clk=Fcpu/16
SPSR = (0<<SPI2X); //clk*2 = off
break;
case 32:
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1); //enable SPI, Master, clk=Fcpu/64
SPSR = (1<<SPI2X); //clk*2 = Fcpu/32
break;
}
#endif
return;
}
void fcBuffers::finalizeFrame()
{
// Called in main loop context.
// Finalize any frames received during the course of this loop iteration,
// and update the status LED.
if (flags & CFLAG_NO_ACTIVITY_LED) {
// LED under manual control
digitalWriteFast(LED_BUILTIN, flags & CFLAG_LED_CONTROL);
} else {
// Use the built-in LED as a USB activity indicator.
digitalWriteFast(LED_BUILTIN, handledAnyPacketsThisFrame);
}
handledAnyPacketsThisFrame = false;
if (pendingFinalizeFrame) {
finalizeFramebuffer();
pendingFinalizeFrame = false;
}
if (pendingFinalizeLUT) {
finalizeLUT();
pendingFinalizeLUT = false;
}
// Let the USB driver know we may be able to process buffers that were previously deferred
usb_rx_resume();
}
void hexbright::set_light_level(unsigned long level) {
// LOW 255 approximately equals HIGH 48/49. There is a color change.
// Values < 4 do not provide any light.
// I don't know about relative power draw.
// look at linearity_test.ino for more detail on these algorithms.
#if (DEBUG==DEBUG_LIGHT)
Serial.print("light level: ");
Serial.println(level);
#endif
pinModeFast(DPIN_PWR, OUTPUT);
digitalWriteFast(DPIN_PWR, HIGH);
if(level == 0) {
// lowest possible power, but still running (DPIN_PWR still high)
digitalWriteFast(DPIN_DRV_MODE, LOW);
analogWrite(DPIN_DRV_EN, 0);
}
else if(level<=500) {
digitalWriteFast(DPIN_DRV_MODE, LOW);
analogWrite(DPIN_DRV_EN, .000000633*(level*level*level)+.000632*(level*level)+.0285*level+3.98);
} else {
level -= 500;
digitalWriteFast(DPIN_DRV_MODE, HIGH);
analogWrite(DPIN_DRV_EN, .00000052*(level*level*level)+.000365*(level*level)+.108*level+44.8);
}
}
inline void hexbright::_led_off(unsigned char led) {
if(led == RLED) { // DPIN_RLED_SW
digitalWriteFast(DPIN_RLED_SW, LOW);
pinModeFast(DPIN_RLED_SW, INPUT);
} else { // DPIN_GLED
digitalWriteFast(DPIN_GLED, LOW);
}
}
void ssd1351_init_board(void) {
pinMode(SSD1351_R, OUTPUT);
pinMode(SSD1351_CS, OUTPUT);
pinMode(SSD1351_DC, OUTPUT);
digitalWriteFast(SSD1351_R, 1);
digitalWriteFast(SSD1351_CS, 1);
digitalWriteFast(SSD1351_DC, 1);
}
void hexbright::shutdown() {
pinModeFast(DPIN_PWR, OUTPUT);
digitalWriteFast(DPIN_PWR, LOW);
digitalWriteFast(DPIN_DRV_MODE, LOW);
analogWrite(DPIN_DRV_EN, 0);
// make sure we don't try to turn back on
change_done = change_duration+1;
end_light_level = 0;
}
// init
// Initializes the vision chips for normal operation. Sets vision chip pins to low outputs, clears
// chip registers, sets biases and config register. Arduino pin numbers must be specified. For
// the remaining parameters if no parameters are passed in, default values are used.
void Stonyman::init( char inPinRESP, char inPinINCP, char inPinRESV, char inPinINCV,
char inPinINPHI, char inPinANALOG1, char inPinANALOG2, short vref, short nbias,
short aobias, char gain, char selamp )
{
short config;
/* TODO russ: use later
if(Stonyman::MAX_GAIN < inGain)
{
return Stonyman::RC_ERROR_BADPARAM;
}
// TODO russ: there are likely other checks to perform (vref, nbias, aobias)
*/
pinRESP = inPinRESP;
pinINCP = inPinINCP;
pinRESV = inPinRESV;
pinINCV = inPinINCV;
pinINPHI = inPinINPHI;
pinANALOG1 = inPinANALOG1;
pinANALOG2 = inPinANALOG2;
// set all digital pins to output
pinMode(pinRESP, OUTPUT);
pinMode(pinINCP, OUTPUT);
pinMode(pinRESV, OUTPUT);
pinMode(pinINCV, OUTPUT);
pinMode(pinINPHI, OUTPUT);
// FIXME russ: is this necessary?
pinMode(pinANALOG1, INPUT);
pinMode(pinANALOG2, INPUT);
// set all pins low
digitalWriteFast(pinRESP, 0);
digitalWriteFast(pinINCP, 0);
digitalWriteFast(pinRESV, 0);
digitalWriteFast(pinINCV, 0);
digitalWriteFast(pinINPHI, 0);
//clear all chip register values
clearValues();
//set up biases
// TODO russ: haven't looked at what this function does
setBiases(vref,nbias,aobias);
// sanitize this input before use
flagUseAmplifier=selamp ? 1:0;
config=gain+(flagUseAmplifier*8)+(16);
//turn chip on with config value
setPointerValue(Stonyman::REG_CONFIG,config);
// TODO russ: use later
// return Stonyman::RC_OK;
}
int PS2Pad::init(bool disableInt) {
PS2Pad::_disableInt = disableInt;
pinModeFast(DAT_PIN, INPUT);
digitalWriteFast(DAT_PIN, HIGH);
pinModeFast(CLK_PIN, OUTPUT);
pinModeFast(ATT_PIN, OUTPUT);
pinModeFast(CMD_PIN, OUTPUT);
// Init pad
digitalWriteFast(CLK_PIN, HIGH);
digitalWriteFast(CMD_PIN, HIGH);
PS2Pad::read();
if(PS2Pad::_pad_data[1] != 0x41 && PS2Pad::_pad_data[1] != 0x73 && PS2Pad::_pad_data[1] != 0x79) {
return 1;
}
PS2Pad::_read_delay = 1;
for(byte i = 0; i <= 2; i++) {
// Enter Config Mode
byte enter_config_command[] = {0x01, 0x43, 0x00, 0x01, 0x00};
PS2Pad::send_command(enter_config_command, 5);
// Get pad type
byte get_pad_type_command[] = {0x01, 0x45, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A};
PS2Pad::send_command(get_pad_type_command, 9);
PS2Pad::_type = get_pad_type_command[3];
// Lock to Analog Mode on Stick
byte lock_analog_mode_command[] = {0x01, 0x44, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00};
PS2Pad::send_command(lock_analog_mode_command, 9);
// Exit config mode
byte exit_config_command[] = {0x01, 0x43, 0x00, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A};
PS2Pad::send_command(exit_config_command, 9);
PS2Pad::read();
if(PS2Pad::_pad_data[1] == 0x73) {
_analogMode = true;
break;
}
PS2Pad::_read_delay++;
}
return 0;
}
static void prvQueueReceiveTask(void *pvParameters)
{
while(1)
{
digitalWriteFast(13, HIGH);
delay(10);
digitalWriteFast(13, LOW);
delay(1000);
}
}
void ADDAC::StoreManuals(int _socket,int _channel){ // EXTERNAL READING
if(_socket == A){
digitalWriteFast(manualInAs0, truthTableA[_channel]);
digitalWriteFast(manualInAs1, truthTableB[_channel]);
digitalWriteFast(manualInAs2, truthTableC[_channel]);
manualValuesA[_channel]=1-(analogRead(manualInApin)/1023.0f);
}
else if(_socket == B){
digitalWriteFast(manualInBs0, truthTableA[_channel]);
digitalWriteFast(manualInBs1, truthTableB[_channel]);
digitalWriteFast(manualInBs2, truthTableC[_channel]);
manualValuesB[_channel]=1-(analogRead(manualInBpin)/1023.0f);
}
else if(_socket == C){
digitalWriteFast(manualInCs0, truthTableA[_channel]);
digitalWriteFast(manualInCs1, truthTableB[_channel]);
digitalWriteFast(manualInCs2, truthTableC[_channel]);
manualValuesC[_channel]=1-(analogRead(manualInCpin)/1023.0f);
}
}
void PJON::send_byte(uint8_t b) {
digitalWriteFast(_input_pin, HIGH);
delayMicroseconds(BIT_SPACER);
digitalWriteFast(_input_pin, LOW);
delayMicroseconds(BIT_WIDTH);
for(uint8_t mask = 0x01; mask; mask <<= 1) {
digitalWriteFast(_input_pin, b & mask);
delayMicroseconds(BIT_WIDTH);
}
}
inline void LiquidCrystalNew_SSPI::altSPIwrite(uint8_t d) {
for (int8_t i=7; i>=0; i--) {
digitalWriteFast(_clk, LOW);
if (d & _BV(i)) {
digitalWriteFast(_mosi, HIGH);
} else {
digitalWriteFast(_mosi, LOW);
}
digitalWriteFast(_clk, HIGH);
}
}
void digitalPotWrite(int value) {
// take the SS pin low to select the chip:
digitalWriteFast(10,LOW);
// send in the address and value via spi:
//last 2 bits: pot select
//other 1: write command
SPI.transfer(0b00010011);
SPI.transfer(value);
// take the SS pin high to de-select the chip:
digitalWriteFast(10,HIGH);
}
void Zetaohm_AD5676::begin(uint8_t cs_pin, uint8_t ldac_pin) {
_cs_pin = cs_pin;
_ldac_pin = ldac_pin;
pinMode(_cs_pin, OUTPUT); // cs_pin is also the SYNC pin
pinMode(_ldac_pin, OUTPUT); // configure cs_pin as output
digitalWriteFast(_cs_pin, HIGH); //deactivate DAC
digitalWriteFast(_ldac_pin, LOW);
spi4teensy3::init(0,1,0);
//SPI.begin ();
//SPI.setClockDivider(SPI_CLOCK_DIV2);
}
inline void hexbright::_led_on(unsigned char led) {
if(led == RLED) { // DPIN_RLED_SW
pinModeFast(DPIN_RLED_SW, OUTPUT);
byte l = rledMap[led_brightness[RLED]>>6];
byte r = 1<<(loopCount & 0b11);
if(l & r) {
digitalWriteFast(DPIN_RLED_SW, HIGH);
} else {
digitalWriteFast(DPIN_RLED_SW, LOW);
}
} else { // DPIN_GLED
void hexbright::init_hardware() {
// These next 8 commands are for reference and cost nothing,
// as we are initializing the values to their default state.
pinModeFast(DPIN_PWR, OUTPUT);
digitalWriteFast(DPIN_PWR, LOW);
pinModeFast(DPIN_RLED_SW, INPUT);
pinModeFast(DPIN_GLED, OUTPUT);
pinModeFast(DPIN_DRV_MODE, OUTPUT);
pinModeFast(DPIN_DRV_EN, OUTPUT);
digitalWriteFast(DPIN_DRV_MODE, LOW);
digitalWriteFast(DPIN_DRV_EN, LOW);
#if (DEBUG!=DEBUG_OFF)
// Initialize serial busses
Serial.begin(9600);
Wire.begin();
Serial.println("DEBUG MODE ON");
#endif
#if (DEBUG!=DEBUG_OFF && DEBUG!=DEBUG_PRINT)
if(DEBUG==DEBUG_LIGHT) {
// do a full light range sweep, (printing all light intensity info)
set_light(0,1000,update_delay*1002);
} else if (DEBUG==DEBUG_TEMP) {
set_light(0, MAX_LEVEL, NOW);
} else if (DEBUG==DEBUG_LOOP) {
// note the use of TIME_MS/update_delay.
set_light(0, MAX_LEVEL, 2500/update_delay);
}
#ifdef FREE_RAM
Serial.print("Ram available: ");
Serial.print(freeRam());
Serial.println("/1024 bytes");
#endif
#ifdef FLASH_CHECKSUM
Serial.print("Flash checksum: ");
Serial.println(flash_checksum());
#endif
#endif // DEBUG!=DEBUG_OFF
#ifdef ACCELEROMETER
enable_accelerometer();
#endif
// was this power on from battery? if so, it was a button press, even if it was too fast to register.
read_charge_state();
if(get_charge_state()==BATTERY)
press_button();
continue_time = micros();
}
void saturn_init() {
pinModeFast(D1, INPUT);
pinModeFast(D0, INPUT);
pinModeFast(D3, INPUT);
pinModeFast(D2, INPUT);
pinModeFast(S0, OUTPUT);
pinModeFast(S1, OUTPUT);
digitalWriteFast(D1, HIGH);
digitalWriteFast(D0, HIGH);
digitalWriteFast(D3, HIGH);
digitalWriteFast(D2, HIGH);
}
static void prvLEDTimerCallback( xTimerHandle xTimer )
{
static int toggle = 0;
if(toggle == 0) {
digitalWriteFast(12, HIGH);
toggle = 1;
}
else {
digitalWriteFast(12, LOW);
toggle = 0;
}
}
