C++ (Cpp) spi_stack_master_transceive Examples

Example #1

File: spi_stack_master.c Project: Tinkerforge/bricklib

void spi_stack_master_state_machine_loop(void *arg) {
	uint8_t sa_counter = 1;
    while(true) {
		// As long as receive buffer is not empty
    	// Or there are no stack participants, do nothing
    	if(spi_stack_buffer_size_recv == 0 && com_info.current != COM_NONE) {
    		// If nothing to send ask for data round robin
			if(spi_stack_buffer_size_send == 0) {
				spi_stack_select(sa_counter);
				spi_stack_master_transceive();
				spi_stack_deselect();
	    		spi_stack_master_insert_position(spi_stack_buffer_recv, sa_counter);
				if(sa_counter == com_info.last_stack_address) {
					sa_counter = 1;
				} else {
					sa_counter++;
				}
			}

			// If something to send, handle it first
			else {
				if((spi_stack_send_to < SPI_ADDRESS_MIN) ||
				   (spi_stack_send_to > com_info.last_stack_address)) {
					RouteTo route_to = routing_route_stack_to(spi_stack_buffer_send[0] |
					                                          (spi_stack_buffer_send[1] << 8) |
					                                          (spi_stack_buffer_send[2] << 16) |
					                                          (spi_stack_buffer_send[3] << 24));
					spi_stack_send_to = route_to.to;
				}
				spi_stack_select(spi_stack_send_to);
				spi_stack_master_transceive();
				spi_stack_deselect();
	    		spi_stack_master_insert_position(spi_stack_buffer_recv, spi_stack_send_to);


			}
		}
		taskYIELD();
    }
}

Example #2

void routing_table_create_stack(void) {
	uint8_t stack_address = 0;
	uint8_t tries = 0;
	while(stack_address < SPI_ADDRESS_MAX) {
		StackEnumerate se;
		com_make_default_header(&se, 0, sizeof(StackEnumerate), FID_STACK_ENUMERATE);

		uint32_t options = stack_address + 1;
		if(spi_stack_send(&se, sizeof(StackEnumerate), &options) != 0) {
			spi_stack_select(stack_address + 1);

			tries = 0;
			while(!spi_stack_master_transceive() && tries < 10) {
				SLEEP_MS(50);
				tries++;
			}
			if(tries == 10) {
				break;
			}

			spi_stack_deselect();

			spi_stack_buffer_size_recv = 0;
		}

		StackEnumerateReturn ser;
		tries = 0;
		while(tries < 10) {
			SLEEP_MS(50);
			spi_stack_select(stack_address + 1);
			spi_stack_master_transceive();
			spi_stack_deselect();
			if(spi_stack_recv(&ser, sizeof(StackEnumerateReturn), NULL)) {
				break;
			}
			tries++;
		}

		if(tries == 10) {
			logspise("Did not receive answer for Stack Enumerate\n\r");
			break;
		}

		stack_address++;
		com_info.last_stack_address = stack_address;

		for(uint8_t i = 0; i < STACK_ENUMERATE_MAX_UIDS; i++) {
			if(ser.uids[i] != 0) {
				if(routing_table_size >= ROUTING_TABLE_MAX_SIZE) {
					break;
				}
				routing_table[routing_table_size].uid = ser.uids[i];
				routing_table[routing_table_size].route_to.to = ROUTING_STACK;
				routing_table[routing_table_size].route_to.option = stack_address;
				routing_table_last_stack = routing_table_size;
				routing_table_size++;
				logspisi("New Stack participant (sa, uid): %d, %lu\n\r", stack_address, ser.uids[i]);
			}
		}
	}

	spi_stack_buffer_size_send = 0;
}