Application of Observer Mode in MCU

Host: WIN8

Development environment: MDK5.13

mcu: stm32f103RB

illustrate:

The observer pattern was previously used in Java, and now the idea of ​​this pattern is applied to microcontroller programming

Android Programming: Observer Pattern Design:

http://blog.csdn.net/jdh99/article/details/41821295

The essence of the observer pattern:

There are two modules A and B. A is the target and B is the observer. Then B can observe the changes of A.

In the program implementation process is:

1.A Generate data

2. A notifies B

3.B Processing Data

Method implemented in single chip microcomputer:

In Java, this idea is implemented through interfaces. If the microcontroller is programmed in C language, it can be implemented through function pointers.

The dw1000 communication module in the source code provides two observable targets: receive data and send data complete.

source code:

dw1000.h

/*
* dw1000 communication module header file
* (c) copyright 2015, jdh
* All Rights Reserved
*New creation time: 2015/1/5 by jdh
*Modified on: 2015/1/6 by jdh
/

#ifndef _DW1000_H_
#define _DW1000_H_

/*
* head File
/

#include "world.h"

/*
* Macro definition
/

/*
* Maximum length of receive data buffer
/

#define LEN_DW1000_BUF_RX 128

/*
* data structure
/

/*
* dw1000 time structure
/

union _Dw1000_Time
{
	uint8_t pt[8];
	uint64_t value;
};

/*
* Receive data structure
/

struct _Dw1000_Rx
{
	//Receive data
	uint8_t buf[LEN_DW1000_BUF_RX];
	//dw1000 time to receive data
	union _Dw1000_Time time;
};

/*
* Observer mode: receiving data processing function pointer
/

typedef void (*T_Dw1000_Deal_Rx)(struct _Dw1000_Rx);

/*
* Observer mode: Send data to complete the processing function pointer
/

typedef void (*T_Dw1000_Deal_Tx_End)(union _Dw1000_Time);

/*
* Receive buffer
/

struct _Rx_Buf_CC1100
{
	//Receive time
	T_Time time;
	
	//Source ID
	uint16_t src_id;
	//function code
	uint8_t cmd;
	//data
	uint8_t data[3];
	//rssi
	int rssi;
	//lqi
	uint8_t lqi;
};

/*
* Functions
/

/*
* Interface function: module loading
/

void dw1000_load(void);

/*
* Interface function: module operation
/

void dw1000_run(void);

/*
* Interface function: interrupt processing function
/

void dw1000_irq_handler(void);

/*
* Interface function: Determine whether it can be sent
*Return: 0: cannot be sent, 1: can be sent
/

uint8_t cc1100_judge_tx(void);

/*
* Interface function: send data
*Parameter: cmd: function code
* id: target id
* data: 3 bytes of data
/

void cc1100_tx(uint8_t cmd,uint16_t id,uint8_t *data);

/*
* Interface function: get received data
* Return: receive data
/

struct _Rx_Buf_CC1100 cc1100_get_rx_buf(void);

/*
* Interface function: set frequency
*Parameter: freq: the frequency point to be set
/

void cc1100_set_freq(uint8_t freq);

/*
* Interface function: Register observer: Receive data
/

void dw1000_register_observer_rx(T_Dw1000_Deal_Rx function);

/*
* Interface function: Register observer: Send completed
/

void dw1000_register_observer_tx_end(T_Dw1000_Deal_Tx_End function);

#endif

dw1000.c

/*
* dw1000 communication module main file
* (c) copyright 2015, jdh
* All Rights Reserved
*New creation time: 2015/1/5 by jdh
*Modified on: 2015/1/6 by jdh
/

/*
* head File
/

#include "dw1000.h"

/*
* Macro definition
/

/*
* Maximum number of observers
/

#define MAX_OBSERVER 10

/*
* Static variables
/

/*
* Receive data observer list
/

static T_Dw1000_Deal_Rx Observer_Rx[MAX_OBSERVER];
static uint8_t Len_Observer_Rx = 0;

/*
* Send the completed observer list
/

static T_Dw1000_Deal_Tx_End Observer_Tx_End[MAX_OBSERVER];
static uint8_t Len_Observer_Tx_End = 0;

/*
* Static functions
/

/*
* Receive and process
/

static void deal_rx(void);

/*
* Send end processing
/

static void deal_tx_end(void);

/*
* Functions
/

/*
* Interface function: module loading
/

void dw1000_load(void)
{
    
}

/*
* Interface function: module operation
/

void dw1000_run(void)
{
	
}

/*
* Interface function: Register observer: Receive data
/

void dw1000_register_observer_rx(T_Dw1000_Deal_Rx function)
{
	Observer_Rx[Len_Observer_Rx++] = function;
}

/*
* Interface function: Register observer: Send completed
/

void dw1000_register_observer_tx_end(T_Dw1000_Deal_Tx_End function)
{
	Observer_Tx_End[Len_Observer_Tx_End++] = function;
}

/*
* Interface function: interrupt processing function
/

void dw1000_irq_handler(void)
{
	uint32_t status = 0;
	uint32_t clear = 0; // will clear any events seen
	uint8_t resetrx;
	
	status = dwt_read32bitreg(SYS_STATUS_ID); // read status register low 32bit
	if(status & SYS_STATUS_LDEDONE)
	{
		if((status & (SYS_STATUS_LDEDONE | SYS_STATUS_RXPHD | SYS_STATUS_RXSFDD)) != (SYS_STATUS_LDEDONE | SYS_STATUS_RXPHD | SYS_STATUS_RXSFDD))
		{
			resetrx = 0xe0;
			//got LDE done but other flags SFD and PHR are clear - this is a bad frame - reset the transceiver
			dwt_forcetrxoff(); //this will clear all events
			//set rx reset
			dwt_writetodevice(PMSC_ID, 0x3, 1, &resetrx);
			resetrx = 0xf0; //clear RX reset
			dwt_writetodevice(PMSC_ID, 0x3, 1, &resetrx);
// dwt_write16bitoffsetreg(SYS_CTRL_ID,0,(uint16)SYS_CTRL_RXENAB);
		}
	}
	if((status & SYS_STATUS_RXFCG) && (status & SYS_STATUS_LDEDONE)) // Receiver FCS Good
    {
		//clear all receive status bits (as we are finished with this receive event)
		clear |= status & CLEAR_ALLRXGOOD_EVENTS ;
	    dwt_write32bitreg(SYS_STATUS_ID,clear); // write status register to clear event bits we have seen
		//Receive and process
		deal_rx();
    }
	else
	{
		if (status & SYS_STATUS_TXFRS) // Transmit Frame Sent
		{
			clear |= CLEAR_ALLTX_EVENTS; //clear TX event bits
			dwt_write32bitreg(SYS_STATUS_ID,clear); // write status register to clear event bits we have seen
			//Send end processing
			deal_tx_end();
			
		}
		else
		{
			if (status & SYS_STATUS_RXRFTO)
			{
				//Receive timeout
				clear |= status & SYS_STATUS_RXRFTO ;
				dwt_write32bitreg(SYS_STATUS_ID,clear); // write status register to clear event bits we have seen
				dwt_setrxtimeout(0);
				dwt_rxenable(0);
			}
			else
			{
				// Clear all flags when exception occurs					 
				clear |= CLEAR_ALLRXERROR_EVENTS;
				dwt_write32bitreg(SYS_STATUS_ID,clear); // write status register to clear event bits we have seen
				dwt_forcetrxoff(); //this will clear all events
				//set rx reset
				dwt_writetodevice(PMSC_ID, 0x3, 1, &resetrx);
    		    resetrx = 0xf0; //clear RX reset
		        dwt_writetodevice(PMSC_ID, 0x3, 1, &resetrx);
				dwt_rxenable(0);	 
			}
		}
	}
}

/*
* Receive and process
/

static void deal_rx(void)
{
	struct _Dw1000_Rx rx;
	uint16_t len;
	uint8_t i = 0;
	
	len = dwt_read16bitoffsetreg(RX_FINFO_ID, 0) & 0x3FF;
	if (len >= 127)
	{
		return;
	}
	
	dwt_write32bitreg(SYS_STATUS_ID,CLEAR_ALLRXGOOD_EVENTS);
	//Get the receiving time
	dwt_readrxtimestamp(rx.time.pt);
	rx.time.value &= MASK_40BIT;
	//Get received data
	dwt_readfromdevice(RX_BUFFER_ID,0,len,rx.buf);
	
	//Notify observers
	for (i = 0;i < Len_Observer_Rx;i++)
	{
		Observer_Rx[i](rx);
	}
	
// uint8 resetrx;
//	
//// resetrx = 0xe0; //got LDE done but other flags SFD and PHR are clear - this is a bad frame - reset the transceiver
//// dwt_forcetrxoff(); //this will clear all events
//// dwt_writetodevice(PMSC_ID, 0x3, 1, &resetrx);//set rx reset
//// resetrx = 0xf0; //clear RX reset
//// dwt_writetodevice(PMSC_ID, 0x3, 1, &resetrx);
	dwt_write16bitoffsetreg(SYS_CTRL_ID,0,(uint16)SYS_CTRL_RXENAB);			
}

/*
* Send end processing
/

static void deal_tx_end(void)
{
	union _Dw1000_Time time;
	uint8_t i = 0;
	
	//Get the sending time
	dwt_readtxtimestamp(time.pt);
	time.value &= MASK_40BIT;	

	//Notify observers
	for (i = 0;i < Len_Observer_Tx_End;i++)
	{
		Observer_Tx_End[i](time);
	}
}

Observe the received data of the dw1000 module in main.c:

//Add observer to receive data
	dw1000_register_observer_rx(deal_rx);

Processing function:

void deal_rx(struct _Dw1000_Rx rx)
 {
	 //deal with...
	 __nop();
	 __nop();
	 __nop();
 }