static void alarmCallback()
{
static struct RTC_time t_now;
static struct unicast_message *tmp, sMsg;
static struct sensor_data sens_data;
static uint16_t samplingDelay = 280;
static uint16_t delay = 40; // ADC requires minimum 20 us of sampling time.
static uint16_t sleepDelay = 9680;
static uint16_t avg;
static uint8_t count = 0;
if(count==0)
RTC_getTime(&t_now);
int len;
uint8_t i, numSampl = 20;
static uint16_t v = 0, v1;
ioPins_configurePin(8, USEGPIO, OUTPUT, NOPULLUP, HYSTERESIS_OFF);
ioPins_configurePin(7, USEGPIO, OUTPUT, NOPULLUP, HYSTERESIS_OFF);
ioPins_setValue(8, 1);
ioPins_setValue(7, 1);
avg = 0;
for(i=0;i<numSampl;i++)
{
ioPins_setValue(8, 0);
clock_delay_usec(samplingDelay);
v = ioPins_getValue(16);
avg+=v;
clock_delay_usec(delay);
ioPins_setValue(8, 1);
clock_delay_usec(sleepDelay);
}
sens_data.lraw[count] = avg&0xFF;
sens_data.hraw[count] = (avg&0xFF00)>>8;
if(count==59)
{
sMsg.id = id;
sMsg.type = DATA_REQ;
sMsg.time = t_now;
strcpy(sMsg.name, "Dust sensor\0");
sMsg.data = sens_data;
sMsg.numSampl = numSampl;
packetbuf_copyfrom(&sMsg, sizeof(struct unicast_message));
unicast_send(&unicast, &nmaddr);
count = 0;
}
else
{
count++;
}
}
/*---------------------------------------------------------------------------*/
uint8_t sht21_read(uint16_t * data, uint8_t regist)
{
uint16_t temp;
uint8_t dataByte[2];
if(regist != SHT21_TEMP_REGISTER && regist != SHT21_HUMI_REGISTER) {
return -1;
}
i2c_master_set_slave_address(SHT21_SLAVE_ADDRESS, I2C_SEND);
i2c_master_data_put(regist);
i2c_master_command(I2C_MASTER_CMD_BURST_SEND_START);
while (i2c_master_busy()) {
}
if(i2c_master_error() == I2C_MASTER_ERR_NONE) {
if(regist == SHT21_TEMP_REGISTER) {
for (temp = 0; temp < 10; temp++) {
clock_delay_usec(8500); //85ms
}
} else if(regist == SHT21_HUMI_REGISTER) {
for (temp = 0; temp < 10; temp++) {
clock_delay_usec(2900); //29ms
}
}
/* Get the 2 bytes of data*/
/* Data MSB */
i2c_master_set_slave_address(SHT21_SLAVE_ADDRESS, I2C_RECEIVE);
i2c_master_command(I2C_MASTER_CMD_BURST_RECEIVE_START);
while (i2c_master_busy()) {
}
if(i2c_master_error() == I2C_MASTER_ERR_NONE) {
*data = i2c_master_data_get() << 8;
/* Data LSB */
i2c_master_command(I2C_MASTER_CMD_BURST_RECEIVE_CONT);
while (i2c_master_busy()) {
}
if(i2c_master_error() == I2C_MASTER_ERR_NONE) {
*data |= i2c_master_data_get();
/* Checksum */
i2c_master_command(I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
while (i2c_master_busy()) {
}
if(i2c_master_error() == I2C_MASTER_ERR_NONE) {
dataByte[0] = (*data) >> 8;
dataByte[1] = (*data) & 0x00FF;
if(sht21_check_crc(dataByte, 2,
i2c_master_data_get()) == I2C_MASTER_ERR_NONE) {
return I2C_MASTER_ERR_NONE;
}
}
}
void onewire_reset(void)
{
OUT_DQ();
CLR_DQ();
clock_delay_usec(480);
SET_DQ();
clock_delay_usec(60);
IN_DQ();
clock_delay_usec(10);
while(!(GET_DQ()));
OUT_DQ();
SET_DQ();
}
/*---------------------------------------------------------------------------*/
static void
floppin(uint8_t port, uint8_t pin)
{
uint8_t i;
GPIO_CLR_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin));
clock_delay_usec(500);
for(i = 0; i < 50; i++) {
GPIO_SET_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin));
clock_delay_usec(500);
GPIO_CLR_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin));
clock_delay_usec(500);
}
}
/* -------------------------------------------------------------------------- */
static int8_t
pm_get_ack(void)
{
uint16_t error = PM_ERROR;
PM_CMD_AS_INPUT;
clock_delay_usec(PM_3_MILISECOND);
if(PM_CMD_LINE_READ) {
error = PM_SUCCESS;
}
clock_delay_usec(PM_10_MILISECOND);
PM_CMD_AS_OUTPUT;
return error;
}
/*---------------------------------------------------------------------------*/
int
mp3_wtv020sd_reset(void)
{
if(initialized != MP3_WTV020SD_LINE_MODE) {
return MP3_WTV020SD_ERROR;
}
GPIO_CLR_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK);
GPIO_SET_PIN(MP3_RESET_PORT_BASE, MP3_RESET_PIN_MASK);
GPIO_CLR_PIN(MP3_RESET_PORT_BASE, MP3_RESET_PIN_MASK);
clock_delay_usec(MP3_USEC_DELAY);
GPIO_SET_PIN(MP3_RESET_PORT_BASE, MP3_RESET_PIN_MASK);
GPIO_SET_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK);
clock_delay_usec(MP3_USEC_RESET_DELAY);
return MP3_WTV020SD_SUCCESS;
}
/*---------------------------------------------------------------------------*/
void
i2c_master_command(uint8_t cmd)
{
REG(I2CM_CTRL) = cmd;
/* Here we need a delay, otherwise the I2C module keep the receiver mode */
clock_delay_usec(1);
}
void I2C_Start(void)
{
SDA=1;
SCL=1;
clock_delay_usec(1);
SDA=0;
SCL=0;
}
void Sendack(uint8_t h)
{
SCL=0;
SDA=h&0x01;
SCL=1;
clock_delay_usec(1);
SCL=0;
}
void write(unsigned char start, unsigned char ddata) //写指令或数据
{
unsigned char start_data,Hdata,Ldata;
if(start == COMMAND)
start_data = 0xf8; //写指令
else
start_data = 0xfa; //写数据
Hdata = ddata&0xf0; //取高四位
Ldata = (ddata<<4)&0xf0; //取低四位
sendbyte(start_data); //发送起始信号
clock_delay_usec(100); //延时是必须的
sendbyte(Hdata); //发送高四位
clock_delay_usec(100); //延时是必须的
sendbyte(Ldata); //发送低四位
clock_delay_usec(100); //延时是必须的
}
void nrf51822_interrupt(uint8_t port, uint8_t pin)
{
uint16_t b;
uint8_t buf[256];
int i;
leds_toggle(LEDS_RED);
spi_set_mode(SSI_CR0_FRF_MOTOROLA, 0, 0, 8);
SPI_CS_CLR(NRF51822_CS_N_PORT_NUM, NRF51822_CS_N_PIN);
clock_delay_usec(8);
// READ_IRQ
SPI_WRITE(0x01);
SPI_FLUSH();
SPI_CS_SET(NRF51822_CS_N_PORT_NUM, NRF51822_CS_N_PIN);
clock_delay_usec(75);
SPI_CS_CLR(NRF51822_CS_N_PORT_NUM, NRF51822_CS_N_PIN);
clock_delay_usec(8);
SPI_READ(b);
if (b == 0xFF) {
// ERROR on the nrf51822 side. Skip this.
} else {
for (i=0; i<b; i++) {
SPI_READ(buf[i]);
}
}
SPI_CS_SET(NRF51822_CS_N_PORT_NUM, NRF51822_CS_N_PIN);
}
void
delay_msec(uint16_t howlong)
{
#if F_CPU>=16000000
while(howlong--) clock_delay_usec(1000);
#elif F_CPU>=8000000
uint16_t i=996;
while(howlong--) {clock_delay_usec(i);i=999;}
#elif F_CPU>=4000000
uint16_t i=992;
while(howlong--) {clock_delay_usec(i);i=999;}
#elif F_CPU>=2000000
uint16_t i=989;
while(howlong--) {clock_delay_usec(i);i=999;}
#else
uint16_t i=983;
while(howlong--) {clock_delay_usec(i);i=999;}
#endif
}
/*---------------------------------------------------------------------------*/
int
mp3_wtv020sd_gpio_next(void)
{
if(initialized != MP3_WTV020SD_GPIO_MODE) {
return MP3_WTV020SD_ERROR;
}
GPIO_CLR_PIN(MP3_PLAY_PORT_BASE, MP3_PLAY_PIN_MASK);
clock_delay_usec(MP3_USEC_DELAY);
GPIO_SET_PIN(MP3_PLAY_PORT_BASE, MP3_PLAY_PIN_MASK);
return MP3_WTV020SD_SUCCESS;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(ac_dimmer_int_process, ev, data)
{
PROCESS_EXITHANDLER();
PROCESS_BEGIN();
int dimtime;
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
dimtime = (uint8_t)(100 - dimming);
dimtime *= 100;
/* Off cycle */
clock_delay_usec(dimtime);
GPIO_SET_PIN(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK);
/* Triac on propagation delay */
clock_delay_usec(DIMMER_DEFAULT_GATE_PULSE_US);
GPIO_CLR_PIN(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
int
mp3_line_command(uint16_t cmd)
{
uint16_t mask;
if(initialized != MP3_WTV020SD_LINE_MODE) {
return MP3_WTV020SD_ERROR;
}
GPIO_CLR_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK);
clock_delay_usec(MP3_USEC_CMD_DELAY / 10);
for(mask = 0x8000; mask > 0; mask >> 1) {
GPIO_CLR_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK);
clock_delay_usec(MP3_USEC_CMD_DELAY / 2);
if(cmd & mask) {
GPIO_SET_PIN(MP3_DATA_PORT_BASE, MP3_DATA_PIN_MASK);
} else {
GPIO_CLR_PIN(MP3_DATA_PORT_BASE, MP3_DATA_PIN_MASK);
}
clock_delay_usec(MP3_USEC_CMD_DELAY / 2);
GPIO_SET_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK);
clock_delay_usec(MP3_USEC_CMD_DELAY);
if(mask > 0x0001) {
clock_delay_usec(MP3_USEC_CMD_DELAY / 10);
}
}
clock_delay_usec(MP3_USEC_CMD_DELAY / 8);
return MP3_WTV020SD_SUCCESS;
}
void fm25v02_dummyWakeup(){
uint8_t dummyReg;
//uint16_t dummyCnt;
spi_set_mode(SSI_CR0_FRF_MOTOROLA, 0, 0, 8);
SPI_CS_CLR(FM25V02_CS_N_PORT_NUM, FM25V02_CS_N_PIN);
// Delay for 400-ish us
clock_delay_usec(400);
//for (dummyCnt=0; dummyCnt<800; dummyCnt++)
// asm("nop");
SPI_FLUSH();
SPI_READ(dummyReg);
SPI_CS_SET(FM25V02_CS_N_PORT_NUM, FM25V02_CS_N_PIN);
}
uint8_t onewire_read(void)
{
uint8_t data = 0;
int i;
for (i = 0; i < 8; i++)
{
OUT_DQ();
CLR_DQ();
data = data >> 1;
SET_DQ();
IN_DQ();
clock_delay_usec(8);
if(GET_DQ())
data |= 0x80;
OUT_DQ();
SET_DQ();
clock_delay_usec(60);
}
return data;
}
/* -------------------------------------------------------------------------- */
static int8_t
pm_send_cmd(uint8_t cmd)
{
uint8_t i;
PRINTF("PM: cmd %u\n", cmd);
/* Enter command mode */
PM_CMD_LINE_SET;
clock_delay_usec(PM_1_MILISECOND);
PM_CMD_LINE_CLR;
/* Send command */
for (i = PM_MAX_BITS; i > 0; i--) {
clock_delay_usec(PM_1_MILISECOND);
if (cmd & PM_NUMBITS(i)) {
PM_CMD_LINE_SET;
}
else PM_CMD_LINE_CLR;
}
clock_delay_usec(PM_1_MILISECOND);
PM_CMD_LINE_CLR;
/* Receive command reply if any */
if((cmd == PM_CMD_GET_STATE) || (cmd == PM_CMD_GET_FW_VERSION)) {
PM_CMD_AS_INPUT;
clock_delay_usec(PM_2_2_MILISECOND);
for (i = PM_MAX_BITS; i > 0; i--) {
clock_delay_usec(PM_1_MILISECOND);
PM_CMD_LINE_READ ? (getData |= PM_NUMBITS(i)) : (getData &= ~PM_NUMBITS(i));
}
PRINTF("PM: getData = 0x%02X\n", getData);
clock_delay_usec(PM_2_2_MILISECOND);
PM_CMD_AS_OUTPUT;
PM_CMD_LINE_CLR;
clock_delay_usec(PM_2_2_MILISECOND);
return PM_SUCCESS;
}
/* Default case */
clock_delay_usec(PM_1_MILISECOND);
return pm_get_ack();
}
void nrf51822_get_all_advertisements () {
//spi_set_mode(SSI_CR0_FRF_MOTOROLA, SSI_CR0_SPO, SSI_CR0_SPH, 8);
spi_set_mode(SSI_CR0_FRF_MOTOROLA, 0, 0, 8);
SPI_CS_CLR(NRF51822_CS_N_PORT_NUM, NRF51822_CS_N_PIN);
clock_delay_usec(8);
// GET ADVERTISEMENTS
SPI_WRITE(0x02);
SPI_FLUSH();
SPI_CS_SET(NRF51822_CS_N_PORT_NUM, NRF51822_CS_N_PIN);
}
void main (void)
{
clock_init();
uart_init();
P1SEL &= ~(0x10 | 0x02 | 0x01);
P1DIR |= (0x10 | 0x02 | 0x01);
P2SEL &= ~0x01;
P2DIR |= 0x01;
while(1) {
P1_0 = 1;
P1_1 = 1;
P1_4 = 1;
printf("Hello\n");
clock_delay_usec(60000);
P1_0 = 0;
P1_1 = 0;
P1_4 = 0;
printf("World\n");
clock_delay_usec(60000);
}
}
void onewire_write(uint8_t data)
{
uint8_t i;
OUT_DQ();
SET_DQ();
clock_delay_usec(16);
for(i = 0; i < 8; i++)
{
CLR_DQ();
if(data & 0x01)
{
SET_DQ();
}
else
{
CLR_DQ();
}
data = data >> 1;
clock_delay_usec(40); //65
SET_DQ();
}
}
/*---------------------------------------------------------------------------*/
static int
value(int type)
{
uint8_t channel = SOC_ADC_ADCCON_CH_AIN0 + ADC_ALS_OUT_PIN;
int16_t res;
GPIO_SET_PIN(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK);
clock_delay_usec(2000);
res = adc_get(channel, SOC_ADC_ADCCON_REF_INT, SOC_ADC_ADCCON_DIV_512);
GPIO_CLR_PIN(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK);
return res;
}
uint8_t I2C_Read_Byte(void)
{
uint8_t i=8;
uint8_t c=0;
SCL=0;
SDA=1;
while(i--){
c<<=1;
SCL=0;
clock_delay_usec(1);
SCL=1;
if(SDA==1)c|=0x01;
else c&=0xfe;
}
SCL=0;
return c;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(energy_scan, ev, data)
{
PROCESS_BEGIN();
printf("Energy Scanner\n");
printf("CCA Threshold: %d\n", (int8_t)RSSIH);
printf("Channel scan range: [%u , %u]\n", CHANNEL_MIN, CHANNEL_MAX);
printf("%u samples per channel, interval %u ticks\n",
RSSI_SAMPLES, SAMPLE_INTERVAL);
channel = CHANNEL_MIN;
while(1) {
cmax = RSSI_BASE;
cc2430_rf_channel_set(channel);
clock_delay_usec(200);
for(j = 0; j < RSSI_SAMPLES; j++) {
t0 = RTIMER_NOW();
rssi = RSSIL;
if(rssi > cmax) {
cmax = rssi;
}
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + 25));
}
printf("%u [%3d]: ", channel, cmax);
for(j = RSSI_BASE; j <= cmax; j++) {
printf("#");
}
printf("\n");
if(channel == CHANNEL_MAX) {
printf("===============\n");
channel = CHANNEL_MIN;
} else {
channel++;
}
etimer_set(&et, SAMPLE_INTERVAL);
PROCESS_YIELD();
}
PROCESS_END();
}
static int poti_value(int type)
{
uint16_t result = 0;
uint8_t counter = 0;
global_irq_disable();
while(counter < 254)
{
adc_service();
result = adc_voltage(ADC_PIN);
counter++;
clock_delay_usec( 33 );
}
global_irq_enable();
return result;
}
void
simistor_strob_callback(void)
{
// rt_now = RTIMER_NOW();
// ct = clock_time();
// printf("Task called at %lu (clock = %lu)\n", rt_now, ct);
GPIO_SET_PIN(GPIO_C_BASE, LAMP_CHAN0);
clock_delay_usec(50);
//disable simistor
GPIO_CLR_PIN(GPIO_C_BASE, LAMP_CHAN0);
//GPIO_SET_PIN(GPIO_C_BASE, 0x80);
//GPIO_CLR_PIN(GPIO_C_BASE, 0x80);
// GPIO_ENABLE_INTERRUPT(BUTTON_LEFT_PORT, BUTTON_LEFT_PIN);
// nvic_interrupt_enable(BUTTON_LEFT_VECTOR);
}
/*---------------------------------------------------------------------------*/
void
i2c_init(uint8_t port_sda, uint8_t pin_sda, uint8_t port_scl, uint8_t pin_scl,
uint32_t bus_speed)
{
/* Enable I2C clock in different modes */
REG(SYS_CTRL_RCGCI2C) |= 1; /* Run mode */
/* Reset I2C peripheral */
REG(SYS_CTRL_SRI2C) |= 1; /* Reset position */
/* Delay for a little bit */
clock_delay_usec(50);
REG(SYS_CTRL_SRI2C) &= ~1; /* Normal position */
/* Set pins in input */
GPIO_SET_INPUT(GPIO_PORT_TO_BASE(port_sda), GPIO_PIN_MASK(pin_sda));
GPIO_SET_INPUT(GPIO_PORT_TO_BASE(port_scl), GPIO_PIN_MASK(pin_scl));
/* Set peripheral control for the pins */
GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(port_sda), GPIO_PIN_MASK(pin_sda));
GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(port_scl), GPIO_PIN_MASK(pin_scl));
/* Set the pad to no drive type */
ioc_set_over(port_sda, pin_sda, IOC_OVERRIDE_DIS);
ioc_set_over(port_scl, pin_scl, IOC_OVERRIDE_DIS);
/* Set pins as peripheral inputs */
REG(IOC_I2CMSSDA) = ioc_input_sel(port_sda, pin_sda);
REG(IOC_I2CMSSCL) = ioc_input_sel(port_scl, pin_scl);
/* Set pins as peripheral outputs */
ioc_set_sel(port_sda, pin_sda, IOC_PXX_SEL_I2C_CMSSDA);
ioc_set_sel(port_scl, pin_scl, IOC_PXX_SEL_I2C_CMSSCL);
/* Enable the I2C master module */
i2c_master_enable();
/* t the master clock frequency */
i2c_set_frequency(bus_speed);
}
void main(void)
{
disable_interrupt();
clock_init();
/* workaround to wait for LSM9DS0 ready */
clock_delay_usec(60000);
/* serial port */
serial_init();
/* one wire UART based LIN (ULIN) */
ulin_init();
/* real time timer */
rtimer_init();
/* radio configuration */
rf_init(RADIO_CHANNEL);
/* comment this line out to prevent bluetooth board from crashing */
printf("\nSMAC2.0 - [%x:%x]\n", rf_get_short_addr1(), rf_get_short_addr0());
enable_interrupt();
/* module specific initialization - modules.h */
module_init();
/* flash bank used as storage */
flash_bank_select(FLASH_BANK_7);
/* looping services */
while(1)
{
json_service();
serial_service();
ulin_service();
}
}
/**
* \brief Obsolete delay function but we implement it here since some code
* still uses it
*/
void
clock_delay(unsigned int i)
{
clock_delay_usec(i);
}
PROCESS_THREAD(poti, ev, data)
{
static struct etimer loop_timer;
PROCESS_BEGIN();
/* Initialize the REST engine. */
rest_init_engine ();
SERVER_NODE (&server_ipaddr);
adc_init ();
/* Activate the application-specific resources. */
#if PLATFORM_HAS_BATTERY
SENSORS_ACTIVATE(battery_sensor);
rest_activate_resource (&res_battery, "s/battery");
#endif
rest_activate_resource (&res_server_ip, "poti/ip");
rest_activate_resource (&res_server_resource, "poti/resource");
rest_activate_resource (&res_interval, "poti/interval");
etimer_set (&loop_timer, LOOP_INTERVAL);
/* Define application-specific events here. */
while(1) {
static int count = 0;
static int lastval = -1;
static coap_packet_t request [1]; /* Array: treat as pointer */
uint8_t val = 127;
PROCESS_WAIT_EVENT();
if (etimer_expired (&loop_timer)) {
uint16_t sum = 0;
int i;
count++;
adc_setup (ADC_DEFAULT, A5);
for (i=0; i<5; i++) {
sum += adc_read ();
clock_delay_usec (50);
}
adc_fin ();
val = (sum / 5) >> 2;
if ((interval > 0 && count > interval) || (val != lastval)) {
char buf [4];
coap_transaction_t *transaction;
sprintf (buf, "%d", val);
lastval = val;
printf ("Sending Value: %s\n", buf);
coap_init_message (request, COAP_TYPE_NON, COAP_PUT, 0);
coap_set_header_uri_path (request, server_resource);
coap_set_header_content_format (request, REST.type.TEXT_PLAIN);
coap_set_payload (request, buf, strlen (buf));
request->mid = coap_get_mid ();
transaction = coap_new_transaction
(request->mid, &server_ipaddr, REMOTE_PORT);
transaction->packet_len = coap_serialize_message
(request, transaction->packet);
coap_send_transaction (transaction);
count = 0;
}
etimer_reset (&loop_timer);
}
} /* while (1) */
