/*---------------------------------------------------------------------------*/
#if 1 /* But ok! */
unsigned
sht11_sreg(void)
{
unsigned sreg, rcrc;
sstart(); /* Start transmission */
if(!swrite(STATUS_REG_R)) {
goto fail;
}
sreg = sread(1);
rcrc = sread(0);
#ifdef CRC_CHECK
{
unsigned crc;
crc = crc8_add(0x0, STATUS_REG_R);
crc = crc8_add(crc, sreg);
if (crc != rev8bits(rcrc))
goto fail;
}
#endif
return sreg;
fail:
sreset();
return -1;
}
/*---------------------------------------------------------------------------*/
static void
sreset(void)
{
int i;
SDA_1();
SCL_0();
for(i = 0; i < 9 ; i++) {
SCL_1();
delay_400ns();
SCL_0();
}
sstart(); /* Start transmission, why??? */
}
int
sht11_reset(void)
{
sstart(); /* Start transmission */
if(!swrite(RESET)) {
goto fail;
}
return 0;
fail:
sreset();
return -1;
}
int
sht11_set_sreg(unsigned sreg)
{
sstart(); /* Start transmission */
if(!swrite(STATUS_REG_W)) {
goto fail;
}
if(!swrite(sreg)) {
goto fail;
}
return 0;
fail:
sreset();
return -1;
}
/*
* Only commands MEASURE_HUMI or MEASURE_TEMP!
*/
static unsigned int
scmd(unsigned cmd)
{
unsigned int n;
if(cmd != MEASURE_HUMI && cmd != MEASURE_TEMP) {
PRINTF("Illegal command: %d\n", cmd);
return -1;
}
sstart(); /* Start transmission */
if(!swrite(cmd)) {
PRINTF("SHT11: scmd - swrite failed\n");
goto fail;
}
for(n = 0; n < 20000; n++) {
if(!SDA_IS_1) {
unsigned t0, t1, rcrc;
t0 = sread(1);
t1 = sread(1);
rcrc = sread(0);
PRINTF("SHT11: scmd - read %d, %d\n", t0, t1);
#ifdef CRC_CHECK
{
unsigned crc;
crc = crc8_add(0x0, cmd);
crc = crc8_add(crc, t0);
crc = crc8_add(crc, t1);
if(crc != rev8bits(rcrc)) {
PRINTF("SHT11: scmd - crc check failed %d vs %d\n",
crc, rev8bits(rcrc));
goto fail;
}
}
#endif
return (t0 << 8) | t1;
}
/* short wait before next loop */
clock_wait(1);
}
fail:
sreset();
return -1;
}
phantom_thread_t *
phantom_create_thread( void (*func)(void *), void *arg, int flags )
{
assert( ! (flags & ~CREATION_POSSIBLE_FLAGS) );
#if USE_FORK_LUKE
phantom_thread_t *t = calloc(1, sizeof(phantom_thread_t));
// Can't be run yet
t->sleep_flags = THREAD_SLEEP_LOCKED;
t->thread_flags = 0;
t->tid = find_tid(t);
t->name = "?";
//t->priority = THREAD_PRIO_NORM;
int ssize = 64*1024;
t->stack_size = ssize;
t->stack = calloc( 1, ssize );
assert(t->stack != 0);
t->start_func_arg = arg;
t->start_func = func;
phantom_thread_state_init(t);
// Let it be elegible to run
//t->sleep_flags &= ~THREAD_SLEEP_LOCKED;
//t_enqueue_runq(t);
GET_CURRENT_THREAD()->child_tid = t->tid;
GET_CURRENT_THREAD()->thread_flags |= THREAD_FLAG_PARENT;
t->thread_flags |= THREAD_FLAG_CHILD;
if(t_prepare_fork())
{
// child - NEW STACK, no local vars are accessible
phantom_thread_t *me = GET_CURRENT_THREAD();
void (*sstart)(void *) = me->start_func;
sstart(me->start_func_arg);
panic("thread returned");
}
// parent
return t;
#else
//phantom_thread_t *t = find_thread();
phantom_thread_t *t = calloc(1, sizeof(phantom_thread_t));
// Can't be run yet
t->sleep_flags = THREAD_SLEEP_LOCKED;
t->tid = find_tid(t);
common_thread_init(t, 64*1024 );
//t->priority = THREAD_PRIO_NORM;
t->start_func_arg = arg;
t->start_func = func;
phantom_thread_state_init(t);
t->thread_flags |= flags;
// Let it be elegible to run
t->sleep_flags &= ~THREAD_SLEEP_LOCKED;
t_enqueue_runq(t);
return t;
#endif
}
