extern void segment_map_test(umMem_T memory) 
{        
        for (int i = 1; i <= 7; i++) {
                segment_map(memory, i, i * 2);
        }
        
        for (int i = 1; i <= 7; i++) {
                int reg_val = register_get(memory, i);
                fprintf(stderr, "regID: %d, segID: %d, segLength: %d\n", i, 
                        reg_val, segment_length(memory, reg_val));
        }
        
        for (int i = 1; i <= 7; i+=2) {
                fprintf(stderr, "i: %d\n", i);
                segment_unmap(memory, i);
        }
        for (int i = 1; i <= 7; i+=2) {
                segment_map(memory, i, i + 10);
        }
        
        for (int i = 1; i <= 7; i++) {
                int reg_val = register_get(memory, i);
                fprintf(stderr, "regID: %d, segID: %d, segLength: %d\n", i, 
                        reg_val, segment_length(memory, reg_val));
        }

}
Exemple #2
0
static size_t op_put(Vis *vis, Text *txt, OperatorContext *c) {
	size_t pos = c->pos;
	bool sel = text_range_size(&c->range) > 0;
	bool sel_linewise = sel && text_range_is_linewise(txt, &c->range);
	if (sel) {
		text_delete_range(txt, &c->range);
		pos = c->pos = c->range.start;
	}
	switch (c->arg->i) {
	case VIS_OP_PUT_AFTER:
	case VIS_OP_PUT_AFTER_END:
		if (c->reg->linewise && !sel_linewise)
			pos = text_line_next(txt, pos);
		else if (!sel)
			pos = text_char_next(txt, pos);
		break;
	case VIS_OP_PUT_BEFORE:
	case VIS_OP_PUT_BEFORE_END:
		if (c->reg->linewise)
			pos = text_line_begin(txt, pos);
		break;
	}

	size_t len;
	const char *data = register_get(vis, c->reg, &len);

	for (int i = 0; i < c->count; i++) {
		text_insert(txt, pos, data, len);
		pos += len;
	}

	if (c->reg->linewise) {
		switch (c->arg->i) {
		case VIS_OP_PUT_BEFORE_END:
		case VIS_OP_PUT_AFTER_END:
			pos = text_line_start(txt, pos);
			break;
		case VIS_OP_PUT_AFTER:
			pos = text_line_start(txt, text_line_next(txt, c->pos));
			break;
		case VIS_OP_PUT_BEFORE:
			pos = text_line_start(txt, c->pos);
			break;
		}
	} else {
		switch (c->arg->i) {
		case VIS_OP_PUT_AFTER:
		case VIS_OP_PUT_BEFORE:
			pos = text_char_prev(txt, pos);
			break;
		}
	}

	return pos;
}
extern void register_PutGet_test(umMem_T memory)
{
        uint32_t array[8];
        
        for (int i = 0; i < 8; i++) {
                array[i] = (uint32_t) (i * 10);
        }
        
        for(int i = 0; i < 8; i++) {
                register_put(memory, i, array[i]);
        }
        for(int i = 0; i < 8; i++) {
                if (register_get(memory, i) != array[i]) {
                        fprintf(stderr, "Register %d has incorrect value\n", i);
                }
        } 
        
        fprintf(stderr, "register_PutGet is fine with valid inputs\n");
}
int main(void)
{
    uint8_t msglen = 0;
    uint8_t msg[BUS_MAXRECVMSGLEN];
    uint16_t sender = 0;
    uint16_t module_id = 0;

    io_initialize();
    clk_initialize();
    scomm_initialize_uart1(&g_serial_phy);

    //register_set_u16(MOD_eReg_ModuleID, 0x0003);
    register_get(MOD_eReg_ModuleID, 0, &module_id);
    bus_configure(&g_bus, module_id);
    bus_initialize(&g_bus, 0);// initialize bus on UART 0

    sei();
    LED_STATUS_OFF;
    LED_ERROR_OFF;
    clk_timer_start(&g_LED_timer, CLOCK_MS_2_TICKS(1000));

    while (1) {
        // check for message and read it
        if (bus_get_message(&g_bus)) {
            bgw_forward_bus_msg(&g_bus, &g_serial_phy);
            if (bus_read_message(&g_bus, &sender, &msglen, msg)) {
                interpret_message(sender, msglen, msg);
            }
        }
        bgw_forward_serial_msg(&g_bus, &g_serial_phy);

        if (clk_timer_is_elapsed(&g_LED_timer)) {
        	// cyclic reset of error LED
            LED_ERROR_OFF;
            LED_STATUS_TOGGLE;
            clk_timer_start(&g_LED_timer, CLOCK_MS_2_TICKS(1000));
        }
    }
    return 0;
}
int main (void)
{
    uint8_t msglen = 0;
    uint8_t msg[BUS_MAXRECVMSGLEN];
    uint16_t module_id = BUS_UNKNOWNADR, sender = 0, val;
    uint16_t new_temp;

    DDRC |= ((1<<PC3) | (1<<PC4));
    PORTC &= ~((1<<PC3) | (1<<PC4));

    clk_initialize();

    //register_set_u16(MOD_eReg_ModuleID, 0x000E);

    // configure a bus node with address X
    register_get(MOD_eReg_ModuleID, 0, &module_id);
    bus_configure(&g_bus, module_id);
    bus_initialize(&g_bus, 0);// initialize bus on UART 0

    spi_master_init_blk();
    zagw_initialize();

    sei();

    register_get(APP_eReg_DesiredTempDay1, 0, &g_target_temp);

    gdisp_initialize();
    gdisp_goto_col_line(0,0);
    gdisp_put_text("aktuell");

    gdisp_goto_col_line(61,0);
    gdisp_put_text("Soll");

    draw_temperatures();
    draw_window_closed();

    gdisp_choose_font(gdisp_font1_x8);
    gdisp_goto_col_line(0,3);
    gdisp_put_text("Addr: ");
    draw_hex16_value(g_bus.sCfg.uOwnNodeAddress);

    clk_timer_start(&g_app_timer, 100);
    while (1) {
        if (bus_get_message(&g_bus)) {
            if (bus_read_message(&g_bus, &sender, &msglen, msg)) {
                interpret_message(&g_bus, msg, msglen, sender);
            }
        }
        if (clk_timer_is_elapsed(&g_app_timer)) {
            clk_timer_start(&g_app_timer,10);
            gdisp_choose_font(gdisp_font1_x8);
            gdisp_goto_col_line(0,3);
            gdisp_put_text("Temp: ");
            if (zagw_receive()) {
                val = zagw_get_bits();
                draw_hex16_value(val);
                new_temp = zagw_get_temperature();
                if (new_temp != g_current_temp) {
                    send_temperature(new_temp);
                }
                g_current_temp = new_temp;
                draw_temperatures();
            } else {
                gdisp_put_text("PERR");
            }
        }
    }
    return 0;
}