int main(int argc, char **argv) {
int cansock;
if(argc < 3) {
die("%s can_interface firware_path", argv[0]);
}
log("bootflashd (rev " GIT_REV ") starting up");
cansock = can_create_socket(argv[1]);
if(cansock < 0) {
die("Failed to attach to can interface");
}
const char *firmware_dir = argv[2];
struct can_frame msg;
while(can_receive_frame(cansock, &msg) >= 0) {
if(!(msg.can_id & 1 << 31) || // No extended id
(msg.can_id & 1 << 30))
continue;
if(memcmp(msg.data, "BOOTMAGC", 8))
continue;
uint32_t addr = msg.can_id & CAN_EFF_MASK;
log("Received boot request from %08X", addr);
int local_sock = can_create_socket(argv[1]);
can_set_filter(local_sock, addr);
if(firmware_flash(local_sock, firmware_dir, addr) < 0) {
log("Flashing firmware failed");
goto out;
}
log("Flashing succeeded");
out:
close(local_sock);
}
}
// ----------------------------------------------------------------------------
void usbcan_decode_command(char *str, uint8_t length)
{
uint8_t temp;
if (length == 0)
return;
switch (str[0]) {
case 'S': // set bitrate
// Lawicel has the folowing settings:
// S0 10 kbps
// S1 20 kbps
// S2 50 kbps
// S3 100 kbps
// S4 125 kbps
// S5 250 kbps
// S6 500 kbps
// S7 800 kbps
// S8 1 mbps; is index 7 on USB2CAN
// Note that the USB2CAN adapter does not support 800 kbps.
// With index 7 USB2CAN runs on 1 mbps.
// Report error if the range is wrong, communication channel
// already open, Parameter wrong or the user tries to set
// 800 kbps, which is not supported.
if ( ((temp = str[1] - '0') > 8) || channel_open || length != 2 || temp == 7 ) {
goto error;
} else {
// Take care of different index usage for 1 mbps.
if ( temp == 8 ) {
temp--;
}
// Set new bitrate, remember all MOB are cleared!
can_init(temp);
bitrate_set = true;
}
break;
case 'r': // send frames
case 't':
case 'R':
case 'T':
if ( !channel_open ) {
goto error;
} else {
if ( !usbcan_decode_message(str, length) ) {
goto error;
}
}
break;
case 'M': // Set acceptance code for SJA1000
case 'm': // Set acceptance mask for SJA1000
case 's': // Set BTR0/BTR1 for SJA1000
goto error;
// TODO
break;
case 'O': // Open channel, i.e. connect CAN to output.
if ( channel_open || !bitrate_set ) {
goto error;
} else {
can_set_mode(NORMAL_MODE);
// In case the baudrate changed, re-enable some filters.
can_filter_t filter = {
.mask = 0,
.id = 0,
.flags.extended = 0,
.flags.rtr = 0
};
for (uint8_t i=11; i<15; i++) {
can_set_filter(i, &filter);
}
// Mark the channel as open.
channel_open = true;
}
break;
case 'L': // Open channel, i.e. connect CAN to output in listen only mode.
if ( channel_open || !bitrate_set ) {
goto error;
} else {
can_set_mode(LISTEN_ONLY_MODE);
channel_open = true;
}
break;
case 'C': // Close channel, i.e. disconnect CAN from output.
if ( !channel_open ) {
goto error;
} else {
channel_open = false;
}
break;
case 'F': // read Status Flags
term_put_hex(0);
// TODO
break;
case 'N': // read serial number
term_putc( 'N' );
term_put_hex( 0 );
term_put_hex( 0 );
break;
case 'V': // read hardware and firmeware version
term_putc( 'V' );
term_put_hex( (HARDWARE_VERSION_MAJOR << 4) | HARDWARE_VERSION_MINOR );
term_put_hex( (SOFTWARE_VERSION_MAJOR << 4) | SOFTWARE_VERSION_MINOR );
break;
case 'Z':
// Switch on or off timestamps.
// On Lawicel this value is stored in EEPROM.
if ( channel_open || length != 2) {
goto error;
} else {
use_timestamps = (str[1] - '0' == 0) ? false : true;
CANTIM = 0;
}
break;
}
term_putc('\r'); // command could be executed
return;
error:
term_putc(7); // Error in command
}
// ----------------------------------------------------------------------------
// processes commands in usbcan-protocol mode
void usbcan_handle_protocol(void)
{
static char buffer[40];
static uint8_t pos;
static can_error_register_t last_error = { 0, 0 };
can_error_register_t error;
// check for new messages
if (can_check_message()) {
can_t message;
// Only communicate data if channel is open.
// Due to left -> right evaluation messages are extracted from the
// MOB to avoid overflow, even if no communication is desired.
if ( can_get_message(&message) && channel_open ) {
uint8_t length = message.length;
if (message.flags.rtr)
{
// print identifier
if (message.flags.extended) {
printf_P(PSTR("R%08lx"), message.id);
} else {
uint16_t id = message.id;
printf_P(PSTR("r%03x"), id);
}
term_putc(length + '0');
}
else
{
// print identifier
if (message.flags.extended) {
printf_P(PSTR("T%08lx"), message.id);
} else {
uint16_t id = message.id;
printf_P(PSTR("t%03x"), id);
}
term_putc(length + '0');
// print data
for (uint8_t i = 0; i < length; i++)
term_put_hex(message.data[i]);
}
if (use_timestamps)
printf_P(PSTR("%04x"), message.timestamp);
term_putc('\r');
}
}
// get commands
while (term_data_available())
{
char chr = term_getc();
if (chr != '\r')
{
buffer[pos] = chr;
pos++;
if (pos >= sizeof(buffer)) {
// format-error: command to long!
pos = 0;
}
}
else {
buffer[pos] = '\0';
usbcan_decode_command(buffer, pos);
pos = 0;
}
}
// get error-register
error = can_read_error_register();
if (last_error.tx != error.tx || last_error.rx != error.rx) {
printf_P(PSTR("E%02x%02x\r"), error.rx, error.tx);
last_error = error;
}
}
int main () {
DDRA = 0xFF;
pwm_init();
/** testing ++++++++++++++++++ **/
pwm_set(500, 0);
_delay_ms(2000);
pwm_set(1000, 0);
while(true);
/** ---------------------------- **/
can_init(BITRATE_1_MBPS);
sei();
// motor 1
can_filter_t filter0;
filter0.id = BOARD_ID;
filter0.mask = 0x7FF;
filter0.flags.rtr = 0;
can_set_filter(0, &filter0);
while(42) {
if (can_check_message()) {
//PORTA ^= 0xF0;
can_t message;
can_get_message(&message);
signed short value0;
signed short value1;
if (BOARD_0) {
value0 = message.data[1];
value1 = -message.data[3];
if (message.data[0] == 1) value0 *= -1;
if (message.data[2] == 1) value1 *= -1;
}
else {
//value0 = message.data[5] *= -1;
//value1 = message.data[7] *= -1;
value0 = -message.data[5];
value1 = -message.data[7];
if (message.data[4] == 1) value0 *= -1;
if (message.data[6] == 1) value1 *= -1;
}
long lvalue0 = value0;
long lvalue1 = value1;
lvalue0 += 255;
lvalue0 *= 1000;
lvalue0 /= (2*255);
lvalue1 += 255;
lvalue1 *= 1000;
lvalue1 /= (2*255);
/* pulsing values */
if (abs(value0) < 45) {
if (abs(value0) < 5) {
pwm_set(500, 0);
}
else if (abs(value0) < 13) {
pwm_set_ontime(pwm_lookup[0].ontime, 0);
pwm_set_offtime(pwm_lookup[0].offtime, 0);
pwm_set(value0 < 0 ? 422 : 588, 0); // speed 45
//pwm_set(value0 < 0 ? 250 : 750, 0); // speed 45
}
else {
double dindex = 0.44*abs(value0)-4.9;
unsigned char cindex = (unsigned char)round(dindex)%13;
pwm_set_ontime(pwm_lookup[cindex].ontime, 0);
pwm_set_offtime(pwm_lookup[cindex].offtime, 0);
pwm_set(value0 < 0 ? 422 : 588, 0); // speed 45
//pwm_set(value0 < 0 ? 250 : 750, 0); // speed 45
}
}
else {
pwm_set_ontime(1, 0);
pwm_set_offtime(0, 0);
pwm_set((unsigned long)lvalue0, 0);
}
if (abs(value1) < 45) {
if (abs(value1) < 5) {
pwm_set(500, 1);
}
else if (abs(value1) < 13) {
pwm_set_ontime(pwm_lookup[0].ontime, 1);
pwm_set_offtime(pwm_lookup[0].offtime, 1);
pwm_set(value1 < 0 ? 422 : 588, 1); // speed 45
//pwm_set(value1 < 0 ? 250 : 750, 1); // speed 45
}
else {
double dindex = 0.44*abs(value1)-4.9;
unsigned char cindex = (unsigned char)round(dindex)%13;
pwm_set_ontime(pwm_lookup[cindex].ontime, 1);
pwm_set_offtime(pwm_lookup[cindex].offtime, 1);
pwm_set(value1 < 0 ? 422 : 588, 1); // speed 45
//pwm_set(value1 < 0 ? 250 : 750, 1); // speed 45
}
}
else {
pwm_set_ontime(1, 1);
pwm_set_offtime(0, 1);
pwm_set((unsigned long)lvalue1, 1);
}
//pwm_set((unsigned long)lvalue0, 0);
//pwm_set((unsigned long)lvalue1, 1);
}
}
}
int main () {
uart_init(38400);
// initialisation of the buttons and leds //
DDRE &= ~(0xF0); // buttons as input
PORTE |= 0xF0; // activate internal pull-ups
DDRA |= 0xFF; // leds as output
/** CAN TESTING HERE **/
can_init(BITRATE_1_MBPS);
sei();
// motor 1
can_filter_t filter0;
filter0.id = 9;
//filter0.mask = 0x7FF;
filter0.mask = 0;
filter0.flags.rtr = 0;
can_set_filter(0, &filter0);
PORTA ^= 0x02;
/*while(true) {
if (can_check_message()) {
can_t msg;
can_get_message(&msg);
PORTA ^= 0x01;
}
}*/
PORTA = 0x01;
_delay_ms(1000);
PORTA = 0x02;
int j = 0;
while(true) {
can_t frame;
frame.id = 0x42;
frame.flags.rtr = 0;
frame.length = 8;
for(int i = 0; i < 8; i++) {
frame.data[i] = 42;//j + i;
}
j++;
for (int k = 0; k < 8; k++) {
if (can_send_message(&frame)) {
PORTA &= ~0x0F;
PORTA ^= 0xF0;
}
else {
PORTA |= 0x0F;
}
}
//_delay_ms(1);
_delay_ms(1);
}
while(true) {
if (can_check_message()) {
PORTA ^= 0x03;
/*can_t msg;
can_get_message(&msg);*/
can_t message;
can_get_message(&message);
for (int i = 0; i < 8; i++) {
uart_debug("%d: %d\n\r", i, message.data[i]);
_delay_ms(5);
}
uart_debug("##########################\n\n\r");
}
if (PINE < 0xF0) {
can_t frame;
frame.id = 0x09;
frame.flags.rtr = 0;
frame.length = 2;
frame.data[0] = 0x2A;
frame.data[1] = 0x06;
if (can_send_message(&frame)) {
PORTA &= ~0xE0;
PORTA ^= 0x10;
}
else PORTA = 0xE0;
uart_debug(".\n\r");
_delay_ms(500);
}
}
/** ** ++++++++++ ** **/
return 0;
}
