flywithu/Oleg-Stepanenko-owo_IEBUS
1
0
Fork 0
mirror of https://github.com/Oleg-Stepanenko-owo/IEBUS synced 2025-06-28 10:16:13 +00:00
Code Issues Releases Wiki Activity

Added bluetooth module

Browse Source
This commit is contained in:
OlegStepanenko_noute 2016-03-22 21:25:36 +02:00
parent 033034df6b
commit a4836d69b1
9 changed files with 2517 additions and 753 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
AVCLan_mini/AVCLan_BT.cpp Normal file
View File

@ -0,0 +1,33 @@
//--------------------------------------------------------------------------------
#include "AVCLan_BT.h"
#include <SoftwareSerial.h>
#include <avr/pgmspace.h>
//--------------------------------------------------------------------------------
SoftwareSerial mySerial(4, 3); // RX | TX
//--------------------------------------------------------------------------------
void AVCLanBT::begin()
//--------------------------------------------------------------------------------
{
mySerial.begin(9600);
mySerial.println("BlueTooth is ready");
}
//--------------------------------------------------------------------------------
void AVCLanBT::println( char* val )
//--------------------------------------------------------------------------------
{
mySerial.println( val );
mySerial.println( "\n\r" );
}
//--------------------------------------------------------------------------------
void AVCLanBT::print( const char* val )
//--------------------------------------------------------------------------------
{
mySerial.print( val );
}
AVCLanBT avclanBT;

28
AVCLan_mini/AVCLan_BT.h Normal file
View File

@ -0,0 +1,28 @@
/*
*/
#ifndef AVCLanBT_h
#define AVCLanBT_h
#include <avr/pgmspace.h>
#include "Arduino.h"
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
class AVCLanBT
{
public:
void begin (); // initialisation, obligatory method
void println( char*);
void print(const char*);
private:
};
extern AVCLanBT avclanBT;
#endif

28
AVCLan_mini/AVCLan_mini.ino
View File

@ -1,6 +1,7 @@
#include "AVCLanDrv.h"
#include "AVCLanHonda.h"
#include "AVCLan_BT.h"
#include "config.h"
//--------------------------------------------------------------------------------
@ -11,6 +12,9 @@
#define HONDA_DIS_ON sbi(LED_PORT, COMMUT_OUT);
#define HONDA_DIS_OFF cbi(LED_PORT, COMMUT_OUT);
static int MAX_ERROR_COUNT = 30;
byte errorID;
int error_count;
//--------------------------------------------------------------------------------
void setup()
//--------------------------------------------------------------------------------
@ -20,6 +24,11 @@ void setup()
avclan.begin();
avclanHonda.begin();
errorID = 0;
error_count = 0;
avclanBT.begin();
avclanBT.println("Start HONDA avclan.");
}
//--------------------------------------------------------------------------------
@ -43,10 +52,22 @@ void loop()
if ( INPUT_IS_SET ) {
byte res = avclan.readMessage();
if ( !res ) {
error_count = 0;
avclanHonda.getActionID();
if ( avclan.actionID != ACT_NONE ) {
avclanHonda.processAction( (AvcActionID)avclan.actionID );
}
} else {
if ( errorID == res ) error_count++;
else error_count = 1;
errorID = res;
if ( error_count > MAX_ERROR_COUNT ) {
error_count = 0;
avclanHonda.setHondaDis(true);
}
}
}
@ -60,6 +81,13 @@ void loop()
HONDA_DIS_OFF;
}
}
if ( !error_count && errorID ) {
char BUFFF[15];
sprintf(BUFFF, "Error: %d", errorID);
avclanBT.println( BUFFF );
delay(2000);
}
}

5
AVCLan_mini/config.h
View File

@ -29,10 +29,7 @@
#define LED_DDR DDRC
#define LED_PORT PORTC
#define LED_PIN PINC
//#define LED_OUT 5
// Commutate pin 11
#define COMMUT_OUT 1
#define COMMUT_OUT 0
// AZFM board activate

617
AVC_LAN_logger/AVCLan_mini/AVCLanDrv.cpp
View File

@ -1,12 +1,14 @@
/*
AVCLanDrv.cpp - AVCLan Library for 'duino / Wiring
Created by Kochetkov Aleksey, 04.08.2010
Version 0.3.1
*/
#include "AVCLanDrv.h"
#include "BuffSerial.h"
// AVCLan driver & timer2 init,
// char buff[80] = {0};
//--------------------------------------------------------------------------------
void AVCLanDrv::begin ()
//--------------------------------------------------------------------------------
{
void AVCLanDrv::begin (){
// AVCLan TX+/TX- read line INPUT
cbi(DATAIN_DDR, DATAIN);
#ifdef AVCLAN_ST485
@ -53,17 +55,14 @@ void AVCLanDrv::begin ()
#endif
headAddress = 0x0000;
deviceAddress = 0x0000;
// event = EV_NONE;
event = EV_NONE;
actionID = ACT_NONE;
}
// Reads specified number of bits from the AVCLan.
// nbBits (byte) -> Number of bits to read.
// Return (word) -> Data value read.
//--------------------------------------------------------------------------------
word AVCLanDrv::readBits (byte nbBits)
//--------------------------------------------------------------------------------
{
word AVCLanDrv::readBits (byte nbBits){
word data = 0;
_parityBit = 0;
@ -89,19 +88,12 @@ word AVCLanDrv::readBits (byte nbBits)
}
}
while (INPUT_IS_CLEAR && TCNT2 < AVC_NORMAL_BIT_LENGTH);
// char buff[10] = {0};
// sprintf(buff, "%x", data );
// // bSDLog.logs( buff );
return data;
}
// Read incoming messages on the AVCLan.
// Return 0 if success.
//--------------------------------------------------------------------------------
byte AVCLanDrv::_readMessage ()
//--------------------------------------------------------------------------------
{
// Return true if success.
byte AVCLanDrv::_readMessage (){
uint8_t t = 0;
uint8_t oldSREG = SREG;
cli(); // disable interrupts
@ -214,43 +206,38 @@ byte AVCLanDrv::_readMessage ()
// Read incoming messages on the AVCLan, log message through serial port
// Return true if success.
//--------------------------------------------------------------------------------
byte AVCLanDrv::readMessage ()
//--------------------------------------------------------------------------------
{
byte AVCLanDrv::readMessage (){
byte res = avclan._readMessage();
if (res)
{
if (!res){
avclan.printMessage(true);
}else{
bSerial.print("R");
bSerial.printHex4(res);
bSerial.println();
while (!avclan.isAvcBusFree());
}
return res;
}
// Send a start bit to the AVCLan
////--------------------------------------------------------------------------------
//void AVCLanDrv::sendStartBit ()
////--------------------------------------------------------------------------------
//{
// // Reset timer to measure bit length.
// TCCR2B = 0x03; // prescaler 32
// TCNT2 = 0;
// OUTPUT_SET_1;
//
// // Pulse level high duration.
// while ( TCNT2 < AVC_START_BIT_HOLD_ON_LENGTH );
// OUTPUT_SET_0;
//
// // Pulse level low duration until ~185 us.
// while ( TCNT2 < AVC_START_BIT_LENGTH );
// TCCR2B = 0x02; // prescaler 8
//
//}
void AVCLanDrv::sendStartBit (){
// Reset timer to measure bit length.
TCCR2B=0x03; // prescaler 32
TCNT2 = 0;
OUTPUT_SET_1;
// Pulse level high duration.
while ( TCNT2 < AVC_START_BIT_HOLD_ON_LENGTH );
OUTPUT_SET_0;
// Pulse level low duration until ~185 us.
while ( TCNT2 < AVC_START_BIT_LENGTH );
TCCR2B=0x02; // prescaler 8
}
// Send a 1 bit word to the AVCLan
//--------------------------------------------------------------------------------
void AVCLanDrv::send1BitWord (bool data)
//--------------------------------------------------------------------------------
{
void AVCLanDrv::send1BitWord (bool data){
// Reset timer to measure bit length.
TCNT2 = 0;
OUTPUT_SET_1;
@ -265,102 +252,90 @@ void AVCLanDrv::send1BitWord (bool data)
while (TCNT2 < AVC_NORMAL_BIT_LENGTH);
}
//// Send a 4 bit word to the AVCLan
////--------------------------------------------------------------------------------
//void AVCLanDrv::send4BitWord (byte data)
////--------------------------------------------------------------------------------
//{
// _parityBit = 0;
//
// // Most significant bit out first.
// for ( char nbBits = 0; nbBits < 4; nbBits++ ) {
// // Reset timer to measure bit length.
// TCNT2 = 2;
// OUTPUT_SET_1;
//
// if (data & 0x8) {
// // Adjust parity.
// _parityBit = ! _parityBit;
// while ( TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH );
// } else {
// while ( TCNT2 < AVC_BIT_0_HOLD_ON_LENGTH );
// }
//
// OUTPUT_SET_0;
// // Hold output low until end of bit.
// while ( TCNT2 < AVC_NORMAL_BIT_LENGTH );
//
// // Fetch next bit.
// data <<= 1;
// }
//}
//
//// Send a 8 bit word to the AVCLan
////--------------------------------------------------------------------------------
//void AVCLanDrv::send8BitWord (byte data)
////--------------------------------------------------------------------------------
//{
// _parityBit = 0;
//
// // Most significant bit out first.
// for ( char nbBits = 0; nbBits < 8; nbBits++ ) {
// // Reset timer to measure bit length.
// TCNT2 = 2;
// OUTPUT_SET_1;
//
// if (data & 0x80) {
// // Adjust parity.
// _parityBit = ! _parityBit;
// while ( TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH );
// } else {
// while ( TCNT2 < AVC_BIT_0_HOLD_ON_LENGTH );
// }
//
// OUTPUT_SET_0;
// // Hold output low until end of bit.
// while ( TCNT2 < AVC_NORMAL_BIT_LENGTH );
//
// // Fetch next bit.
// data <<= 1;
// }
//}
//
//// Send a 12 bit word to the AVCLan
////--------------------------------------------------------------------------------
//void AVCLanDrv::send12BitWord (word data)
////--------------------------------------------------------------------------------
//{
// _parityBit = 0;
//
// // Most significant bit out first.
// for ( char nbBits = 0; nbBits < 12; nbBits++ ) {
// // Reset timer to measure bit length.
// TCNT2 = 2;
// OUTPUT_SET_1;
//
// if (data & 0x0800) {
// // Adjust parity.
// _parityBit = ! _parityBit;
// while ( TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH );
// } else {
// while ( TCNT2 < AVC_BIT_0_HOLD_ON_LENGTH );
// }
//
// OUTPUT_SET_0;
// // Hold output low until end of bit.
// while ( TCNT2 < AVC_NORMAL_BIT_LENGTH );
//
// // Fetch next bit.
// data <<= 1;
// }
//}
// Send a 4 bit word to the AVCLan
void AVCLanDrv::send4BitWord (byte data){
_parityBit = 0;
// Most significant bit out first.
for ( char nbBits = 0; nbBits < 4; nbBits++ ){
// Reset timer to measure bit length.
TCNT2 = 2;
OUTPUT_SET_1;
if (data & 0x8){
// Adjust parity.
_parityBit = ! _parityBit;
while ( TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH );
}else{
while ( TCNT2 < AVC_BIT_0_HOLD_ON_LENGTH );
}
OUTPUT_SET_0;
// Hold output low until end of bit.
while ( TCNT2 < AVC_NORMAL_BIT_LENGTH );
// Fetch next bit.
data <<= 1;
}
}
// Send a 8 bit word to the AVCLan
void AVCLanDrv::send8BitWord (byte data){
_parityBit = 0;
// Most significant bit out first.
for ( char nbBits = 0; nbBits < 8; nbBits++ ){
// Reset timer to measure bit length.
TCNT2 = 2;
OUTPUT_SET_1;
if (data & 0x80){
// Adjust parity.
_parityBit = ! _parityBit;
while ( TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH );
}else{
while ( TCNT2 < AVC_BIT_0_HOLD_ON_LENGTH );
}
OUTPUT_SET_0;
// Hold output low until end of bit.
while ( TCNT2 < AVC_NORMAL_BIT_LENGTH );
// Fetch next bit.
data <<= 1;
}
}
// Send a 12 bit word to the AVCLan
void AVCLanDrv::send12BitWord (word data){
_parityBit = 0;
// Most significant bit out first.
for ( char nbBits = 0; nbBits < 12; nbBits++ ){
// Reset timer to measure bit length.
TCNT2 = 2;
OUTPUT_SET_1;
if (data & 0x0800){
// Adjust parity.
_parityBit = ! _parityBit;
while ( TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH );
}else{
while ( TCNT2 < AVC_BIT_0_HOLD_ON_LENGTH );
}
OUTPUT_SET_0;
// Hold output low until end of bit.
while ( TCNT2 < AVC_NORMAL_BIT_LENGTH );
// Fetch next bit.
data <<= 1;
}
}
// determine whether the bus is free (no tx/rx).
// return TRUE is bus is free.
//--------------------------------------------------------------------------------
bool AVCLanDrv::isAvcBusFree (void)
//--------------------------------------------------------------------------------
{
bool AVCLanDrv::isAvcBusFree (void){
// Reset timer.
TCNT2 = 0;
@ -374,159 +349,140 @@ bool AVCLanDrv::isAvcBusFree (void)
return false;
}
//// reads the acknowledge bit the AVCLan
//// return TRUE if ack detected else FALSE.
////--------------------------------------------------------------------------------
//bool AVCLanDrv::readAcknowledge (void)
////--------------------------------------------------------------------------------
//{
// // The acknowledge pattern is very tricky: the sender shall drive the bus for the equivalent
// // of a bit '1' (20 us) then release the bus and listen. At this point the target shall have
// // taken over the bus maintaining the pulse until the equivalent of a bit '0' (32 us) is formed.
//
// // Reset timer to measure bit length.
// TCNT2 = 0;
// OUTPUT_SET_1;
//
// // Generate bit '0'.
// while (TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH);
// OUTPUT_SET_0;
//
// AVC_OUT_DIS;
//
// while (TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH + AVC_1U_LENGTH);
// // Measure final resulting bit.
// while ( INPUT_IS_SET );
//
// // Sample half-way through bit '0' (26 us) to detect whether the target is acknowledging.
// if (TCNT2 > AVC_BIT_0_HOLD_ON_MIN_LENGTH) {
// // Slave is acknowledging (ack = 0). Wait until end of ack bit.
// while (INPUT_IS_SET );
// AVC_OUT_EN;
// return true;
// }
//
// // No sign of life on the bus.
// return false;
//}
//
//// sends ack bit if I am broadcasting otherwise wait and return received ack bit.
//// return FALSE if ack bit not detected.
////--------------------------------------------------------------------------------
//bool AVCLanDrv::handleAcknowledge (void)
////--------------------------------------------------------------------------------
//{
// if (broadcast == AVC_MSG_BROADCAST) {
// // Acknowledge.
// send1BitWord(0);
// return true;
// }
//
// // Return acknowledge bit.
// return readAcknowledge();
//}
//
//// sends the message in global registers on the AVC LAN bus.
//// return 0 if successful else error code
////--------------------------------------------------------------------------------
//byte AVCLanDrv::_sendMessage (void)
////--------------------------------------------------------------------------------
//{
// uint8_t oldSREG = SREG;
// cli(); // disable interrupts
// while (!isAvcBusFree());
//
// AVC_OUT_EN;
//
// // Send start bit.
// sendStartBit();
//
// // Broadcast bit.
// send1BitWord(broadcast);
//
// // Master address = me.
// send12BitWord(masterAddress);
// send1BitWord(_parityBit);
//
// // Slave address = head unit (HU).
// send12BitWord(slaveAddress);
// send1BitWord(_parityBit);
// if (!handleAcknowledge()) {
// AVC_OUT_DIS;
// SREG = oldSREG;
// return 1;
// }
//
// // Control flag + parity.
// send4BitWord(AVC_CONTROL_FLAGS);
// send1BitWord(_parityBit);
// if (!handleAcknowledge()) {
// AVC_OUT_DIS;
// SREG = oldSREG;
// return 2;
// }
//
// // Data length + parity.
// send8BitWord(dataSize);
// send1BitWord(_parityBit);
// if (!handleAcknowledge()) {
// AVC_OUT_DIS;
// SREG = oldSREG;
// return 3;
// }
//
// for (byte i = 0; i < dataSize; i++) {
// send8BitWord(message[i]);
// send1BitWord(_parityBit);
// if (!handleAcknowledge()) {
// AVC_OUT_DIS;
// SREG = oldSREG;
// return false;
// }
// }
// AVC_OUT_DIS;
// SREG = oldSREG;
// return 0;
//}
//
// reads the acknowledge bit the AVCLan
// return TRUE if ack detected else FALSE.
bool AVCLanDrv::readAcknowledge (void){
// The acknowledge pattern is very tricky: the sender shall drive the bus for the equivalent
// of a bit '1' (20 us) then release the bus and listen. At this point the target shall have
// taken over the bus maintaining the pulse until the equivalent of a bit '0' (32 us) is formed.
// Reset timer to measure bit length.
TCNT2 = 0;
OUTPUT_SET_1;
// Generate bit '0'.
while (TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH);
OUTPUT_SET_0;
AVC_OUT_DIS;
while (TCNT2 < AVC_BIT_1_HOLD_ON_LENGTH + AVC_1U_LENGTH);
// Measure final resulting bit.
while ( INPUT_IS_SET );
// Sample half-way through bit '0' (26 us) to detect whether the target is acknowledging.
if (TCNT2 > AVC_BIT_0_HOLD_ON_MIN_LENGTH){
// Slave is acknowledging (ack = 0). Wait until end of ack bit.
while (INPUT_IS_SET );
AVC_OUT_EN;
return true;
}
// No sign of life on the bus.
return false;
}
// sends ack bit if I am broadcasting otherwise wait and return received ack bit.
// return FALSE if ack bit not detected.
bool AVCLanDrv::handleAcknowledge (void){
if (broadcast == AVC_MSG_BROADCAST){
// Acknowledge.
send1BitWord(0);
return true;
}
// Return acknowledge bit.
return readAcknowledge();
}
// sends the message in global registers on the AVC LAN bus.
// return 0 if successful else error code
byte AVCLanDrv::_sendMessage (void){
uint8_t oldSREG = SREG;
cli(); // disable interrupts
while (!isAvcBusFree());
AVC_OUT_EN;
// Send start bit.
sendStartBit();
// Broadcast bit.
send1BitWord(broadcast);
// Master address = me.
send12BitWord(masterAddress);
send1BitWord(_parityBit);
// Slave address = head unit (HU).
send12BitWord(slaveAddress);
send1BitWord(_parityBit);
if (!handleAcknowledge()){
AVC_OUT_DIS;
SREG = oldSREG;
return 1;
}
// Control flag + parity.
send4BitWord(AVC_CONTROL_FLAGS);
send1BitWord(_parityBit);
if (!handleAcknowledge()){
AVC_OUT_DIS;
SREG = oldSREG;
return 2;
}
// Data length + parity.
send8BitWord(dataSize);
send1BitWord(_parityBit);
if (!handleAcknowledge()){
AVC_OUT_DIS;
SREG = oldSREG;
return 3;
}
for (byte i = 0; i < dataSize; i++){
send8BitWord(message[i]);
send1BitWord(_parityBit);
if (!handleAcknowledge()){
AVC_OUT_DIS;
SREG = oldSREG;
return false;
}
}
AVC_OUT_DIS;
SREG = oldSREG;
return 0;
}
// sends the message in global registers on the AVC LAN bus, log message through serial port
// return 0 if successful else error code
////--------------------------------------------------------------------------------
//byte AVCLanDrv::sendMessage (void)
////--------------------------------------------------------------------------------
//{
// byte sc = MAXSENDATTEMP;
// byte res;
// do {
// res = avclan._sendMessage();
// if (!res) {
// avclan.printMessage(false);
// } else {
// // bSerial.print("W");
// // bSerial.printHex4(res);
// // bSerial.println();
// while (!avclan.isAvcBusFree());
// }
// sc--;
// } while (sc && res);
// return res;
//}
//
byte AVCLanDrv::sendMessage (void){
byte sc = MAXSENDATTEMP;
byte res;
do{
res = avclan._sendMessage();
if (!res){
avclan.printMessage(false);
}else{
bSerial.print("W");
bSerial.printHex4(res);
bSerial.println();
while (!avclan.isAvcBusFree());
}
sc--;
}while (sc && res);
return res;
}
// sends the message for given mesage ID on the AVC LAN bus, log message through serial port
// return 0 if successful else error code
////--------------------------------------------------------------------------------
//byte AVCLanDrv::sendMessage (const AvcOutMessage *msg)
////--------------------------------------------------------------------------------
//{
// loadMessage(msg);
// return sendMessage();
//}
byte AVCLanDrv::sendMessage (AvcOutMessage *msg){
loadMessage(msg);
return sendMessage();
}
// print message to serial port
//--------------------------------------------------------------------------------
void AVCLanDrv::printMessage(bool incoming)
//--------------------------------------------------------------------------------
{
void AVCLanDrv::printMessage(bool incoming){
if (incoming){
bSerial.print("< ");
}else{
@ -550,29 +506,74 @@ void AVCLanDrv::printMessage(bool incoming)
bSerial.printHex8(message[i]);
}
bSerial.println();
}
// Use the last received message to determine the corresponding action ID
byte AVCLanDrv::getActionID(AvcInMessageTable messageTable[], byte mtSize){
if (slaveAddress != deviceAddress && slaveAddress != 0x0FFF) return ACT_NONE;
for (byte msg = 0; msg < mtSize; msg++){
bool found = true;
if (dataSize != pgm_read_byte_near(&messageTable[msg].dataSize)){
continue;
}
for (byte i = 0; i < dataSize; i++){
if (message[i] != pgm_read_byte_near(&messageTable[msg].data[i])){
found = false;
break;
}
}
if (found){
return pgm_read_byte_near(&messageTable[msg].actionID);
}
}
return ACT_NONE;
}
// Use the last received message to determine the corresponding action ID, use masked message table
byte AVCLanDrv::getActionID(AvcInMaskedMessageTable messageTable[], byte mtSize){
if (slaveAddress != deviceAddress && slaveAddress != 0x0FFF) return ACT_NONE;
for (byte msg = 0; msg < mtSize; msg++){
bool found = true;
if (dataSize != pgm_read_byte_near(&messageTable[msg].dataSize)){
continue;
}
word mask = pgm_read_byte_near(&messageTable[msg].mask);
for (byte i = 0; i < dataSize; i++){
if (mask & _BV(i)) continue;
if (message[i] != pgm_read_byte_near(&messageTable[msg].data[i])){
found = false;
break;
}
}
if (found){
return pgm_read_byte_near(&messageTable[msg].actionID);
}
}
return ACT_NONE;
}
// Loads message data for given mesage ID.
////--------------------------------------------------------------------------------
//void AVCLanDrv::loadMessage(const AvcOutMessage *msg)
////--------------------------------------------------------------------------------
//{
// broadcast = pgm_read_byte_near(&msg->broadcast);
// masterAddress = deviceAddress;
//
// if (broadcast == AVC_MSG_BROADCAST)
// slaveAddress = 0x01FF;
// else
// slaveAddress = headAddress;
//
// dataSize = pgm_read_byte_near( &msg->dataSize );
//
// for (byte i = 0; i < dataSize; i++ ) {
// message[i] = pgm_read_byte_near( &msg->data[i] );
// }
//}
void AVCLanDrv::loadMessage(AvcOutMessage *msg){
broadcast = pgm_read_byte_near(&msg->broadcast);
masterAddress = deviceAddress;
if (broadcast == AVC_MSG_BROADCAST)
slaveAddress = 0x01FF;
else
slaveAddress = headAddress;
dataSize = pgm_read_byte_near( &msg->dataSize );
for (byte i = 0; i < dataSize; i++ ){
message[i] = pgm_read_byte_near( &msg->data[i] );
}
};
AVCLanDrv avclan;

70
AVC_LAN_logger/AVCLan_mini/AVCLanDrv.h
View File

@ -61,39 +61,29 @@ typedef enum
} AvcTransmissionMode;
#define ACT_NONE 0 // no action
//#define EV_NONE 0 // no event
//typedef struct
//{
// byte actionID; // Action id
// byte dataSize; // message size (bytes)
// byte prefixSize; // prefix size
// byte prefix[6]; // prefix command (const value)
// byte commandSize; // prefix size
// byte command[4]; // message
//} AvcInMessageTable;
#define EV_NONE 0 // no event
typedef struct
{
byte actionID; // Action id
byte dataSize; // message size (bytes)
byte command; // message
} AvcInCmdTable;
byte data[12]; // message
} AvcInMessageTable;
//typedef struct
//{
// byte actionID; // Action id
// byte dataSize; // message size (bytes)
// byte data[14]; // message
// word mask; // mask, set bit = 1 in not checked position (1<<5 or _BV(5) - datap[5] not checked)
//} AvcInMaskedMessageTable;
typedef struct
{
byte actionID; // Action id
byte dataSize; // message size (bytes)
byte data[14]; // message
word mask; // mask, set bit = 1 in not checked position (1<<5 or _BV(5) - datap[5] not checked)
} AvcInMaskedMessageTable;
//typedef struct
//{
// AvcTransmissionMode broadcast; // Transmission mode: normal (1) or broadcast (0).
// byte dataSize; // message size (bytes)
// byte data[14]; // message
//} AvcOutMessage;
typedef struct
{
AvcTransmissionMode broadcast; // Transmission mode: normal (1) or broadcast (0).
byte dataSize; // message size (bytes)
byte data[14]; // message
} AvcOutMessage;
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
@ -111,33 +101,31 @@ class AVCLanDrv {
word headAddress;
byte dataSize;
byte message[AVC_MAXMSGLEN];
// byte event;
byte event;
byte actionID;
bool readonly;
void begin ();
byte readMessage (void);
// byte sendMessage (void);
// byte sendMessage (const AvcOutMessage*);
byte sendMessage (void);
byte sendMessage (AvcOutMessage*);
void printMessage (bool incoming);
bool isAvcBusFree (void);
// byte getActionID (const AvcInMaskedMessageTable messageTable[], byte mtSize);
// void loadMessage (const AvcOutMessage*);
byte getActionID (AvcInMessageTable messageTable[], byte mtSize);
byte getActionID (AvcInMaskedMessageTable messageTable[], byte mtSize);
void loadMessage (AvcOutMessage*);
private:
bool _parityBit;
word readBits (byte nbBits);
byte _readMessage (void);
// byte _sendMessage (void);
// void sendStartBit (void);
byte _sendMessage (void);
void sendStartBit (void);
void send1BitWord (bool data);
// void send4BitWord (byte data);
// void send8BitWord (byte data);
// void send12BitWord (word data);
// bool readAcknowledge (void);
// bool handleAcknowledge (void);
void send4BitWord (byte data);
void send8BitWord (byte data);
void send12BitWord (word data);
bool readAcknowledge (void);
bool handleAcknowledge (void);
};
extern AVCLanDrv avclan;
#endif

85
AVC_LAN_logger/AVCLan_mini/BuffSerial.cpp
View File

@ -1,17 +1,14 @@
/*
BuffSerial.cpp v.01 - serial with transmit buffer library for Wiring
Created by Kochetkov Aleksey, 03.07.2009
BuffSerial.cpp - serial with transmit buffer library for Wiring
Created by Kochetkov Aleksey, 28.11.2009
Version 0.1.2
*/
//--------------------------------------------------------------------------------
#include <stdio.h>
#include "BuffSerial.h"
//--------------------------------------------------------------------------------
// serial init
//--------------------------------------------------------------------------------
void BuffSerial::begin(long speed)
{
//--------------------------------------------------------------------------------
void BuffSerial::begin(long speed){
#if defined(__AVR_ATmega8__)
UCSRB = _BV(RXCIE) | _BV(RXEN) | _BV(TXCIE) | _BV(TXEN); // enable rx, tx inerrputs
UBRRH = ((F_CPU / 16 + speed / 2) / speed - 1) >> 8; // usart speed
@ -26,7 +23,6 @@ void BuffSerial::begin(long speed)
txFull = 0;
}
//--------------------------------------------------------------------------------
//USART Rx Complete
#if defined(__AVR_ATmega8__)
SIGNAL(SIG_UART_RECV)
@ -41,9 +37,7 @@ SIGNAL(USART_RX_vect)
#endif
if (bSerial.rxEnd < RX_BUFF_SIZE) bSerial.rxEnd++;
}
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
//USART Tx Complete
#if defined(__AVR_ATmega8__)
SIGNAL(SIG_UART_TRANS)
@ -63,13 +57,9 @@ SIGNAL(USART_TX_vect)
}
}
//--------------------------------------------------------------------------------
// send byte to serial or buffer if bisy
//--------------------------------------------------------------------------------
void BuffSerial::sendByte(uint8_t data)
//--------------------------------------------------------------------------------
{
void BuffSerial::sendByte(uint8_t data){
if (txFull){
txOverflow++;
}else{
@ -96,66 +86,55 @@ void BuffSerial::sendByte(uint8_t data)
}
// print string
//--------------------------------------------------------------------------------
void BuffSerial::print(const char *pBuf)
//--------------------------------------------------------------------------------
{
void BuffSerial::print(const char *pBuf){
while (*pBuf) {
sendByte(*pBuf++);
}
}
//--------------------------------------------------------------------------------
void BuffSerial::print(const char pBuf)
//--------------------------------------------------------------------------------
{
void BuffSerial::print(const char pBuf){
sendByte(pBuf);
}
//--------------------------------------------------------------------------------
void BuffSerial::println(const char *pBuf)
//--------------------------------------------------------------------------------
{
// print string from flash
void BuffSerial::print_p(const char *pBuf){
char c;
while ((c = pgm_read_byte_near( pBuf++ ))) {
sendByte(c);
}
}
void BuffSerial::println(const char *pBuf){
print(pBuf);
println();
}
//--------------------------------------------------------------------------------
void BuffSerial::println(const char pBuf)
//--------------------------------------------------------------------------------
{
void BuffSerial::println(const char pBuf){
print(pBuf);
println();
}
//--------------------------------------------------------------------------------
void BuffSerial::println(void)
//--------------------------------------------------------------------------------
{
void BuffSerial::println(void){
print("\r\n");
}
//--------------------------------------------------------------------------------
void BuffSerial::printHex4(uint8_t data)
//--------------------------------------------------------------------------------
{
void BuffSerial::println_p(const char *pBuf){
print_p(pBuf);
println();
}
void BuffSerial::printHex4(uint8_t data){
uint8_t c = data & 0x0f;
c += c < 10 ? '0' : 'A' - 10 ;
sendByte(c);
}
//--------------------------------------------------------------------------------
void BuffSerial::printHex8(uint8_t data)
//--------------------------------------------------------------------------------
{
void BuffSerial::printHex8(uint8_t data){
printHex4(data >> 4);
printHex4(data);
}
//--------------------------------------------------------------------------------
void BuffSerial::printDec(uint8_t data)
//--------------------------------------------------------------------------------
{
void BuffSerial::printDec(uint8_t data){
uint8_t buf[3];
uint8_t i = 0;
if (data == 0){
@ -172,17 +151,11 @@ void BuffSerial::printDec(uint8_t data)
}
// check rx buffer not empty
//--------------------------------------------------------------------------------
bool BuffSerial::rxEnabled(void)
//--------------------------------------------------------------------------------
{
bool BuffSerial::rxEnabled(void){
return rxEnd;
}
//--------------------------------------------------------------------------------
uint8_t BuffSerial::rxRead(void)
//--------------------------------------------------------------------------------
{
uint8_t BuffSerial::rxRead(void){
#if defined(__AVR_ATmega8__)
cbi(UCSRB, RXCIE); // disable RX complete interrupt
#else

9
AVC_LAN_logger/AVCLan_mini/BuffSerial.h
View File

@ -1,7 +1,9 @@
/*
BuffSerial.h v.01 - serial with transmit buffer library for Wiring
Created by Kochetkov Aleksey, 03.07.2009
BuffSerial.h - serial with transmit buffer library for Wiring
Created by Kochetkov Aleksey, 28.11.2009
Version 0.1.2
*/
#include <avr/pgmspace.h>
#ifndef BuffSerial_h
#define BuffSerial_h
@ -11,6 +13,7 @@
#define TX_BUFF_SIZE 240 // max 65535
#define RX_BUFF_SIZE 25 // max 255
#define TX_BUFF_MAX_LEN TX_BUFF_SIZE - 1
#define BUFFSERIAL_VERSION "0.1.2"
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
@ -33,9 +36,11 @@ class BuffSerial {
void sendByte(uint8_t);
void print(const char*);
void print(const char);
void print_p(const char*);
void println(const char*);
void println(const char);
void println(void);
void println_p(const char*);
void printHex4(uint8_t);
void printHex8(uint8_t);
void printDec(uint8_t);

1711
logs/teraterm_parse.log Normal file
View File

File diff suppressed because it is too large Load Diff