int main(void) {
setPin(DDRC,4);
char buffer[4];
/*
* Initialize UART library, pass baudrate and AVR cpu clock
* with the macro
* UART_BAUD_SELECT() (normal speed mode )
* or
* UART_BAUD_SELECT_DOUBLE_SPEED() ( double speed mode)
*/
uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
/*
* now enable interrupt, since UART library is interrupt controlled
*/
sei();
unsigned int c;
uart_puts("Ready.\r\n");
while(1) {
/*
* Get received character from ringbuffer
* uart_getc() returns in the lower byte the received character and
* in the higher byte (bitmask) the last receive error
* UART_NO_DATA is returned when no data is available.
*
*/
c = uart_getc();
if ( c & UART_NO_DATA )
{
/*
* no data available from UART
*/
}
else
{
/*
* new data available from UART
* check for Frame or Overrun error
*/
if ( c & UART_FRAME_ERROR )
{
/* Framing Error detected, i.e no stop bit detected */
uart_puts_P("UART Frame Error: ");
}
if ( c & UART_OVERRUN_ERROR )
{
/*
* Overrun, a character already present in the UART UDR register was
* not read by the interrupt handler before the next character arrived,
* one or more received characters have been dropped
*/
uart_puts_P("UART Overrun Error: ");
}
if ( c & UART_BUFFER_OVERFLOW )
{
/*
* We are not reading the receive buffer fast enough,
* one or more received character have been dropped
*/
uart_puts_P("Buffer overflow error: ");
}
/*
* send received character back
*/
// PORTC ^= 1 << PINC4;
if ((unsigned char)c == 'n') {
setPin(PORTC,4);
uart_puts("On.\r\n");
}
else if ((unsigned char)c == 'm') {
clearPin(PORTC,4);
uart_puts("Off.\r\n");
}
// uart_putc( (unsigned char)c );
}
}
}
void Pineapple::clear(){
//set all register pins to LOW
for(int i = _Number_of_Registers * 8 - 1; i >= 0; i--){
setPin(i, _common);
}
}
void TMRpcm::play(char* filename, unsigned long seekPoint){
if(speakerPin != lastSpeakPin){
#if !defined (MODE2)
setPin();
#else
setPins();
#endif
lastSpeakPin=speakerPin;
}
stopPlayback();
if(!wavInfo(filename)){
#if defined (debug)
Serial.println("WAV ERROR");
#endif
return;
}//verify its a valid wav file
if(seekPoint > 0){ seekPoint = (SAMPLE_RATE*seekPoint) + fPosition();
seek(seekPoint); //skip the header info
}
playing = 1; bitClear(optionByte,7); //paused = 0;
if(SAMPLE_RATE > 45050 ){ SAMPLE_RATE = 24000;
#if defined (debug)
Serial.print("SAMPLE RATE TOO HIGH: ");
Serial.println(SAMPLE_RATE);
#endif
}
#if !defined (USE_TIMER2)
//if(qual)
if(bitRead(optionByte,6)){resolution = 10 * (800000/SAMPLE_RATE);}
else{ resolution = 10 * (1600000/SAMPLE_RATE);
}
#else
resolution = 255;
if(SAMPLE_RATE < 9000){
*TCCRnB[tt] &= ~_BV(CS20);
*TCCRnB[tt] |= _BV(CS21);
}else{
*TCCRnB[tt] &= ~_BV(CS21);
*TCCRnB[tt] |= _BV(CS20);
}
#endif
byte tmp = (sFile.read() + sFile.peek()) / 2;
#if defined(rampMega)
if(bitRead(optionByte,5)){
*OCRnA[tt] = 0; *OCRnB[tt] = resolution;
timerSt();
for(unsigned int i=0; i < resolution; i++){
*OCRnB[tt] = constrain(resolution-i,0,resolution);
//if(bitRead(*TCCRnB[tt],0)){
// for(int i=0; i<10; i++){
// while(*TCNT[tt] < resolution-50){}
// }
//}else{
delayMicroseconds(150);
//}
}
}
bitClear(optionByte,5);
#endif
//rampUp = 0;
unsigned int mod;
if(volMod > 0){ mod = *OCRnA[tt] >> volMod; }else{ mod = *OCRnA[tt] << (volMod*-1); }
bool set_uint8_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id, uint8_t value)
{
uint8_t retval;
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_PIN:
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_PIN:
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_PIN:
case NODE_TYPE_CONFIG_LEAF_BUZZER_PIN:
case NODE_TYPE_CONFIG_LEAF_TEMP_SENSOR_PIN:
case NODE_TYPE_CONFIG_LEAF_HEATER_PIN:
case NODE_TYPE_CONFIG_LEAF_STEPPER_ENABLE_PIN:
case NODE_TYPE_CONFIG_LEAF_STEPPER_DIRECTION_PIN:
case NODE_TYPE_CONFIG_LEAF_STEPPER_STEP_PIN:
return setPin(node_type, parent_instance_id, value);
case NODE_TYPE_CONFIG_LEAF_SYSTEM_HARDWARE_TYPE:
retval = NVConfigStore::SetHardwareType(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_HARDWARE_REV:
retval = NVConfigStore::SetHardwareRevision(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_INPUT_SWITCHES:
retval = Device_InputSwitch::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_OUTPUT_SWITCHES:
retval = Device_OutputSwitch::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_PWM_OUTPUTS:
retval = Device_PwmOutput::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_BUZZERS:
retval = Device_Buzzer::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_TEMP_SENSORS:
retval = Device_TemperatureSensor::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_HEATERS:
retval = Device_Heater::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_STEPPERS:
retval = Device_Stepper::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_INITIAL_STATE:
retval = Device_OutputSwitch::SetInitialState(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_TEMP_SENSOR:
retval = Device_Heater::SetTempSensor(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_POWER_ON_LEVEL:
retval = Device_Heater::SetPowerOnLevel(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_BANG_BANG_HYSTERESIS:
retval = Device_Heater::SetBangBangHysteresis(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_FUNCTIONAL_RANGE:
retval = Device_Heater::SetPidFunctionalRange(parent_instance_id, value);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_send();
return false;
}
void Pineapple::setAll(boolean val){
//set all register pins to LOW
for(int i = _Number_of_Registers * 8 - 1; i >= 0; i--){
setPin(i, val);
}
}
void runMotor(word i2c, word motor, word command){
word in1, in2;
//Defines which motor to control by setting which pins are input and output
switch(motor){
case 1:
in1 = PWM_M1_IN1;
in2 = PWM_M1_IN2;
break;
case 2:
in1 = PWM_M2_IN1;
in2 = PWM_M2_IN2;
break;
case 3:
in1 = PWM_M3_IN1;
in2 = PWM_M3_IN2;
break;
case 4:
in1 = PWM_M4_IN1;
in2 = PWM_M4_IN2;
break;
default:
printf("Invalid motor number '%d'\n", motor);
return;
}
//Sets pins to high or low to define controls
switch(command){
case MOTOR_FORWARD:
setPin(i2c, in2, 0);
setPin(i2c, in1, 1);
break;
case MOTOR_BACK:
setPin(i2c, in1, 0);
setPin(i2c, in2, 1);
break;
case MOTOR_RELEASE:
setPin(i2c, in1, 0);
setPin(i2c, in2, 0);
break;
case MOTOR_BRAKE:
setPin(i2c, in1, 1);
setPin(i2c, in2, 1);
default:
printf("Unsupported command '%d'\n", command);
return;
}
}
// private
Interrupt::Interrupt(const ConstantString & name, const size_t pin)
{
setup(name);
setPin(pin);
}
void connectUSB() {
#if !defined(BOARD_DiscoveryF4)
//resetPin (USB_DISC_BANK,USB_DISC); /* present ourselves to the host */
setPin (USB_DISC_BANK,USB_DISC); /* ala42: present ourselves to the host */
#endif
}
int main(int argc, char ** argv)
{
DWORD devIndex = 0;
char Buffer[255];
ftdi_pins.pins = 0xF1;
ftdi_pins.clk = HIGH;
DWORD p = 0;
byte e1 = 0xff;
byte e2 = 0;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hConsole, 7);
if (argc < 2) {
printf("Please specify the hex file\n");
return 1;
}
FT_STATUS ftStatus = FT_ListDevices((PVOID)devIndex, Buffer, FT_LIST_BY_INDEX | FT_OPEN_BY_SERIAL_NUMBER);
if (ftStatus == FT_OK) {
int bytes = load_file(argv[1]);
ftStatus = FT_OpenEx(Buffer, FT_OPEN_BY_SERIAL_NUMBER, &ftdi_chip);
FT_SetBitMode(ftdi_chip, PIN_TX | PIN_RX | PIN_CTS, 1); // BIT BANG MODE
FT_SetBaudRate(ftdi_chip, BAUD_RATE);
setPin(RST_8051, LOW);
setPin(MOSI_8051, LOW);
setPin(CLK_8051, LOW);
setPin(RST_8051, HIGH);
Sleep(500);
printf("%x\n", progEnable());
Sleep(1100);
eraseChip();
for (int i = from_addr; i < to_addr + 1; i++) {
printf("%02X", readProgmem(0, i));
}
printf("\n");
for (int i = from_addr; i < to_addr + 1; i++) {
printf("%02X", memory[i]);
}
printf("\n");
// write memory
for (int i = from_addr; i < to_addr+1; i++) {
writeProgmem(0, i, memory[i]);
printf("%02X", readProgmem(0, i));
}
printf("\n");
Sleep(1000);
setPin(RST_8051, LOW);
Sleep(500);
FT_Close(ftdi_chip);
getchar();
}
else {
printf("Can't open FTDI chip\n");
return 1;
}
return 0;
}
AIPin& AIPin::operator = (uint8_t p_rhs)
{
setPin(p_rhs);
return *this;
}
