/*------------------------------------------------------------------------------------*/
void pv_cmdRdMCP(void)
{
// read mcp 0|1|2 addr
// mcpDevide: argv[2]
// devAddress: argv[3]
s08 retS = FALSE;
u08 regValue;
switch( atoi(argv[2] )) {
case 0:
retS = MCP_read( MCP0_ADDR, atoi(argv[3]), ®Value );
break;
case 1:
retS = MCP_read( MCP1_ADDR, atoi(argv[3]), ®Value );
break;
}
if (retS ) {
snprintf_P( cmd_printfBuff,sizeof(cmd_printfBuff),PSTR("OK\r\n[reg 0X%03x]=[0X%03x]\r\n\0"),atoi(argv[3]),regValue);
} else {
snprintf_P( cmd_printfBuff,sizeof(cmd_printfBuff),PSTR("ERROR\r\n\0"));
}
FreeRTOS_write( &pdUART1, cmd_printfBuff, sizeof(cmd_printfBuff) );
return;
}
int CAN_readID(int buffer)
{
char a = MCP_read(RXB0SIDH + 16*buffer);
char b = MCP_read(RXB0SIDL + 16*buffer);
int cid=((int)b>>5);
cid =cid+ ((int)a<<3);
return cid;
}
//------------------------------------------------------------------------------------
void pvMCP_checkConfiguration(void)
{
s08 retS = FALSE;
u08 regValue;
// Si estoy aqui es porque algo fallo. Verifico la configuracion del MCP
retS = MCP_read( MCP1_ADDR, 0x01, ®Value );
if ( !retS ) {
// No pude leer el MCP. Asumo un problema en el bus.
// Deshabilito la interfase TWI. La proxima lectura la voy a habilitar y veremos
// si esto soluciona el problema.
TWCR &= ~(1 << TWEN);
snprintf_P( debug_printfBuff,sizeof(debug_printfBuff),PSTR("**DEBUG::pvMCP I2C BUS ERROR !! Disable interface...\r\n\0"));
u_debugPrint(D_DEBUG, debug_printfBuff, sizeof(debug_printfBuff) );
return;
}
// El bus I2C anda bien y el problema esta en el ADC o en el MCP
if ( regValue != 0x64) {
// El MCP esta desconfigurado: Lo reprogramo
snprintf_P( debug_printfBuff,sizeof(debug_printfBuff),PSTR("**DEBUG::pvMCP MCP ERROR !! Reconfigure...\r\n\0"));
u_debugPrint(D_DEBUG, debug_printfBuff, sizeof(debug_printfBuff) );
pvMCP_init_MCP1(1);
taskYIELD();
}
}
void CAN_modeSelect(int mode)
{
MCP_bitModify(CANCTRL,0b11100000, mode);
while((MCP_read(CANCTRL) & 0b11100000)^mode); // waiting for CAN to have entered correct mode
printf("mode selected \n\r");
}
//------------------------------------------------------------------------------------
s08 MCP_queryDin1( u08 *pin)
{
s08 retS;
u08 regValue;
retS = MCP_read( MCP1_ADDR, MCP1_GPIOB, ®Value);
*pin = ( regValue & 0x20) >> 5;
return(retS);
}
//------------------------------------------------------------------------------------
s08 MCP_query2Din( u08 *din0, u08 *din1 )
{
s08 retS;
u08 regValue;
retS = MCP_read( MCP1_ADDR, MCP1_GPIOB, ®Value);
*din0 = ( regValue & 0x40) >> 6;
*din1 = ( regValue & 0x20) >> 5;
return(retS);
}
// DCD es el bit1, mask = 0x02
// retS = MCP_read( MCP0_ADDR, MCP0_GPIO, ®Value);
// *pin = ( regValue & 0x02) >> 1;
//*pin = ( regValue & _BV(1) ) >> 1; // bit1, mask = 0x02
// return(retS);
//}
//------------------------------------------------------------------------------------
s08 MCP_queryRi( u08 *pin)
{
// MCP23008 logic
s08 retS;
u08 regValue;
// RI es el bit2, mask = 0x04
retS = MCP_read( MCP0_ADDR, MCP0_GPIO, ®Value);
*pin = ( regValue & 0x04) >> 2;
//*pin = ( regValue & _BV(2) ) >> 1; // bit2, mask = 0x04
return(retS);
}
int CAN_recieve(int * dataByte, int * data)
{
int buffer = 0;
while((MCP_read(CANINTF) & (1<<(RX0IF + buffer))) == 0) // wait untill the interupt flag in the buffer is one
buffer = (buffer+1) %2 ;
int cid= CAN_readID(buffer);
*dataByte = (MCP_read(RXB0DLC + 16*buffer)&0b1111);
for(int i = 0; i < *dataByte; i++)
{
data[i] = MCP_read(RXB0D0 + 16*buffer + i);
}
return cid;
}
int MCP_init(){
//Start SPI driver
SPI_init();
//Reset MPC to enter configuration mode
MCP_reset();
// Self-test
uint8_t value = MCP_read(MCP_CANSTAT);
if ((value & MODE_MASK) != MODE_CONFIG) {
return 1;
}
return 0;
}
void CAN_send(uint16_t cid, int dataByte, int* data)
{
int buffer = 0;
if(buffer < 0 || buffer > 2)
{
printf("Transmit buffer, %u, does not exist\n\r", buffer);
return;
}
// wait for the TXBnCTRL.TXREQ to be cleared
while((MCP_read(TXB0CTRL + 16*buffer) & (1<<TXREQ)));
CAN_setID(buffer, cid);
CAN_setData(buffer, dataByte, data);
MCP_RTS(1<<buffer);
}
/*------------------------------------------------------------------------------
* Main Program
*----------------------------------------------------------------------------*/
int main(void) {
uartInit(12); /* baudrate 38400 */
sei();
MCP_init();
uartPutString("MCP2515 CAN Test\n");
/* request configuration mode */
MCP_WRITE_B(CANCTRL, CANCTRL_REQOP, REQOP_CONFIG);
/* configure SJW and Tq duration */
MCP_WRITE_B(CNF1, CNF1_SJW, 4-1); /* SJW = X-1 [Tq] */
MCP_WRITE_B(CNF1, CNF1_BRP, 0); /* Tq = 2*(X+1)/FOSC [s] */
/* configure phase seg1 and propseg */
MCP_WRITE_B(CNF2, CNF2_BTLMODE, 1);
MCP_WRITE_B(CNF2, CNF2_SAM, 1);
MCP_WRITE_B(CNF2, CNF2_PHSEG1, 4-1); /* PHSEG1 = X-1 [Tq] */
MCP_WRITE_B(CNF2, CNF2_PRSEG, 4-1); /* PRSEG = X-1 [Tq] */
/* configure phase seg2 and wakeup filter */
MCP_WRITE_B(CNF3, CNF3_WAKFIL, 1);
MCP_WRITE_B(CNF3, CNF3_PHSEG2, 4-1); /* PHSEG2 = X-1 [Tq] */
/* configure interrupts */
MCP_WRITE_R(CANINTE, 0);
// Mark all filter bits as don't care:
mcp_write_can_id(RXMnSIDH(0), 1, 0);
mcp_write_can_id(RXMnSIDH(1), 1, 0);
// Anyway, set all filters to 0:
mcp_write_can_id(RXF0SIDH, 0, 0);
mcp_write_can_id(RXF1SIDH, 0, 0);
mcp_write_can_id(RXF2SIDH, 0, 0);
mcp_write_can_id(RXF3SIDH, 0, 0);
mcp_write_can_id(RXF4SIDH, 0, 0);
mcp_write_can_id(RXF5SIDH, 0, 0);
/* request loopback mode */
MCP_WRITE_B(CANCTRL, CANCTRL_REQOP, REQOP_LOOPBACK);
uint8_t tmp = MCP_read(CANCTRL);
uartPutString("CANCTRL = ");
uartPutUInt8(tmp, 2);
uartPutString("\n");
tmp = MCP_read(CANSTAT);
uartPutString("CANSTAT = ");
uartPutUInt8(tmp, 2);
uartPutString("\n");
tmp = MCP_read(CNF1);
uartPutString("CNF1 = ");
uartPutUInt8(tmp, 2);
uartPutString("\n");
tmp = MCP_read(CNF2);
uartPutString("CNF2 = ");
uartPutUInt8(tmp, 2);
uartPutString("\n");
tmp = MCP_read(CNF3);
uartPutString("CNF3 = ");
uartPutUInt8(tmp, 2);
uartPutString("\n");
tmp = MCP_read(CANINTE);
uartPutString("CANINTE = ");
uartPutUInt8(tmp, 2);
uartPutString("\n");
/* main loop */
while(1) {
/* do nothing */
}
}
void sp5K_readFunction(void)
{
u08 devId, address, regValue, pin, channel, pcbChannel, adcChannel;
u08 length = 10;
s08 retS;
u08 mcp_address;
RtcTimeType rtcDateTime;
u08 i;
u16 adcRetValue;
char eeRdBuffer[EERDBUFLENGHT];
u16 eeAddress;
u08 pos;
frameDataType rdFrame;
u16 recCount;
double I,M,D;
u08 bdGetStatus;
u16 rcdIndex;
u08 b[9];
memset( cmd_printfBuff, NULL, CHAR128);
makeargv();
// RTC
// Lee la hora del RTC.
if (!strcmp_P( strupr(argv[1]), PSTR("RTC\0"))) {
retS = rtcGetTime(&rtcDateTime);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d/%02d/%04d "),rtcDateTime.day,rtcDateTime.month, rtcDateTime.year );
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d:%02d:%02d\r\n\0"),rtcDateTime.hour,rtcDateTime.min, rtcDateTime.sec );
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DCD
if (!strcmp_P( strupr(argv[1]), PSTR("DCD\0"))) {
retS = MCP_queryDcd(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// RI
if (!strcmp_P( strupr(argv[1]), PSTR("RI\0"))) {
retS = MCP_queryRi(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN0
if (!strcmp_P( strupr(argv[1]), PSTR("DIN0\0"))) {
retS = MCP_queryDin0(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN0 %d\r\n\0"), pin);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN1
if (!strcmp_P( strupr(argv[1]), PSTR("DIN1\0"))) {
retS = MCP_queryDin1(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN1 %d\r\n\0"), pin);
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(cmd_printfBuff);
return;
}
// TERMSW
if (!strcmp_P( strupr(argv[1]), PSTR("TERMSW\0"))) {
retS = MCP_queryTermPwrSw(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW OFF\r\n\0")); }
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MCP
// read mcp 0|1|2 addr
if (!strcmp_P( strupr(argv[1]), PSTR("MCP\0"))) {
devId = atoi(argv[2]);
address = atoi(argv[3]);
if ( devId == 0 ) { mcp_address = MCP_ADDR0; }
if ( devId == 1 ) { mcp_address = MCP_ADDR1; }
if ( devId == 2 ) { mcp_address = MCP_ADDR2; }
retS = MCP_read( address, mcp_address, 1, ®Value);
if (retS ) {
// Convierto el resultado a binario.
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
strcpy(b,byte_to_binary(regValue));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("mcp %d: reg=[%d] data=[0X%03x] [%s] \r\n\0"),devId, address,regValue, b);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// *****************************************************************************************************
// SOLO PARA USO EN MODO SERVICE.
if ( systemVars.wrkMode != WK_SERVICE) {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("WARNING: Debe pasar a modo SERVICE !!!\r\n"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// ADC
// read adc channel
// El canal es de 0..3/0..7 y representa el canal fisico en el conector, NO
// EL PROPIO CANAL DEL A/D
if (!strcmp_P( strupr(argv[1]), PSTR("ADC\0"))) {
pcbChannel = atoi(argv[2]);
if ( NRO_CHANNELS == 3 ) {
switch (pcbChannel ) {
case 0:
adcChannel = 3;
break;
case 1:
adcChannel = 5;
break;
case 2:
adcChannel = 7;
break;
case 3:
adcChannel = 1; // Bateria
break;
}
}
retS = ADS7828_convert( adcChannel, &adcRetValue );
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("adc_%d(%d)=[%d]\r\n\0"),pcbChannel, adcChannel, adcRetValue);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// FRAME
// Lee todos los canales y presenta el frame.
if (!strcmp_P( strupr(argv[1]), PSTR("FRAME\0"))) {
SIGNAL_tkDataReadFrame();
return;
}
// EEPROM
// read ee addr length
if (!strcmp_P( strupr(argv[1]), PSTR("EE\0"))) {
eeAddress = atol(argv[2]);
length = atoi(argv[3]);
// Buffer control.
if (length > EERDBUFLENGHT) {
length = EERDBUFLENGHT;
}
retS = EE_read( eeAddress, length, &eeRdBuffer);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("addr=[%d] data=[%s]\r\n\0"),eeAddress,eeRdBuffer);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MEMORY DUMP
if (!strcmp_P( strupr(argv[1]), PSTR("MEMORY\0"))) {
recCount = 0;
for (;;) {
vTaskDelay( (portTickType)(50 / portTICK_RATE_MS) );
rcdIndex = BD_getRDptr();
bdGetStatus = BD_get( &rdFrame, rcdIndex);
// BD vacia
if (bdGetStatus == 0) {
break;
}
recCount++;
// Armo el frame
memset( cmd_printfBuff, NULL, CHAR128);
pos = 0;
pos = snprintf_P( &cmd_printfBuff, CHAR128, PSTR("(%d/%d)>" ), recCount, rcdIndex);
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%04d%02d%02d,"),rdFrame.rtc.year,rdFrame.rtc.month, rdFrame.rtc.day );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%02d%02d%02d,"),rdFrame.rtc.hour,rdFrame.rtc.min, rdFrame.rtc.sec );
// Valores analogicos
for ( channel = 0; channel < NRO_CHANNELS; channel++) {
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f"),systemVars.aChName[channel],rdFrame.analogIn[channel] );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(","));
}
// Valores digitales.
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f,"), systemVars.dChName[0], rdFrame.din0_pCount );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%s=%.2f"), systemVars.dChName[1], rdFrame.din0_pCount );
#ifdef CHANNELS_3
// Bateria
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(",bt=%.2f"), rdFrame.batt );
#endif
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR("<\r\n\0") );
// Imprimo
sp5K_printStr(&cmd_printfBuff);
BD_delete(-1);
taskYIELD();
}
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n\0"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// CMD NOT FOUND
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
rprintfProgStrM(CMD_UART, "ERROR\r\n");
rprintfProgStrM(CMD_UART, "CMD NOT DEFINED\r\n");
xSemaphoreGive( sem_CmdUart );
}
return;
}
//------------------------------------------------------------------------------------
s08 MCP_outsPulse( u08 channel, u08 phase, u16 delay )
{
// Genera un pulso en el canal 'channel', con la secuencia de fases 'phase' y
// de duracion 'delay'
// Deja el sistema en reposo ( sleep )
// OJO: El MCP1 tiene por defecto los pull-ups correspondientes a las salidas deshabilitados
// para ahorrar corriente. Lo que debo hacer es activar los pullups, generar los pulsos y desactivarlos.
s08 retS = FALSE;
u08 regOlatA, regOlatB;
MCP_read( MCP1_ADDR, MCP1_GPPUA, ®OlatA );
MCP_write( MCP1_ADDR, MCP1_GPPUA, 0xFF );
MCP_read( MCP1_ADDR, MCP1_GPPUB, ®OlatB );
MCP_write( MCP1_ADDR, MCP1_GPPUB, 0xFF );
MCP_outputsNoSleep();
MCP_outputsNoReset();
switch(channel) {
case 0: // Canal 0, A1
if ( phase == 0 ) { retS = MCP_outputA1Phase_01(); }
if ( phase == 1 ) { retS = MCP_outputA1Phase_10(); }
MCP_outputA1Enable();
vTaskDelay( ( TickType_t)( delay / portTICK_RATE_MS ) );
MCP_outputA1Disable();
break;
case 1: // Canal 1, B1
if ( phase == 0 ) { retS = MCP_outputB1Phase_10(); }
if ( phase == 1 ) { retS = MCP_outputB1Phase_01(); }
MCP_outputB1Enable();
vTaskDelay( ( TickType_t)( delay / portTICK_RATE_MS ) );
MCP_outputB1Disable();
break;
case 2: // Canal 2, A2
if ( phase == 0 ) { retS = MCP_outputA2Phase_10(); }
if ( phase == 1 ) { retS = MCP_outputA2Phase_01(); }
MCP_outputA2Enable();
vTaskDelay( ( TickType_t)( delay / portTICK_RATE_MS ) );
MCP_outputA2Disable();
break;
case 3: // Canal 3, B2
if ( phase == 0 ) { retS = MCP_outputB2Phase_01(); }
if ( phase == 1 ) { retS = MCP_outputB2Phase_10(); }
MCP_outputB2Enable();
vTaskDelay( ( TickType_t)( delay / portTICK_RATE_MS ) );
MCP_outputB2Disable();
break;
default:
retS = FALSE;
break;
}
MCP_outputsSleep();
MCP_write( MCP1_ADDR, MCP1_GPPUA, regOlatA );
MCP_write( MCP1_ADDR, MCP1_GPPUB, regOlatB );
return(retS);
}
