// write to scratchpad of a SINGLE sensor
void writeSP(int brdNo) {
int i;
int get[8];
ow_reset();
write_byte(0xCC);
write_byte(0x4E);
write_byte(brdNo);
write_byte(0x0);
write_byte(0x7F);
while(read_bit() == 0);
ow_reset();
write_byte(0xCC);
write_byte(0x48);
uDelay(120);
ow_reset();
write_byte(0xCC);
uDelay(120);
write_byte(0xBE);
for (i = 0 ; i < 9 ; i++){
get[i] = read_byte();
}
if(get[2] != brdNo || get[3] != 0 || get[4] != 0x7F) {
UART_printf("BAD CONFIGURATION?\n");
}
}
int ow_read_temperature(void)
{
char get[10];
char temp_lsb,temp_msb;
int k;
char temp_c;
//char temp_f;
ow_reset();
ow_write_byte(0xCC); //Skip ROM
ow_write_byte(0x44); // Start Conversion
delay_usec(119); //wait 120us
ow_reset();
ow_write_byte(0xCC); // Skip ROM
ow_write_byte(0xBE); // Read Scratch Pad
for (k=0; k<9; k++) {
get[k] = ow_read_byte();
}
temp_msb = get[1]; // Sign byte + lsbit
temp_lsb = get[0]; // Temp data plus lsb
if (temp_msb <= 0x80){temp_lsb = (temp_lsb/2);} // shift to get whole degree
temp_msb = temp_msb & 0x80; // mask all but the sign bit
if (temp_msb >= 0x80) {temp_lsb = (~temp_lsb)+1;} // twos complement
if (temp_msb >= 0x80) {temp_lsb = (temp_lsb/2);}// shift to get whole degree
if (temp_msb >= 0x80) {temp_lsb = ((-1)*temp_lsb);} // add sign bit
temp_c = temp_lsb; // ready for conversion to Fahrenheit
//temp_f = (((int)temp_c)* 9)/5 + 32;
return temp_c;
}
/* get power status of DS18x20
input : id = rom_code
returns: DS18X20_POWER_EXTERN or DS18X20_POWER_PARASITE */
uint8_t DS18X20_get_power_status(uint8_t id[])
{
uint8_t pstat;
ow_reset();
ow_command(DS18X20_READ_POWER_SUPPLY, id);
pstat=ow_bit_io(1); // pstat 0=is parasite/ !=0 ext. powered
ow_reset();
return (pstat) ? DS18X20_POWER_EXTERN:DS18X20_POWER_PARASITE;
}
unsigned char ds18x20_get_power_status(void)
{
ow_reset();
send_selected_rom();
ow_put_byte(READ_POWER_SUPPLY);
power_status=ow_get_bit();
ow_reset();
return(power_status);
}
void ds18x20_get_scratchpad(unsigned char *mem_array)
{
unsigned char x=0;
ow_reset();
send_selected_rom();
ow_put_byte(READ_SCRATCHPAD);
for(x=0; x<9; x++) {*(mem_array+x)=ow_get_byte(); }
ow_reset();
return;
}
void OneWireInit(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
ow_reset();
ow_write_byte(0xcc);
ow_write_byte(0x4e);
ow_write_byte(0);
ow_write_byte(0);
ow_write_byte(0x60); // 12 bit
ow_reset();
}
/* tempSense() - returns temperature (in celcius) of device ROM
* to specify which device is read, pass in the index of the device (ROM)
* in the foundROM array
*
* FINDING THE BOARD NUMBER OF A TEMPERATURE READ
* The board number is returned as the 16 MSB of tempSense()'s return
* value
* i.e. for temperature = tempSense(x) | 0x7F
* i.e. for board number = tempSense(x) >> 16
*/
int tempSense(int ROM) {
char get[10];
char temp_lsb, temp_msb;
int k, i;
ow_reset();
write_byte(0x55);
uDelay(10);
for(i = 0 ; i < 8 ; i++) {
write_byte(FoundROM[ROM][i]);
}
write_byte(0x44); // Start Conversion
uDelay(102);
ow_reset();
write_byte(0x55);
uDelay(10);
for(i = 0 ; i < 8 ; i++) {
write_byte(FoundROM[ROM][i]);
}
// Read Scratch Pad
write_byte(0xBE);
for (k=0;k<9;k++){
get[k]=read_byte();
}
temp_msb = get[1]; // Sign byte + lsbit
temp_lsb = get[0]; // Temp data plus lsb
// shift to get whole degree
if (temp_msb <= 0x80)
temp_lsb = (temp_lsb/2);
// mask all but the sign bit
temp_msb = temp_msb & 0x80;
// twos complement
if (temp_msb >= 0x80)
temp_lsb = (~temp_lsb)+1;
// shift to get whole degree
if (temp_msb >= 0x80)
temp_lsb = (temp_lsb/2);
// add sign bit
if (temp_msb >= 0x80)
temp_lsb = ((-1)*temp_lsb);
return (int)temp_lsb | get[2] << 16;
}
// FIND DEVICES
uint8_t FindDevices(void) {
unsigned char m;
// Begins when a presence is detected
if(!ow_reset()) {
// Begins when at least one part is found
if(First()) {
numROMs=0;
do {
numROMs++;
for(m=0;m<8;m++) {
// Identifies ROM number on found device
FoundROM[numROMs][m]=ROM[m];
}
#if OW_DEBUG
UART_printf("\nSENSOR = %d ROM = %02X %02X %02X %02X %02X %02X %02X %02X\n",
numROMs + 1, FoundROM[numROMs][0],FoundROM[numROMs][1],
FoundROM[numROMs][2],FoundROM[numROMs][3], FoundROM[numROMs][4],
FoundROM[numROMs][5],FoundROM[numROMs][6],FoundROM[numROMs][7]);
#endif
} while (Next()&&(numROMs<=NO_ROMS)); //Continues until no additional devices are found
}
}
return numROMs;
}
void ds18b20_recall_eeprom()
{
ow_reset();
ow_write_byte(0xCC);
ow_write_byte(0xB8);
__delay_us(50);
}
void ds18b20_read_rom(struct ds18b20 *dev)
{
//uint8_t romid[8];
//ow_init();
ow_reset();
ow_write_byte(0x33);
dev->romcode[0] = ow_read_byte();
dev->romcode[1] = ow_read_byte();
dev->romcode[2] = ow_read_byte();
dev->romcode[3] = ow_read_byte();
dev->romcode[4] = ow_read_byte();
dev->romcode[5] = ow_read_byte();
dev->romcode[6] = ow_read_byte();
dev->romcode[7] = ow_read_byte();
//printf("id 1 = %x\r\n", dev->romcode[0]);
//printf("id 2 = %x\r\n", dev->romcode[1]);
//printf("id 3 = %x\r\n", dev->romcode[2]);
//printf("id 4 = %x\r\n", dev->romcode[3]);
//printf("id 5 = %x\r\n", dev->romcode[4]);
//printf("id 6 = %x\r\n", dev->romcode[5]);
//printf("id 7 = %x\r\n", dev->romcode[6]);
//printf("id 8 = %x\r\n", dev->romcode[7]);
//*(id) = romid[1] | romid[0];
//*(id + 1) = romid[3] | romid[2];
//dev->address[0] = ((((unsigned long)romid[3] << 8) | (unsigned long)romid[2]) << 16) | (((unsigned long)romid[1] << 8) | romid[0]);
//dev->address[1] = ((((unsigned long)romid[7] << 8) | (unsigned long)romid[6]) << 16) | (((unsigned long)romid[5] << 8) | romid[4]);
//printf("Address 1 = %ld\r\n", dev->address[0]);
//printf("Address 2 = %ld\r\n", dev->address[1]);
}
static uint8_t search_sensors(void)
{
uint8_t i;
uint8_t id[OW_ROMCODE_SIZE];
uint8_t diff, nSensors;
ow_reset();
nSensors = 0;
diff = OW_SEARCH_FIRST;
while ( diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ) {
DS18X20_find_sensor( &diff, &id[0] );
if( diff == OW_PRESENCE_ERR ) {
break;
}
if( diff == OW_DATA_ERR ) {
break;
}
for ( i=0; i < OW_ROMCODE_SIZE; i++ ) {
gSensorIDs[nSensors][i] = id[i];
}
nSensors++;
}
return nSensors;
}
uint8_t search_sensors(void)
{
uint8_t i;
uint8_t id[OW_ROMCODE_SIZE];
uint8_t diff, nSensors;
ow_reset();
nSensors = 0;
diff = OW_SEARCH_FIRST;
while (diff != OW_LAST_DEVICE && nSensors < MAXSENSORS) {
ds18b20_find_sensor(&diff, &id[0]);
if (diff == OW_PRESENCE_ERR) {
//printf("no sensors\n");
break;
}
if (diff == OW_DATA_ERR) {
//printf("bus error\n");
break;
}
for (i = 0; i < OW_ROMCODE_SIZE; i++)
sensor_ids[nSensors][i] = id[i];
nSensors++;
}
return nSensors;
}
port_width Read1820(port_width error)
{
uint8_t l, m, pokus=0;
port_width errormask = (port_width)0x0001;
//???;*'vysledkom je 16 bytov v buffroch: 8x1.byte+8x2.byte...
do
{
owire(0xBE,error); //read scratch, save it to 1Wbuff, read 9 bytes, switch off power after finish)
for(l = 0;l<8;l++)
{
ow_inp(OWbuff,l,error); //zacinaj ukladat data vzdy od 1. dallasu byte "l"
}
ow_reset(error);
error = CheckCRC_8(OWbuff,error,8); //checkCRC
pokus++;
}while(error && (pokus < 5)); //cyklus, kym error !=0 alebo try=3 (tri pokusy o spravne nacitanie)
ow_rstprt(error);
if(error) //ak bola chyba v comm, tak data pri chybe = 0xFF
{
for(l=0;l<D_NUM;l++)
{
if(error & errormask)
{
for(m=0;m<8;m++)
OWbuff[l].data[m] = 0xFF;
}
errormask<<=1;
}
}
return(error);
}
static uint8_t search_sensors(void)
{
uint8_t i;
uint8_t id[OW_ROMCODE_SIZE];
uint8_t diff, nSensors;
uart_puts_P( NEWLINESTR "Scanning Bus for DS18X20" NEWLINESTR );
ow_reset();
nSensors = 0;
diff = OW_SEARCH_FIRST;
while ( diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ) {
DS18X20_find_sensor( &diff, &id[0] );
if( diff == OW_PRESENCE_ERR ) {
uart_puts_P( "No Sensor found" NEWLINESTR );
break;
}
if( diff == OW_DATA_ERR ) {
uart_puts_P( "Bus Error" NEWLINESTR );
break;
}
for ( i=0; i < OW_ROMCODE_SIZE; i++ )
gSensorIDs[nSensors][i] = id[i];
nSensors++;
}
return nSensors;
}
void ow_reset_demo(void)
{
unsigned char c1;
clear_screen();
printf("1-Wire-Reset: Test, ob JEMAND am Bus angeschlossen ist\n");
printf("======================================================\n");
printf("(Beenden durch Eingabe von 'e')");
printf("\n\nStart des Tests: Taste druecken ... ");
while(1)
{
set_cursor(7,2); printf(" ");
set_cursor(7,2);
c1=getchar();
if (c1 == 'e') break; // Rücksprung
// 1-Wire Reset durchführen
if (ow_reset()) printf(" Test NEGATIV: Keiner da !\n");
else printf(" Test POSITIV: Mindestens EINER da !\n");
printf("\n\nWeiter - Taste druecken ... ");
c1 = getchar();
}
}
uint8_t search_sensors(void)
{
uint8_t i;
uint8_t id[OW_ROMCODE_SIZE];
uint8_t diff, nSensors;
ow_reset();
nSensors = 0;
diff = OW_SEARCH_FIRST;
while ( diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ) {
DS18X20_find_sensor( &diff, &id[0] );
if( diff == OW_PRESENCE_ERR ) {
// CDC_Device_SendString (&VirtualSerial_CDC_InterfaceR, "No Sensor found \n\r");
break;
}
if( diff == OW_DATA_ERR ) {
// CDC_Device_SendString (&VirtualSerial_CDC_InterfaceR, "Bus Error \n\r");
break;
}
for ( i=0; i < OW_ROMCODE_SIZE; i++ )
gSensorIDs[nSensors][i] = id[i];
nSensors++;
}
return nSensors;
}
void owchip_geteui(uint8_t* eui) { // >= 6000us
uint8_t id[8];
int retry;
int crc;
uint8_t* byte;
uint16_t oldTactl;
retry = 5;
memset(eui,0,8);
// store current value of TACTL
oldTactl = TACTL;
// start timer in continuous mode at 1MHz
TACTL = TASSEL_2 | ID_2 | MC_2;
owpin_init();
while (retry-- > 0) {
crc = 0;
if(ow_reset()) {
ow_write_byte(0x33); //read rom
for(byte=id+7; byte>=id; byte--) {
crc = crc8_byte( crc, *byte=ow_read_byte() );
}
if(crc==0) {
// CRC valid
memcpy(eui,id,8);
}
}
}
// restore value of TACTL
TACTL = oldTactl;
}
void ow_set_bus(volatile uint8_t* in, volatile uint8_t* out,volatile uint8_t* ddr,uint8_t pin)
{
OW_DDR=ddr;
OW_OUT=out;
OW_IN=in;
OW_PIN_MASK=(1<<pin);
ow_reset();
}
static void ds18b20_start(void)
{
ow_reset();
ow_skip_rom();
ow_write_byte(DS18B20_CMD_CONVERT_T);
}
void
ow_command(uint8_t cmd, uint8_t pin)
{
ow_reset(pin);
/* To all devices */
ow_write_byte(OW_SKIP_ROM, pin);
ow_write_byte(cmd, pin);
}
void ds1820_wr_t_reg(unsigned char TH, unsigned char TL)
{
// Start mit Master-Reset-Impuls u. Abfrage: Slave presence
if(ow_reset())
{
printf("\n\n\n\n Fehler beim Schreiben des Scratch Pads 1: KEIN Presence vom Slave !");
printf("\n\n Reset druecken ... ");
while(1);
}
/********************************************/
/*** 1. Werte in Scratch Pad einschreiben ***/
/********************************************/
// Skip ROM-Befehl, da nur ein DS1820 angeschlossen ist
ow_wr_byte(0xcc);
// Schreib-Befehl senden: "WRITE SCRATCHPAD" = 0x4e
ow_wr_byte(0x4e);
// Byte 1 senden: Reg TH
ow_wr_byte(TH);
// Byte 2 senden: Reg TL
ow_wr_byte(TL);
// Msster sendet abschließenden Reset-Impuls
if(ow_reset())
{
printf("\n\n\n\n Fehler beim Schreiben des Scratch Pads 2: KEIN Presence vom Slave !");
printf("\n\n Reset druecken ... ");
while(1);
}
/****************************************************/
/*** 2. Werte vom Scratch Pad ins EEPROM kopieren ***/
/****************************************************/
// Skip ROM-Befehl, da nur ein DS1820 angeschlossen ist
ow_wr_byte(0xcc);
// Kopieren ins Scratch Pad (EEPROM)-Befehl senden: "COPY SCRATCHPAD" = 0x48
ow_wr_byte(0x48);
_wait_ms(15); // Wartezeit f. EPROM-Programmierung
}
/*
* Reads temp from the DS18B20
*/
double ds1820_read(void)
{
ADCSRA &= ~(1<<ADEN)|~(1<<ADSC);
uint8_t busy=0, temp1, temp2;
int16_t temp3;
double result;
ow_reset();
ow_byte_wr(0xCC);
ow_byte_wr(0x44);
while(busy == 0) {
busy = ow_byte_rd();
}
ow_reset();
ow_byte_wr(0xCC);
ow_byte_wr(0xBE);
temp1 = ow_byte_rd();
temp2 = ow_byte_rd();
/*onewire_write(0xCC); //Skip ROM, address all devices
onewire_write(0x44); //Start temperature conversion
while(busy == 0) //Wait while busy (bus is low)
busy = onewire_read();
onewire_reset();
onewire_write(0xCC); //Skip ROM, address all devices
onewire_write(0xBE); //Read scratchpad
temp1 = onewire_read();
temp2 = onewire_read();*/
temp3 = temp2;
temp3 = temp3 << 8;
temp3 = temp3 | temp1;
//result = (float) temp3 / 2.0; //Calculation for DS18S20 with 0.5 deg C resolution
result = (double) temp3 / 16.0; //Calculation for DS18B20
//_delay_ms(200);
return(result);
}
void ds18b20_read_scratch(struct ds18b20 *dev)
{
unsigned char i;
//unsigned char data[9];
//ow_init();
ow_reset();
//ow_write_byte(0xCC);
ow_write_byte(0x55);
for(i=0;i<8;i++){
ow_write_byte(dev->romcode[i]);
}
ow_write_byte(0xBE);
dev->scratchpad[0] = ow_read_byte();
dev->scratchpad[1] = ow_read_byte();
dev->scratchpad[2] = ow_read_byte();
dev->scratchpad[3] = ow_read_byte();
dev->scratchpad[4] = ow_read_byte();
dev->scratchpad[5] = ow_read_byte();
dev->scratchpad[6] = ow_read_byte();
dev->scratchpad[7] = ow_read_byte();
dev->scratchpad[8] = ow_read_byte();
//printf("data 1 = %x\r\n", dev->scratchpad[0]);
//printf("data 2 = %x\r\n", dev->scratchpad[1]);
//printf("data 3 = %x\r\n", dev->scratchpad[2]);
//printf("data 4 = %x\r\n", dev->scratchpad[3]);
//printf("data 5 = %x\r\n", dev->scratchpad[4]);
//printf("data 6 = %x\r\n", dev->scratchpad[5]);
//printf("data 7 = %x\r\n", dev->scratchpad[6]);
//printf("data 8 = %x\r\n", dev->scratchpad[7]);
//printf("data 9 = %x\r\n", dev->scratchpad[8]);
dev->config = dev->scratchpad[4];
dev->crc = dev->scratchpad[8];
//printf("TempDS = %d\r\n", ((dev->scratchpad[1] << 8) | (dev->scratchpad[0] >> 4)));
dev->tempi = (((0x07 & dev->scratchpad[1]) << 8) | dev->scratchpad[0]) >> 4;
if(dev->scratchpad[1] & 0xF0)
dev->tempi = -dev->tempi;
dev->tempd = dev->scratchpad[0] & 0x0F;
if( dev->tempd & 0x08 ){
dev->tempd = 5;
}else if( dev->tempd & 0x04 ){
dev->tempd = 25;
}else if( dev->tempd & 0x02 ){
dev->tempd = 125;
}else if( dev->tempd & 0x01 ){
dev->tempd = 625;
}
//printf("TempDS = %d.%d\r\n", dev->tempi, dev->tempd);
}
/* reads temperature (scratchpad) of sensor with rom-code id
output: subzero==1 if temp.<0, cel: full celsius, mcel: frac
in millicelsius*0.1
i.e.: subzero=1, cel=18, millicel=5000 = -18,5000°C */
uint8_t DS18X20_read_meas(uint8_t *id, uint8_t *subzero, uint8_t *cel, uint8_t *cel_frac_bits)
{
uint8_t i;
uint8_t sp[DS18X20_SP_SIZE];
ow_reset(); //**
ow_command(DS18X20_READ, id);
for ( i=0 ; i< DS18X20_SP_SIZE; i++ ) sp[i]=ow_byte_rd();
if ( crc8( &sp[0], DS18X20_SP_SIZE ) )
return DS18X20_ERROR_CRC;
DS18X20_meas_to_cel(id[0], sp, subzero, cel, cel_frac_bits);
return DS18X20_OK;
}
void ds18b20_start_convert(struct ds18b20 *dev)
{
unsigned char i;
ow_reset();
ow_write_byte(0x55);
for(i=0;i<8;i++){
ow_write_byte(dev->romcode[i]);
}
ow_write_byte(0x44);
__delay_ms(750);
}
/* start measurement (CONVERT_T) for all sensors if input id==NULL
or for single sensor. then id is the rom-code */
uint8_t DS18X20_start_meas( uint8_t with_power_extern, uint8_t id[])
{
ow_reset(); //**
if( ow_input_pin_state() ) { // only send if bus is "idle" = high
ow_command( DS18X20_CONVERT_T, id );
if (with_power_extern != DS18X20_POWER_EXTERN)
ow_parasite_enable();
return DS18X20_OK;
}
else {
return DS18X20_START_FAIL;
}
}
static int8_t ds18x_access(uint8_t *id)
{
int i;
if(!ow_reset(0))
return -1;
if(ow_write_byte(0, ROM_MATCH) < 0)
return -1;
for(i=0;i<8;i++)
if(ow_write_byte(0, id[i]) < 0)
return -1;
return 0;
}
u8 ow_2760_copy_data(u8 addr)
{
u8 ret;
ret = ow_reset();
if (ret)
{
return ret;
}
ow_byte_write(OW_CMD_SKIP_ROM);
ow_byte_write(OW_2760_COPY_DATA);
ow_byte_write(addr);
return 0;
}
u8 ow_2760_recall_data(u8 addr)
{
u8 ret;
ret = ow_reset();
if (ret)
{
return ret;
}
ow_byte_write(OW_CMD_SKIP_ROM);
ow_byte_write(OW_2760_RECALL_DATA);
ow_byte_write(addr);
return 0;
}
void ds18x20_set_reg(unsigned char reg, signed int value)
{
unsigned char scratchpad[9];
unsigned char x=0, write_end_pos=3;
if(ds18x20_rom_code[0]==DS18B20) { write_end_pos=4; }
ds18x20_get_scratchpad(scratchpad);
scratchpad[reg]=value;
ow_reset();
send_selected_rom();
ow_put_byte(WRITE_SCRATCHPAD);
/* write the byte, lsb first */
for(x=2; x<=write_end_pos; x++)
{
ow_put_byte(scratchpad[x]);
}
ow_reset();
return;
}
