int main(void){
// The following four lines are due to my laziness about breadboard.
SET_OUTPUT(DDRD,3); // +5v
SET_HIGH(PORTD,3); // +5V
SET_OUTPUT(DDRD,4); // GND
SET_LOW(PORTD,4); // GND
// Initial values of channels.
channels[0]=25;
channels[1]=75;
channels[2]=125;
channels[3]=175;
channels[4]=225;
// Set to taste. Start with 0 initially.
pulse_fine_tune=30;
// Start.
init_transmission();
while(1){
// Changing channels
channels[0]++;
_delay_ms(100);
}
return 0;
}
/******* EXT IO ***********************/
void ZeroPi::extInit(int index, int type){
if(EXT_INPUT == type){
SET_INPUT(extios[index].pin);
extios[index].function = EXT_INPUT;
}else if(EXT_OUTPUT == type){
SET_OUTPUT(extios[index].pin);
extios[index].function = EXT_OUTPUT;
}else if(EXT_SERVO== type){
SET_OUTPUT(extios[index].pin);
extios[index].function = EXT_SERVO;
}
}
void HAL::spiBegin()
{
#if MOTHERBOARD == 500 || MOTHERBOARD == 501
if (spiInitMaded == false)
{
#endif // Configre SPI pins
PIO_Configure(
g_APinDescription[SCK_PIN].pPort,
g_APinDescription[SCK_PIN].ulPinType,
g_APinDescription[SCK_PIN].ulPin,
g_APinDescription[SCK_PIN].ulPinConfiguration);
PIO_Configure(
g_APinDescription[MOSI_PIN].pPort,
g_APinDescription[MOSI_PIN].ulPinType,
g_APinDescription[MOSI_PIN].ulPin,
g_APinDescription[MOSI_PIN].ulPinConfiguration);
PIO_Configure(
g_APinDescription[MISO_PIN].pPort,
g_APinDescription[MISO_PIN].ulPinType,
g_APinDescription[MISO_PIN].ulPin,
g_APinDescription[MISO_PIN].ulPinConfiguration);
// set master mode, peripheral select, fault detection
SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR |
SPI_MR_MODFDIS | SPI_MR_PS);
SPI_Enable(SPI0);
#if MOTHERBOARD == 500 || MOTHERBOARD == 501
SET_OUTPUT(DAC0_SYNC);
#if NUM_EXTRUDER > 1
SET_OUTPUT(DAC1_SYNC);
WRITE(DAC1_SYNC, HIGH);
#endif
SET_OUTPUT(SPI_EEPROM1_CS);
SET_OUTPUT(SPI_EEPROM2_CS);
SET_OUTPUT(SPI_FLASH_CS);
WRITE(DAC0_SYNC, HIGH);
WRITE(SPI_EEPROM1_CS, HIGH );
WRITE(SPI_EEPROM2_CS, HIGH );
WRITE(SPI_FLASH_CS, HIGH );
WRITE(SDSS , HIGH );
#endif// MOTHERBOARD == 500 || MOTHERBOARD == 501
PIO_Configure(
g_APinDescription[SPI_PIN].pPort,
g_APinDescription[SPI_PIN].ulPinType,
g_APinDescription[SPI_PIN].ulPin,
g_APinDescription[SPI_PIN].ulPinConfiguration);
spiInit(1);
#if (MOTHERBOARD==500) || (MOTHERBOARD==501)
spiInitMaded = true;
}
#endif
}
// ----------------------------------------------------------------------------
void mcp2515_spi_init(void)
{
// Aktivieren der Pins fuer das SPI Interface
SET(MCP2515_CS);
SET_OUTPUT(MCP2515_CS);
// Aktivieren der Pins fuer das SPI Interface
RESET(P_SCK);
RESET(P_MOSI);
RESET(P_MISO);
SET_OUTPUT(P_SCK);
SET_OUTPUT(P_MOSI);
SET_INPUT(P_MISO);
}
void setup_powerhold()
{
#if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
SET_OUTPUT(SUICIDE_PIN);
WRITE(SUICIDE_PIN, HIGH);
#endif
#if defined(PS_ON_PIN) && PS_ON_PIN > -1
SET_OUTPUT(PS_ON_PIN);
#if defined(PS_DEFAULT_OFF)
WRITE(PS_ON_PIN, PS_ON_ASLEEP);
#else
WRITE(PS_ON_PIN, PS_ON_AWAKE);
#endif
#endif
}
void MD_TCS230::begin()
{
#define SET_OUTPUT(x) if (x!=NO_PIN) pinMode(x,OUTPUT)
SET_OUTPUT(_S0);
SET_OUTPUT(_S1);
SET_OUTPUT(_S2);
SET_OUTPUT(_S3);
SET_OUTPUT(_OE);
setEnable(false);
setFrequency2(_freqSet);
#undef SET_OUTPUT
DUMPS("\nLibrary begin initialised");
}
void buzz(long duration, uint16_t freq) {
if (freq > 0) {
#if ENABLED(LCD_USE_I2C_BUZZER)
lcd_buzz(duration, freq);
#elif PIN_EXISTS(BEEPER) // on-board buzzers have no further condition
SET_OUTPUT(BEEPER_PIN);
#if ENABLED(SPEAKER) // a speaker needs a AC ore a pulsed DC
//tone(BEEPER_PIN, freq, duration); // needs a PWMable pin
unsigned int delay = 1000000 / freq / 2;
int i = duration * freq / 1000;
while (i--) {
WRITE(BEEPER_PIN, HIGH);
delayMicroseconds(delay);
WRITE(BEEPER_PIN, LOW);
delayMicroseconds(delay);
}
#else // buzzer has its own resonator - needs a DC
WRITE(BEEPER_PIN, HIGH);
delay(duration);
WRITE(BEEPER_PIN, LOW);
#endif
#else
delay(duration);
#endif
} else
delay(duration);
}
void suicide()
{
#if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
SET_OUTPUT(SUICIDE_PIN);
WRITE(SUICIDE_PIN, LOW);
#endif
}
void setup_photpin()
{
#if defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1
SET_OUTPUT(PHOTOGRAPH_PIN);
WRITE(PHOTOGRAPH_PIN, LOW);
#endif
}
void Space::load_motor(int m, int32_t &addr) { // {{{
loaddebug("loading motor %d", m);
uint16_t enable = motor[m]->enable_pin.write();
double old_home_pos = motor[m]->home_pos;
double old_steps_per_unit = motor[m]->steps_per_unit;
motor[m]->step_pin.read(read_16(addr));
motor[m]->dir_pin.read(read_16(addr));
motor[m]->enable_pin.read(read_16(addr));
motor[m]->limit_min_pin.read(read_16(addr));
motor[m]->limit_max_pin.read(read_16(addr));
motor[m]->steps_per_unit = read_float(addr);
motor[m]->home_pos = read_float(addr);
motor[m]->limit_v = read_float(addr);
motor[m]->limit_a = read_float(addr);
motor[m]->home_order = read_8(addr);
arch_motors_change();
SET_OUTPUT(motor[m]->enable_pin);
if (enable != motor[m]->enable_pin.write()) {
if (motors_busy)
SET(motor[m]->enable_pin);
else {
RESET(motor[m]->enable_pin);
}
}
RESET(motor[m]->step_pin);
SET_INPUT(motor[m]->limit_min_pin);
SET_INPUT(motor[m]->limit_max_pin);
bool must_move = false;
if (!isnan(motor[m]->home_pos)) {
// Axes with a limit switch.
if (motors_busy && (old_home_pos != motor[m]->home_pos || old_steps_per_unit != motor[m]->steps_per_unit) && !isnan(old_home_pos)) {
double ohp = old_home_pos * old_steps_per_unit;
double hp = motor[m]->home_pos * motor[m]->steps_per_unit;
double diff = hp - ohp;
motor[m]->settings.current_pos += diff;
//debug("load motor %d %d new home %f add %f", id, m, motor[m]->home_pos, diff);
arch_addpos(id, m, diff);
must_move = true;
}
}
else {
// Axes without a limit switch, including extruders.
if (motors_busy && old_steps_per_unit != motor[m]->steps_per_unit) {
debug("load motor %d %d new steps no home", id, m);
double oldpos = motor[m]->settings.current_pos;
double pos = oldpos / old_steps_per_unit;
motor[m]->settings.current_pos = pos * motor[m]->steps_per_unit;
arch_addpos(id, m, motor[m]->settings.current_pos - oldpos);
// Adjust current_pos in all history.
for (int h = 0; h < FRAGMENTS_PER_BUFFER; ++h) {
oldpos = motor[m]->history[h].current_pos;
pos = oldpos / old_steps_per_unit;
motor[m]->history[h].current_pos = pos * motor[m]->steps_per_unit;
}
}
}
if (must_move)
move_to_current();
} // }}}
/******* DC MOTORS *******************/
void ZeroPi::motorInit(int slot){
int n;
for(n=0;n<SLOT_NUM_PINS;n++){
SET_OUTPUT(slots[slot].pin[n]);
}
slots[slot].function = SLOT_MOTOR;
}
/******* STEPPERS *******************/
void ZeroPi::stepperInit(int slot){
int n;
for(n=0;n<SLOT_NUM_PINS;n++){
SET_OUTPUT(slots[slot].pin[n]);
}
stepperEnable(slot,0);
slots[slot].function = SLOT_STEPPER;
}
bool sja1000_init(uint8_t bitrate)
{
if (bitrate >= 8)
return false;
#if !SJA1000_MEMORY_MAPPED
SET(SJA1000_WR);
SET(SJA1000_RD);
RESET(SJA1000_ALE);
RESET(SJA1000_CS);
SET_OUTPUT(SJA1000_WR);
SET_OUTPUT(SJA1000_RD);
SET_OUTPUT(SJA1000_ALE);
SET_OUTPUT(SJA1000_CS);
DDR(SJA1000_DATA) = 0xff;
#endif
// enter reset mode
sja1000_write(MOD, (1<<RM)|(1<<AFM));
// choose PeliCAN-Mode
sja1000_write(CDR, (1<<CANMODE) | SJA1000_CLOCK_REGISTER);
// select the bitrate configuration
sja1000_write(BTR0, pgm_read_byte(&_sja1000_cnf[bitrate][0]));
sja1000_write(BTR1, pgm_read_byte(&_sja1000_cnf[bitrate][1]));
// filter are not practical useable, so we disable them
sja1000_write(AMR0, 0xff);
sja1000_write(AMR1, 0xff);
sja1000_write(AMR2, 0xff);
sja1000_write(AMR3, 0xff);
// set output driver configuration
sja1000_write(OCR, (1<<OCTP0)|(1<<OCTN0)|(1<<OCMODE1));
// enable receive interrupt
sja1000_write(IER, (1<<RIE));
// leave reset-mode
sja1000_write(MOD, (1<<AFM));
return true;
}
/**
* @brief Begin SPI port setup
*
* @return Nothing
*
* @details Only configures SS pin since stm32duino creates and initialize the SPI object
*/
void spiBegin(void) {
#if !PIN_EXISTS(SS)
#error "SS_PIN not defined!"
#endif
SET_OUTPUT(SS_PIN);
WRITE(SS_PIN, HIGH);
}
void Space::load_motor(uint8_t m, int32_t &addr) { // {{{
loaddebug("loading motor %d", m);
uint16_t enable = motor[m]->enable_pin.write();
double old_home_pos = motor[m]->home_pos;
double old_steps_per_unit = motor[m]->steps_per_unit;
motor[m]->step_pin.read(read_16(addr));
motor[m]->dir_pin.read(read_16(addr));
motor[m]->enable_pin.read(read_16(addr));
motor[m]->limit_min_pin.read(read_16(addr));
motor[m]->limit_max_pin.read(read_16(addr));
motor[m]->sense_pin.read(read_16(addr));
motor[m]->steps_per_unit = read_float(addr);
motor[m]->max_steps = read_8(addr);
motor[m]->home_pos = read_float(addr);
motor[m]->limit_v = read_float(addr);
motor[m]->limit_a = read_float(addr);
motor[m]->home_order = read_8(addr);
arch_motors_change();
SET_OUTPUT(motor[m]->enable_pin);
if (enable != motor[m]->enable_pin.write()) {
if (motors_busy)
SET(motor[m]->enable_pin);
else {
RESET(motor[m]->enable_pin);
}
}
RESET(motor[m]->step_pin);
SET_INPUT(motor[m]->limit_min_pin);
SET_INPUT(motor[m]->limit_max_pin);
SET_INPUT(motor[m]->sense_pin);
bool must_move = false;
if (!isnan(motor[m]->home_pos)) {
// Axes with a limit switch.
if (motors_busy && (old_home_pos != motor[m]->home_pos || old_steps_per_unit != motor[m]->steps_per_unit) && !isnan(old_home_pos)) {
int32_t hp = motor[m]->home_pos * motor[m]->steps_per_unit + (motor[m]->home_pos > 0 ? .49 : -.49);
int32_t ohp = old_home_pos * old_steps_per_unit + (old_home_pos > 0 ? .49 : -.49);
int32_t diff = hp - ohp;
motor[m]->settings.current_pos += diff;
cpdebug(id, m, "load motor new home add %d", diff);
arch_addpos(id, m, diff);
must_move = true;
}
}
else {
// Axes without a limit switch, including extruders.
if (motors_busy && old_steps_per_unit != motor[m]->steps_per_unit) {
int32_t cp = motor[m]->settings.current_pos;
double pos = cp / old_steps_per_unit;
cpdebug(id, m, "load motor new steps no home");
motor[m]->settings.current_pos = pos * motor[m]->steps_per_unit;
int diff = motor[m]->settings.current_pos - cp;
arch_addpos(id, m, diff);
}
}
if (must_move)
move_to_current();
} // }}}
void Space::load_motor(int m) { // {{{
loaddebug("loading motor %d", m);
uint16_t enable = motor[m]->enable_pin.write();
double old_home_pos = motor[m]->home_pos;
double old_steps_per_unit = motor[m]->steps_per_unit;
bool old_dir_invert = motor[m]->dir_pin.inverted();
motor[m]->step_pin.read(shmem->ints[2]);
motor[m]->dir_pin.read(shmem->ints[3]);
motor[m]->enable_pin.read(shmem->ints[4]);
motor[m]->limit_min_pin.read(shmem->ints[5]);
motor[m]->limit_max_pin.read(shmem->ints[6]);
motor[m]->home_order = shmem->ints[7];
motor[m]->steps_per_unit = shmem->floats[0];
if (std::isnan(motor[m]->steps_per_unit)) {
debug("Trying to set NaN steps per unit for motor %d %d", id, m);
motor[m]->steps_per_unit = old_steps_per_unit;
}
motor[m]->home_pos = shmem->floats[1];
motor[m]->limit_v = shmem->floats[2];
motor[m]->limit_a = shmem->floats[3];
arch_motors_change();
SET_OUTPUT(motor[m]->enable_pin);
if (enable != motor[m]->enable_pin.write()) {
if (motors_busy)
SET(motor[m]->enable_pin);
else {
RESET(motor[m]->enable_pin);
}
}
RESET(motor[m]->step_pin);
RESET(motor[m]->dir_pin);
SET_INPUT(motor[m]->limit_min_pin);
SET_INPUT(motor[m]->limit_max_pin);
if (motor[m]->dir_pin.inverted() != old_dir_invert)
arch_invertpos(id, m);
if (!std::isnan(motor[m]->home_pos)) {
// Axes with a limit switch.
if (motors_busy && (old_home_pos != motor[m]->home_pos || old_steps_per_unit != motor[m]->steps_per_unit) && !std::isnan(old_home_pos)) {
double diff = motor[m]->home_pos - old_home_pos * old_steps_per_unit / motor[m]->steps_per_unit;
motor[m]->settings.current_pos += diff;
//debug("load motor %d %d new home %f add %f", id, m, motor[m]->home_pos, diff);
// adjusting the arch pos is not affected by steps/unit.
arch_addpos(id, m, motor[m]->home_pos - old_home_pos);
}
reset_pos(this);
}
else if (!std::isnan(motor[m]->settings.current_pos)) {
// Motors without a limit switch: adjust motor position to match axes.
for (int a = 0; a < num_axes; ++a)
axis[a]->settings.target = axis[a]->settings.current;
space_types[type].xyz2motors(this);
double diff = motor[m]->settings.target_pos - motor[m]->settings.current_pos;
motor[m]->settings.current_pos += diff;
arch_addpos(id, m, diff);
}
} // }}}
/// Set up temp sensors.
void temp_init() {
temp_sensor_t i;
for (i = 0; i < NUM_TEMP_SENSORS; i++) {
switch(temp_sensors[i].temp_type) {
#ifdef TEMP_MAX6675
case TT_MAX6675:
WRITE(SS, 1); // Turn sensor off.
SET_OUTPUT(SS);
// Intentionally no break, we might have more than one sensor type.
#endif
#ifdef TEMP_THERMISTOR
// handled by analog_init()
/* case TT_THERMISTOR:
break;*/
#endif
#ifdef TEMP_AD595
// handled by analog_init()
/* case TT_AD595:
break;*/
#endif
#ifdef TEMP_INTERCOM
case TT_INTERCOM:
// Enable the RS485 transceiver
SET_OUTPUT(RX_ENABLE_PIN);
SET_OUTPUT(TX_ENABLE_PIN);
WRITE(RX_ENABLE_PIN,0);
disable_transmit();
intercom_init();
send_temperature(0, 0);
// Intentionally no break.
#endif
default: /* prevent compiler warning */
break;
}
}
}
void power_on() {
if (ps_is_on == 0) {
#ifdef PS_ON_PIN
WRITE(PS_ON_PIN, 0);
SET_OUTPUT(PS_ON_PIN);
_delay_ms(500);
#endif
ps_is_on = 1;
}
psu_timeout = 0;
}
/// set up temp sensors. Currently only the 'intercom' sensor needs initialisation.
void temp_init() {
temp_sensor_t i;
for (i = 0; i < NUM_TEMP_SENSORS; i++) {
switch(temp_sensors[i].temp_type) {
#ifdef TEMP_MAX6675
// initialised when read
/* case TT_MAX6675:
break;*/
#ifdef NAL_REPRAP
SET_OUTPUT(MAX6675_CS);
SET_OUTPUT(MAX6675_SCK);
SET_INPUT(MAX6675_SO);
#endif
#endif
#ifdef TEMP_THERMISTOR
// handled by analog_init()
/* case TT_THERMISTOR:
break;*/
#endif
#ifdef TEMP_AD595
// handled by analog_init()
/* case TT_AD595:
break;*/
#endif
#ifdef TEMP_INTERCOM
case TT_INTERCOM:
intercom_init();
send_temperature(0, 0);
break;
#endif
default: /* prevent compiler warning */
break;
}
}
}
uint8_t ds18b20_read_bit(){
// synchronize
SET_LOW(DS18B20_PORT, DS18B20_DQ);
SET_OUTPUT(DS18B20_DDR, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
// wait until thermometer puts bit
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
DS18B20_PRECISE_DELAY(5);
// read it
uint8_t ret=IS_HIGH(DS18B20_PIN, DS18B20_DQ);
DS18B20_PRECISE_DELAY(60);
return ret;
}
/** LCD API **/
void lcd_init()
{
lcd_implementation_init();
#ifdef NEWPANEL
SET_INPUT(BTN_EN1);
SET_INPUT(BTN_EN2);
#if (SDCARDDETECT != -1)
SET_INPUT(SDCARDDETECT);
#endif
WRITE(BTN_EN1,HIGH);
WRITE(BTN_EN2,HIGH);
#if BTN_ENC > 0
SET_INPUT(BTN_ENC);
WRITE(BTN_ENC,HIGH);
#endif
#ifdef REPRAPWORLD_KEYPAD
SET_OUTPUT(SHIFT_CLK);
SET_OUTPUT(SHIFT_LD);
SET_INPUT(SHIFT_OUT);
WRITE(SHIFT_OUT,HIGH);
WRITE(SHIFT_LD,HIGH);
#endif
#else
#ifdef SR_LCD_2W_NL
SET_OUTPUT(SR_DATA_PIN);
SET_OUTPUT(SR_CLK_PIN);
#else
SET_OUTPUT(SHIFT_CLK);
SET_OUTPUT(SHIFT_LD);
SET_OUTPUT(SHIFT_EN);
SET_INPUT(SHIFT_OUT);
WRITE(SHIFT_OUT,HIGH);
WRITE(SHIFT_LD,HIGH);
WRITE(SHIFT_EN,LOW);
#endif // SR_LCD_2W_NL
#endif//!NEWPANEL
#if (SDCARDDETECT > 0)
WRITE(SDCARDDETECT, HIGH);
lcd_oldcardstatus = IS_SD_INSERTED;
#endif//(SDCARDDETECT > 0)
#ifdef LCD_HAS_SLOW_BUTTONS
slow_buttons = 0;
#endif
lcd_buttons_update();
#ifdef ULTIPANEL
encoderDiff = 0;
#endif
}
void setup_neopixel() {
SET_OUTPUT(NEOPIXEL_PIN);
pixels.setBrightness(NEOPIXEL_BRIGHTNESS); // 0 - 255 range
pixels.begin();
pixels.show(); // initialize to all off
#if ENABLED(NEOPIXEL_STARTUP_TEST)
safe_delay(1000);
set_neopixel_color(pixels.Color(255, 0, 0, 0)); // red
safe_delay(1000);
set_neopixel_color(pixels.Color(0, 255, 0, 0)); // green
safe_delay(1000);
set_neopixel_color(pixels.Color(0, 0, 255, 0)); // blue
safe_delay(1000);
#endif
set_neopixel_color(pixels.Color(NEO_WHITE)); // white
}
void buzz(long duration, uint16_t freq) {
if (freq > 0) {
#ifdef LCD_USE_I2C_BUZZER
lcd_buzz(duration, freq);
#elif defined(BEEPER) && BEEPER >= 0 // on-board buzzers have no further condition
SET_OUTPUT(BEEPER);
tone(BEEPER, freq);
delay(duration);
noTone(BEEPER);
#else
delay(duration);
#endif
}
else {
delay(duration);
}
}
void ds18b20_write_bit(uint8_t bit){
// synchronize
SET_OUTPUT(DS18B20_DDR, DS18B20_DQ);
SET_LOW(DS18B20_PORT, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
// put bit
if(bit){
SET_HIGH(DS18B20_PORT, DS18B20_DQ);
}
DS18B20_PRECISE_DELAY(60);
// release line
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
SET_LOW(DS18B20_PORT, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
}
CardReader::CardReader()
{
filesize = 0;
sdpos = 0;
sdprinting = false;
cardOK = false;
saving = false;
autostart_atmillis=0;
autostart_stilltocheck=true; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware.
lastnr=0;
//power to SD reader
#if SDPOWER > -1
SET_OUTPUT(SDPOWER);
WRITE(SDPOWER,HIGH);
#endif //SDPOWER
autostart_atmillis=millis()+5000;
}
uint8_t ds18b20_reset(){
// reset pulse
SET_LOW(DS18B20_PORT, DS18B20_DQ);
SET_OUTPUT(DS18B20_DDR,DS18B20_DQ);
DS18B20_PRECISE_DELAY(480);
// presence pulse
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
DS18B20_PRECISE_DELAY(100);
if(IS_HIGH(DS18B20_PIN, DS18B20_DQ)){
return 0; // not present
}
DS18B20_PRECISE_DELAY(380);
if(IS_LOW(DS18B20_PIN, DS18B20_DQ)){
return 0; // not present
}
return 1;
}
SDCard::SDCard()
{
sdmode = false;
sdactive = false;
savetosd = false;
Printer::setAutomount(false);
//power to SD reader
#if SDPOWER > -1
SET_OUTPUT(SDPOWER);
WRITE(SDPOWER,HIGH);
#endif
#define SDCARDDETECT 24
#if defined(SDCARDDETECT) && SDCARDDETECT>-1
SET_INPUT(SDCARDDETECT);
WRITE(SDCARDDETECT,HIGH);
#endif
}
CardReader::CardReader() {
filesize = 0;
sdpos = 0;
sdprinting = false;
cardOK = false;
saving = false;
logging = false;
workDirDepth = 0;
file_subcall_ctr = 0;
memset(workDirParents, 0, sizeof(workDirParents));
autostart_stilltocheck = true; //the SD start is delayed, because otherwise the serial cannot answer fast enough to make contact with the host software.
autostart_index = 0;
//power to SD reader
#if SDPOWER > -1
SET_OUTPUT(SDPOWER);
WRITE(SDPOWER, HIGH);
#endif //SDPOWER
autostart_atmillis = millis() + 5000;
}
TemperatureManager::TemperatureManager()
: Subject<float>()
, m_target_temperature(0)
, m_current_temperature(0)
, m_current_temperature_raw(0)
#ifdef DOGLCD
, m_control()
#endif
, m_blower_control(true)
{
setTargetTemperature(0);
SET_OUTPUT(HEATER_0_PIN);
#ifdef FAN_BLOCK_PIN
pinMode(FAN_BLOCK_PIN, OUTPUT);
digitalWrite(FAN_BLOCK_PIN, LOW);
#endif //FAN_BLOCK_PIN
#ifdef DOGLCD
m_control = new TemperatureControl();
#endif
}
void mcp2515_init(void)
{
// Aktivieren der Pins fuer das SPI Interface
PORT_SPI &= ~((1 << PIN_NUM(P_SCK)) | (1 << PIN_NUM(P_MOSI)));
DDR_SPI |= (1 << PIN_NUM(P_SCK)) | (1 << PIN_NUM(P_MOSI));
SET(MCP2515_CS);
SET_OUTPUT(MCP2515_CS);
// Aktivieren des SPI Master Interfaces
SPCR = (1 << SPE) | (1 << MSTR) | R_SPCR;
SPSR = R_SPSR;
_delay_us(1);
// MCP2515 per Software Reset zuruecksetzten,
// danach ist er automatisch im Konfigurations Modus
RESET(MCP2515_CS);
spi_putc(SPI_RESET);
SET(MCP2515_CS);
// ein bisschen warten bis der MCP2515 sich neu gestartet hat
_delay_ms(0.1);
// Filter usw. setzen
RESET(MCP2515_CS);
spi_putc(SPI_WRITE);
spi_putc(RXF0SIDH);
for (uint8_t i = 0; i < sizeof(mcp2515_register_map); i++) {
spi_putc(pgm_read_byte(&mcp2515_register_map[i]));
}
SET(MCP2515_CS);
// nur Standard IDs, Message Rollover nach Puffer 1
mcp2515_write_register(RXB0CTRL, (0 << RXM1) | (1 << RXM0) | (1 << BUKT));
mcp2515_write_register(RXB1CTRL, (0 << RXM1) | (1 << RXM0));
// MCP2515 zurueck in den normalen Modus versetzten
mcp2515_write_register(CANCTRL, CLKOUT_PRESCALER_);
}
