Matrisberäkningar med för STM32?

[Al_Bundy]

Blir dina sizeof verkligen rätt i den där koden?
Kör några printf för att kolla om dom verkligen är rätt.
Tror du bara får storleken på en pekare, men jag är osäker.

Normalt så kör jag denna kod. Här får jag samma resultat.

Read 10 bytes. Received message: 1136


Read 10 bytes. Received message: 1270,1208,
Read 12 bytes. Received message: 187,1135


Read 10 bytes. Received message:


Read 11 bytes. Received message: 1262,1242,1
Read 13 bytes. Received message:
Read 12 bytes. Received message: 1175,1152


Read 10 bytes. Received message: 60


Read 10 bytes. Received message: 1265,1243,
Read 13 bytes. Received message: 213,1136


Read 12 bytes. Received message: 248,1160


Read 10 bytes. Received message:
Read 12 bytes. Received message: 7,1208,1105

Read 10 bytes. Received message: 6


Read 12 bytes. Received message: 228,1216,115
Read 11 bytes. Received message: 99


Read 10 bytes. Received message: 24


Read 13 bytes. Received message:
Read 10 bytes. Received message: 8


Read 12 bytes. Received message: 4,1203,1115

Read 10 bytes. Received message:
Read 14 bytes. Received message: 1264,1158


Read 11 bytes. Received message: 1153


Read 12 bytes. Received message: 66,1195,1136
Read 10 bytes. Received message:

Read 10 bytes. Received message: 1168

Kod: Markera allt

/*
 * Here we are going to read the USB
 */
int readUSB(struct USB* stm32) {

	/*
	 * Reset
	 */
	while(1){
	memset(&stm32->readBuffer, '\0', sizeof(stm32->readBuffer));

	/*
	 * Read
	 */
	tcflush(stm32->serialPort, TCIFLUSH);
	int receiveBytes = read(stm32->serialPort, &stm32->readBuffer, sizeof(stm32->readBuffer));

	/*
	 * receiveBytes is the number of bytes read. receiveBytes may be 0 if no bytes were received, and can also be -1 to signal an error.
	 */
	if (receiveBytes < 0) {
		printf("Error reading: %s", strerror(errno));
	}

	/*
	 * Print it out
	 */
	printf("Read %i bytes. Received message: %s\n", receiveBytes, stm32->readBuffer);
	sleep(1);
	}

	return 0;
}

[bearing]

Jag hade fel angående sizeof. Det går såklart utmärkt att skriva så.

Angående ditt problem så gissar jag att det har med tcflush och sleep(1) och att göra. När du flushar så kastar du ju en massa information, vilket antagligen är anledningen till att du får halva meddelanden. Dessutom, med en hel sekunds sleep så kanske buffern hinner fyllas innan du skriver ut något. Läs oftare, och kör printf när du samlat på dig en hel mening.

Men du kan ju till att börja med testa att lägga in något sånt här i slutet:

Kod: Markera allt

	/*
    * Print it out
    */
    printf("Read %i bytes.\n", receiveBytes);
	int printedBytes = 0;
	do {
		if (stm32->buffer[printedBytes] == '\0')
		{
			printedBytes++;
		}
		else
		{
			printf("Received message: ");
			printedBytes += printf("%s", &stm32->buffer[printedBytes]);
			printf("\n");
		}
	} while (printedBytes < receiveBytes);

[Al_Bundy]

Jag testade utan att spola bort värdena och testade att ändra några flaggor. Utan spolningen gav endast skillnaden att jag han fylla upp till 256 bytes för varje iteration.

Men jag ska testa din kod. Återkommer. Du tror inte det har något med handskakning att göra?

Edit:
Den fungerar inte. Jag tror att jag måste ha någon typ av handskakning. Min STM32 verkar ha det då det går utmärkt att läsa USB-värdena från andra program.
Hur man programmerar handskakning vet jag inte.

[bearing]

Jag har inte satt mig in i ditt system, så jag vet inte vad för handskakning som sker.
Hur ofta skicka din stm32 värden då?
Om du ligger och sover en hel sekund i datorn, och din stm32 skickar konstant, är det ju klart att din buffer fylls hela tiden. Du måste så klart ha timern i din stm32. Så att den skickar en gång per sekund. Och datorn skriver ut när den fått ett paket.

Vad innebär det att min kod inte fungerade då?
Här är programmet som jag testade koden med, om du vill veta hur det fungerar.
Edit, ändrade "buffer" till "readBuffer"

Kod: Markera allt

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
struct serial_data_t
{
	char readBuffer[100];
};

int readBuffer(struct serial_data_t *s)
{
	memset(&s->readBuffer, '!', sizeof(s->readBuffer));
	for (int i = 0; i <= 99; i += 9)
	{
		s->readBuffer[i] = '\0';
	}
	return sizeof(s->readBuffer);
}

int main()
{
	struct serial_data_t serial;
	struct serial_data_t *stm32 = &serial;
	int receiveBytes = readBuffer(stm32);
	
   /*
    * Print it out
    */
    printf("Read %i bytes.\n", receiveBytes);
   int printedBytes = 0;
   do {
      if (stm32->readBuffer[printedBytes] == '\0')
      {
         printedBytes++;
      }
      else
      {
         printf("Received message: ");
         printedBytes += printf("%s", &stm32->readBuffer[printedBytes]);
         printf("\n");
      }
   } while (printedBytes < receiveBytes);
	
	return 0;
}
}

[Al_Bundy]

Jag kan bifoga min stm32 kod.

Min STM32 skickar hela tiden så snabbt som det kan gå. Linux i terminalen verkar klara av det.

Edit: Jag kan inte kompilera din kod. Det verkar saknas något. Men jag laddar även upp mitt projekt. Importera in det med Eclipse.

[bearing]

Ja men då är det ju självklart att du får det här felet. Du ligger ju och sover i en hel sekund i ditt program. Buffern fylls ju direkt. Läs mitt inlägg ovan igen, jag har lagt till lite info.

Jag har inte eclipse, och jag tänker inte lägga mer tid på det här nu.

[Al_Bundy]

Okej.

Men om min STM32 skickar hela tiden, varför klarar då detta kommando att läsa?

Kod: Markera allt

dell@dell-Precision-M6400:~/Dokument/eclipse-c-workspace/.metadata/.plugins/org.eclipse.core.resources/.safetable$ cat < /dev/ttyACM0
1280,1230,1148
1280,1219,1142
1268,1273,1191
1243,1217,1158
1262,1248,1175
1248,1227,1173
1264,1200,1128
1258,1174,1106
1280,1199,1145
1256,1195,1122
1257,1185,1102
1268,1242,1125

Så här blev det när jag hade 100ms fördröjning på STM21 och 0ms fördröjning på C-koden.

Read 3 bytes. Received message:
Read 4 bytes. Received message: 1224
Read 11 bytes. Received message: ,1160,1080

Read 5 bytes. Received message:

Read 3 bytes. Received message: 123
Read 11 bytes. Received message: 9,1174,1090
Read 6 bytes. Received message:


Read 1 bytes. Received message: 1
Read 12 bytes. Received message: 238,1126,110
Read 7 bytes. Received message: 7


Read 12 bytes. Received message: 1253,1189,11
Read 8 bytes. Received message: 05


Read 10 bytes. Received message: 1230,1141,
Read 10 bytes. Received message: 1094


Read 10 bytes. Received message: 1216,1159,
Read 10 bytes. Received message: 1080


Read 8 bytes. Received message: 1242,114
Read 12 bytes. Received message: 5,1101


Read 7 bytes. Received message: 1260,11
Read 4 bytes. Received message: 90,1
Read 9 bytes. Received message: 109


Read 6 bytes. Received message: 1239,1
Read 12 bytes. Received message: 172,1096


Read 2 bytes. Received message:
Read 5 bytes. Received message: 1221,
Read 12 bytes. Received message: 1126,1090


Read 3 bytes. Received message:
Read 4 bytes. Received message: 1267
Read 12 bytes. Received message: ,1212,1120


Read 4 bytes. Received message:
Read 3 bytes. Received message: 123
Read 12 bytes. Received message: 7,1177,1090

Read 5 bytes. Received message:

Read 3 bytes. Received message: 125
Read 11 bytes. Received message: 1,1176,1098
Read 6 bytes. Received message:


Read 2 bytes. Received message: 12
Read 12 bytes. Received message: 32,1145,1104
Read 6 bytes. Received message:


Read 1 bytes. Received message: 1
Read 11 bytes. Received message: 249,1193,11
Read 8 bytes. Received message: 00


Read 11 bytes. Received message: 1225,1178,1
Read 9 bytes. Received message: 080


Read 10 bytes. Received message: 1300,1229,
Read 10 bytes. Received message: 1149


Read 10 bytes. Received message: 1230,1166,
Read 10 bytes. Received message: 1081


Read 9 bytes. Received message: 1246,1193
Read 11 bytes. Received message: ,1096


Read 9 bytes. Received message: 1266,1150
Read 11 bytes. Received message: ,1136


Read 7 bytes. Received message: 1231,11
Read 13 bytes. Received message: 79,1077

[bearing]

Kolla om det finns något sätt att läsa en hel mening. Annars får du göra det själv genom att t.ex. vänta på ett CR, läsa till nästa CR, och printa bokstäverna emellan.

Du kan ju utgå från min kod ovan t.ex. byt ut '\0' mot asciikoden för CR. Och så vidare.

[Al_Bundy]

Någon som vet hur man kan skicka mer än 8 bit via STM32 där en UART är på 8-bit? Jag har ett 12-bits värde att skicka.

Bästa vore om man kunde typ skicka 12 bit 101011001101, men jag vet inte hur.

Kanske man ska göra om jag har typ värdet 3984, som är ett 12-bits värde (0 till 4095) Då skickar jag 8 bit först och sedan 4 bit sedan? Eller måste jag dela upp 3984 i flera delar? Typ 15 delar 255 och resten typ 160?

[AndLi]

Skicka 2x8 bitar... Vaska 4 bitar...

Eller så slår du ihop de två 4bitars talen till ett 8 bitars.. och vipps så vaskar du inga bitar längre. Men det kräver ju att du kan vänta på nästa mätvärde.

[Al_Bundy]

Hur menar du?

Vi säger att jag har talet 510. Då kan jag dela upp det i 255 och 255. Dvs jag skickar 8 bitar två gånger. Eventuellt om jag har 610 så skickar jag 255, 255, 100. Men det känns som det blir många iterationer om man har ett värde på 4095.

[Icecap]

Tja - för att göra det enkelt för dig: skicka 2 bytes. Den första innehåller de 7 lägsta bits och MSB ställd till '0', Alltså mellan 0x00 och 0x7F.

Andra byten innehåller bit 7-13 och har MSB ställd till '1', alltså kommer värdet alltid att vara mellan 0x80 och 0xFF.

Det ger ett total på 14 bitar du kan överföra, alltså värde mellan 0 och 16383.

Hur gör man det?
'Value' är den 16-bitars variabel som innehåller talet som ska skickas.
Första byte = Value & 0x7F;
Andra byte = 0x80 | (Value >> 7);

Mottagning då?
'Temp' är en static integer.
'Rx_Byte' är en läst byte.
if(0x80 & Rx_Byte) Value = Temp + ((Rx_Byte & 0x7F) << 7); // Här är värdet samlat
else Temp = Rx_Byte;

Men JAG hade föredragit att köra det som text:
char Buffer[10];
sprintf(Buffer, "%u\r", Value);
Sedan skickas att tecken från starten av Buffer fram till noll nås.

Mottagningen då?

Kod: Markera allt

char Buffer[10];
if(Rx_Byte != '\r') sprintf(Buffer + strlen(Buffer), "%c", Rx_Char);
else
  {
  Value = atoi(Buffer);
  Buffer[0] = 0;

På detta vis kan man enkelt skicka värden med upp till 9 siffror men med större buffer kan de bli större.

[Al_Bundy]

Nu kan jag endast skicka integers och inte hex. Men du skickar väll en sträng?

[Icecap]

Jag brukar skicka vad jag vill. Dels värden i decimalt och dels hex för checksum.
Ibland är det fastformat i hex.

[Al_Bundy]

Nu har jag börjat fått kontroll över det jag skickar.

Read 3 bytes. Received message: ���
Read 1 bytes. Received message: .
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ���@
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ���U
Read 4 bytes. Received message: ���.
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ����
Read 1 bytes. Received message: �
Read 3 bytes. Received message: ��(
Read 2 bytes. Received message: ��
Read 2 bytes. Received message: ��
Read 3 bytes. Received message: ���
Read 1 bytes. Received message: �
Read 4 bytes. Received message: ���`
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ���k
Read 4 bytes. Received message: ���Z
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ����
Read 4 bytes. Received message: ���)
Read 4 bytes. Received message: ����
Read 1 bytes. Received message: �
Read 3 bytes. Received message: ���
Read 2 bytes. Received message: ��
Read 2 bytes. Received message: �H
Read 3 bytes. Received message: ���

med C-koden..

Kod: Markera allt

// send 8 bits at the time, due to UART is 8 bit


		for(int i = 0; i < 3; i++){
			int size = (int) (ceil((adcValues[i]+1)/256)); // e.g 4096/256 will give us size 16

			uint8_t sendArray[size];

			for(int j = 0; j < size; j++)
				sendArray[j] = 256 -1;

			sendArray[size - 1] = ((adcValues[i]+1) % 256) -1; // Modulus for last message

			HAL_UART_Transmit(&huart2, sendArray, sizeof(sendArray), 10);
			HAL_Delay(10);
		}

Nu gäller det bara att försöka läsa in ASCII tecken till int.