// UART1 RX ISR
void __attribute__ ((interrupt,no_auto_psv)) _U1RXInterrupt(void)
{
char c;
// Clear the interrupt status of UART1 RX
U1RX_Clear_Intr_Status_Bit;
// Get the character from the GSM UART
c = gsmRead();
// If a character comes in from the GSM module...
if (c)
{
while(BusyUART3());
WriteUART3((unsigned int)c); // Print the incoming character to USB UART
// Clear out any garbage characters
while(DataRdyUART1())
ReadUART1();
}
// Detect if GSM antenna is ready
if(newSINDreceived() && gsmReady()) {
// gsmCall(HOME_NUMBER);
// gsmText(HOME_NUMBER, "Hey Matt!");
//
//MS: add parser
}
}
//-----------------------------------------------------------------
// Interrupts
//-----------------------------------------------------------------
// UART1 -> IR signal
void __attribute__((__interrupt__)) _U1RXInterrupt(void)
{
unsigned char buffer;
IFS0bits.U1RXIF = 0;
while( DataRdyUART1() )
{
buffer=ReadUART1();
}
if (buffer == current_TRANSMITTER) //check if the received signal is the current slave's adress
{
receive_flag[current_state]=buffer;
}
}
/****************************************************************************
* Function Name : getsUART1
* Description : This function gets a string of data of specified length
* if available in the UxRXREG buffer into the buffer
* specified.
* Parameters : unsigned int length the length expected
* unsigned int *buffer the received data to be
* recorded to this array
* unsigned int uart_data_wait timeout value
* Return Value : unsigned int number of data bytes yet to be received
*************************************************************************/
unsigned int getsUART1(unsigned int length,unsigned int *buffer,
unsigned int uart_data_wait)
{
int wait = 0;
char *temp_ptr = (char *)buffer;
while(length) /* read till length is 0 */
{
while(!DataRdyUART1())
if( (!uart_data_wait) && (wait++ > uart_data_wait) )
return length; /*Time out- Return words/bytes to be read */
if(U1MODEbits.PDSEL == 3) /* check if TX/RX is 8bits or 9bits */
*buffer++ = U1RXREG; /* data word from HW buffer to SW buffer */
else
*temp_ptr++ = U1RXREG & 0xFF; /* data byte from HW buffer to SW buffer */
length--;
}
return length; /* number of data yet to be received i.e.,0 */
}
/* Read GSM data */
char gsmRead(void) {
char c = 0;
/* Grab data from GSM if available */
if (!DataRdyUART1()) {
return c;
} else {
c = ReadUART1();
}
if (c == '+') {
gsmCurrentLine[gsmLineIdx] = 0;
gsmLineIdx = 0;
}
if (c == '\n') {
gsmCurrentLine[gsmLineIdx] = 0;
if (gsmCurrentLine == gsmLine1) {
gsmCurrentLine = gsmLine2;
gsmLastLine = gsmLine1;
} else {
gsmCurrentLine = gsmLine1;
gsmLastLine = gsmLine2;
}
gsmLineIdx = 0;
gsmRcvdFlag = true;
}
gsmCurrentLine[gsmLineIdx++] = c;
if (gsmLineIdx >= SINDMAXLINELENGTH)
gsmLineIdx = SINDMAXLINELENGTH-1;
return c;
}
void InterruptAX() {
while(DataRdyUART1()) {
byte b = ReadUART1();
if(posAX == -5 && b == 0xFF)
posAX = -4;
else if(posAX == -4 && b == 0xFF) {
posAX = -3;
checksumAX = 0;
responseAX.len = 1;
}
else if(posAX == -3) {
posAX = -2;
responseAX.id = b;
}
else if(posAX == -2 && b < 2 + 4 /*taille de ax.parameters*/) {
posAX = -1;
checksumAX = responseAX.id + b;
responseAX.len = b - 2;
}
else if(posAX == -1) {
posAX = 0;
responseAX.error = *((errorAX*)&b);
//checksumAX += b;
}
else if(0 <= posAX && posAX < responseAX.len) {
((byte*)&responseAX.params)[posAX++] = b;
checksumAX += b;
}
else if(posAX == responseAX.len && (b & checksumAX) == 0) {
responseReadyAX = 1;
posAX = -5;
}
else
posAX = -5; // Erreur.
}
}
void vLogicAnalizer(void){
unsigned int keepGoing = 0; // Determina si debe seguir o no el muestreo
unsigned int triggerType; // Tipo de trigger
unsigned int samplingFrequency; // Frecuencia de muestreo
unsigned int channelMask; // Máscara para filtrar los canales (un 1 en el canal que se desea el trigger, 0 de otro modo)
TRISB |= 0xFF00; // Parte alta del puerto B como entrada (hacemos una OR sino modificamos los pines
// UART y deja de funcionar)
TRISAbits.TRISA1 = 0; // Pin de dirección del buffer
PORTAbits.RA1 = 0; // Puerto B del buffer como entrada y A como salida (A <- B)
CNPU1 = CNPU2 = 0; // Deshabilito pull-ups
CLKDIVbits.DOZEN = 0; // CPU a 40 MIPS
disableUARTInt();
writeUART1(LOGIC_ANALIZER); // Envío el modo
debug("\r\nAnalizador Logico");
// Elimino datos que puedan quedar en el UART
while(DataRdyUART1()){
printNumericDebug("\r\nDatos disponibles en el UART: ", ReadUART1());
}
// Leo el estado para saber si debo continuar o detenerme
sleepWait();
keepGoing = mReadUART1();
printNumericDebug("\r\nKeepGoing recibido: ", keepGoing);
while(keepGoing != 0){
if(keepGoing != 0){
debug("\r\nKeep Going!");
samplingFrequency = mReadUART1(); // Obtengo la frecuencia de muestreo
triggerType = mReadUART1(); // Obtengo el tipo de trigger
channelMask = mReadUART1(); // Obtengo la máscara
printCharDebug("\r\nSampling Frequency: ", samplingFrequency);
printNumericDebug("\r\nTrigger Type: ", triggerType);
printNumericDebug("\r\nChannel Mask: ", channelMask);
CNEN1 = CNEN2 = 0;
if(channelMask == 0) triggerType = noTrigger;
// De acuerdo al bit seteado en el Mask detecto o no el cambio de estado
// en el pin correspondiente
if(bitTest(channelMask, 7)) CNEN1bits.CN11IE = 1;
if(bitTest(channelMask, 6)) CNEN1bits.CN12IE = 1;
if(bitTest(channelMask, 5)) CNEN1bits.CN13IE = 1;
if(bitTest(channelMask, 4)) CNEN1bits.CN14IE = 1;
if(bitTest(channelMask, 3)) CNEN1bits.CN15IE = 1;
if(bitTest(channelMask, 2)) CNEN2bits.CN16IE = 1;
if(bitTest(channelMask, 1)) CNEN2bits.CN21IE = 1;
if(bitTest(channelMask, 0)) CNEN2bits.CN22IE = 1;
// Habilito interrupciones por cambio de estado en caso de usarlas
if(triggerType == simpleTrigger){
IEC1bits.CNIE = 1;
IFS1bits.CNIF = 0;
}
else IEC1bits.CNIE = 0;
}
else{
debug("\r\nAnalizador Logico BREAK");
break;
}
switch(samplingFrequency){
case F40MHz:
debug("\r\nSampling 40MHz");
if(triggerType == noTrigger) vSample40MHz((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE);
else if(triggerType == simpleTrigger) vSample40MHzTriggerSimple((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE, channelMask);
break;
case F20MHz:
debug("\r\nSampling 20MHz");
if(triggerType == noTrigger) vSample20MHz((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE);
else if(triggerType == simpleTrigger) vSample20MHzTriggerSimple((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE, channelMask);
break;
case F10MHz:
debug("\r\nSampling 10MHz");
if(triggerType == noTrigger) vSample10MHz((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE);
else if(triggerType == simpleTrigger) vSample10MHzTriggerSimple((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE, channelMask);
break;
case F4MHz:
debug("\r\nSampling 4MHz");
if(triggerType == noTrigger) vSample4MHz((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE);
else if(triggerType == simpleTrigger) vSample4MHzTriggerSimple((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE, channelMask);
break;
case F400KHz:
debug("\r\nSampling 400KHz");
if(triggerType == noTrigger) vSample400KHz((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE);
else if(triggerType == simpleTrigger) vSample400KHzTriggerSimple((unsigned char *)&PORTB+1, Buffer, BUFFER_SIZE, channelMask);
break;
case F2KHz:
debug("\r\nSampling 2KHz");
//vSample2KHz((char *)&PORTB+1, &Buffer, BUFFER_SIZE);
break;
case F10Hz:
debug("\r\nSampling 10Hz");
//vSample10Hz((char *)&PORTB+1, &Buffer, BUFFER_SIZE);
break;
default:
debug("\r\nSampling Default");
break;
}
debug("\r\nSending data");
writeUART1(START_BYTE); // Envío byte de Start
writeUART1(LOGIC_ANALIZER); // Envío proveniencia del dato
// Envío el buffer comprimido
RLEncodeSendBuffer(Buffer, BUFFER_SIZE);
// Dos 0xFF indican la terminación
writeUART1(0xFF);
writeUART1(0xFF);
sleepWait();
keepGoing = mReadUART1();
printNumericDebug("\r\nKeepGoing recibido: ", keepGoing);
}
debug("\r\nSale de Analizador Logico");
enableUARTInt(); // Habilito nuevamente las interrupciones UART
}
/**
* Espero un byte desde el USART 1 y lo devuelvo
* @return byte leido desde el USART
*/
unsigned int mReadUART1 (void){
while(!DataRdyUART1());
return ReadUART1();
}
