fork(1) download
copy 
  1. #include "hspi.h"
  2.  
  3. //#include <stdio.h>
  4. //#include <string.h>
  5.  
  6. #include "py/nlr.h"
  7. #include "py/obj.h"
  8. #include "py/runtime.h"
  9. #include "py/binary.h"
  10. #include "portmodules.h"
  11.  
  12.  
  13. STATIC mp_obj_t hspi_txchunk(mp_obj_t data) {
  14.  
  15. //	for offset in range(0, len(buf), 10): # iterate trough data 10 bytes at the time
  16. //		sdata = buf[offset : offset + 10] # buf is a bytearray
  17. //		hspitxchunk.send(sdata)
  18. 	if (!MP_OBJ_IS_TYPE(data, &mp_type_bytearray)) {
  19. 		nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "takes bytearray"));
  20. 	}
  21. 	// uint8_t dlen;
  22. 	// dlen = mp_obj_len(data);
  23.  
  24. 	mp_buffer_info_t bufinfo;
  25. 	mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ); 
  26.  
  27. //	const char *str = mp_obj_str_get_str(data);
  28. //	for (; *str; ++str) {
  29.  
  30. //		int chr = *(uint8_t*)str;
  31. //	}
  32.  
  33. 	uint16_t tat = bufinfo.len / 10;
  34. 	uint16_t trm = bufinfo.len % 10;
  35. 	uint8_t nbytes = 10;
  36. 	for (uint32_t t = 0; t < (tat + 1); t++) {
  37. 		if (t == tat) { //remainder bytes?
  38. 			nbytes = trm;
  39. 		}
  40.  
  41. 		uint8_t cmdbits = 0;
  42. 		uint32_t addrbits = 0;
  43. 		uint32_t doutbits = 0;
  44. 		uint8_t cshift = 0;
  45. 		uint8_t ashift = 0;
  46. 		uint8_t dshift = 0;
  47.  
  48. 		for (uint8_t bl = 0; bl < nbytes; bl++)
  49. 		{
  50. 			if (cmdbits < 16) {
  51. 				cmdbits = cmdbits + 8;
  52. 				cshift += 1;
  53. 			}
  54. 			else {
  55. 				if (addrbits < 32) {
  56. 					addrbits = addrbits + 8;
  57. 					ashift += 1;
  58. 				}
  59. 				else {
  60. 					if (doutbits < 32) {
  61. 						doutbits = doutbits + 8;
  62. 						dshift += 1;
  63. 					}
  64. 					else {
  65. 						break;
  66. 					}
  67. 				}
  68. 			}
  69. 		}
  70.  
  71. 		uint16_t cmddata = 0;
  72. 		uint32_t addrdata = 0;
  73. 		uint32_t doutdata = 0;
  74. 		const uint8_t *p = (const uint8_t*)bufinfo.buf;
  75. 		p = &p[t * 10];
  76.  
  77. 		for (uint8_t n = 0; n < 4; n++)
  78. 		{
  79. 			if (n <= 1) {
  80. 				if (((n + 1) * 8) <= cmdbits) {
  81. 					cmddata |= (p[n] << (8 * (1 - n)));
  82. 				}
  83. 			}
  84. 			if (addrbits != 0) {
  85. 				if (((n + 1) * 8) <= addrbits) {
  86. 					addrdata |= (p[n + 2] << (8 * (3 - n)));
  87. 				}
  88. 			}
  89. 			if (doutbits != 0) {
  90. 				if (((n + 1) * 8) <= doutbits) {
  91. 					doutdata |= (p[n + 6] << (8 * (3 - n)));
  92. 				}
  93. 			}
  94. 		}
  95.  
  96. 		cmddata = cmddata >> ((2 - cshift) * 8);
  97. 		addrdata = addrdata >> ((4 - ashift) * 8);
  98. 		doutdata = doutdata >> ((4 - dshift) * 8);
  99.  
  100. 		while (spi_busy(1)) {};  // Wait for SPI to be ready
  101.  
  102. 		// Enable SPI Functions
  103. 		// Disable MOSI, MISO, ADDR, COMMAND, DUMMY in case previously set.
  104. 		CLEAR_PERI_REG_MASK(SPI_USER(1), SPI_USR_MOSI | SPI_USR_MISO | SPI_USR_COMMAND | SPI_USR_ADDR | SPI_USR_DUMMY);
  105.  
  106. 		// Setup Bitlengths
  107. 		WRITE_PERI_REG(SPI_USER1(1),
  108. 			// Number of bits in Address
  109. 			((addrbits - 1) & SPI_USR_ADDR_BITLEN) << SPI_USR_ADDR_BITLEN_S |
  110. 			// Number of bits to Send
  111. 			((doutbits - 1) & SPI_USR_MOSI_BITLEN) << SPI_USR_MOSI_BITLEN_S);
  112.  
  113. 		// Setup Command Data
  114. 		if (cmdbits) {
  115. 			// Enable COMMAND function in SPI module
  116. 			SET_PERI_REG_MASK(SPI_USER(1), SPI_USR_COMMAND);
  117. 			// Align command data to high bits
  118. 			uint16_t command = cmddata << (16 - cmdbits);
  119. 			// Swap byte order
  120. 			command = ((command >> 8) & 0xff) | ((command << 8) & 0xff00);
  121. 			WRITE_PERI_REG(SPI_USER2(1), (
  122. 				(((cmdbits - 1) & SPI_USR_COMMAND_BITLEN) << SPI_USR_COMMAND_BITLEN_S) |
  123. 				(command & SPI_USR_COMMAND_VALUE)
  124. 				));
  125. 		}
  126.  
  127. 		// Setup Address Data
  128. 		if (addrbits) {
  129. 			// Enable ADDRess function in SPI module
  130. 			SET_PERI_REG_MASK(SPI_USER(1), SPI_USR_ADDR);
  131. 			// Align address data to high bits
  132. 			WRITE_PERI_REG(SPI_ADDR(1), addrdata << (32 - addrbits));
  133. 		}
  134.  
  135. 		// Setup DOUT data
  136. 		if (doutbits) {
  137. 			// Enable MOSI function in SPI module
  138. 			SET_PERI_REG_MASK(SPI_USER(1), SPI_USR_MOSI);
  139. 			// Copy data to W0
  140. 			if (READ_PERI_REG(SPI_USER(1))&SPI_WR_BYTE_ORDER) {
  141. 				WRITE_PERI_REG(SPI_W0(1), doutdata << (32 - doutbits));
  142. 			}
  143. 			else {
  144. 				WRITE_PERI_REG(SPI_W0(1), doutdata);
  145. 			}
  146. 		}
  147.  
  148. 		// Begin SPI Transaction
  149. 		SET_PERI_REG_MASK(SPI_CMD(1), SPI_USR);
  150. 	}
  151. 	// Transaction completed
  152. 	return mp_const_none; //return None
  153. }
  154.  
  155.  
  156. STATIC MP_DEFINE_CONST_FUN_OBJ_1(hspitxchunk_send_obj, hspi_txchunk);
  157. //STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(hspitxchunk_send_obj, 1, 10, hspi_txchunk);
  158.  
  159. // declare python module
  160. STATIC const mp_map_elem_t hspitxchunk_globals_table[] = {
  161. 	{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_hspitxchunk) },
  162. 	{ MP_OBJ_NEW_QSTR(MP_QSTR_send), (mp_obj_t)&hspitxchunk_send_obj },
  163. };
  164.  
  165. STATIC MP_DEFINE_CONST_DICT(mp_module_hspitxchunk_globals, hspitxchunk_globals_table);
  166.  
  167. const mp_obj_module_t mp_module_hspitxchunk = {
  168. 	.base = { &mp_type_module },
  169. 	//.name = MP_QSTR_hspitxchunk, // depricated
  170. 	.globals = (mp_obj_dict_t*)&mp_module_hspitxchunk_globals,
  171. };
  172. // end declaration
  173.  
  174.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.c:1:18: fatal error: hspi.h: No such file or directory
 #include "hspi.h"
                  ^
compilation terminated.
stdout
copy 
Standard output is empty
https://ideone.com/SZ62N8
language:
C (gcc 8.3)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!