josheeg
Member
I made a virtual com port reader program that is in c for linux and mac it prints to the screen or could print to a text file.
it is under 50 lines of code.
Why did I do it I thought python or other interpreted languages would be too slow for a ft2232h that I am using for a parrellel in serial out virtual com port high speed usb device. USB1232h module works nice but the USB label on the chip in the documentation lead me to insering it backwards but it works now that I have it in the right way.
josheeg
Member
here is the code I will test it on the maple latter today.
it compiles for linux and mac not windows I used teensy++ websites serial_listen.c Com port benchmark program.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
// To compile on Ubuntu or Mac OS X with xcode:
// gcc -O3 -Wall -o serial_listen serial_listen.c
const char *begin_string="10 second speed test begins";
const char *end_string="done!\r\n";
#define END_LEN 7
int main(int argc, char **argv)
{
int buf[64];
int port;
long n, sum=0, dotcount=0;
struct termios settings;
if (argc < 2) {
fprintf(stderr, "Usage: serial_listen <port>\n");
#if #system(linux)
fprintf(stderr, "Example: serial_listen /dev/ttyACM0\n");
#else
fprintf(stderr, "Example: serial_listen /dev/cu.usbmodem12341\n");
#endif
return 1;
}
// Open the serial port
port = open(argv[1], O_RDONLY);
if (port < 0) {
fprintf(stderr, "Unable to open %s\n", argv[1]);
return 1;
}
// Configure the port
tcgetattr(port, &settings);
cfmakeraw(&settings);
tcsetattr(port, TCSANOW, &settings);
// Read data until we get a see the end string or get an error
printf("Reading from %s\n", argv[1]);
while (1) {
n = read(port, buf, sizeof(buf));
while(n>0){
printf("%d",buf[n]);
n--;
}
}
return 0;
}
gbulmer
Moderator
That's a helpful post.
I think it would be more generally useful if these changes are made ...
1. Change:
int buf[64];
to
char buf[256];
2. Change
while(n>0){
printf("%d",buf[n]);
n--;
}to
for (int i=0; i<n; ++i){
putchar(buf[i]);
}This will act like a dumb terminal.
It print exactly the characters sent, and not 32-bit numbers (which may be what you wanted, but is less useful in general).
It will print the characters in the order sent, rather than reverse order.
HTH
(WARNING - Just typed in here, and not compiled or tested, so may still contain errors)
josheeg
Member
This is tested a little more the teensy sends a 1 when the button is pressed and a 0 otherwise.
The reason I am sending numbers is I have a ft2232h module called the usb1232h it puts the ft2232h in a nice easy to put into a white breadboard module with support components.
The maple triggers the sclk and loads the data into 8 ads1298 biopotential mesurement chips made by ti. The modules I made boards for in kicad a free and open source cad program. The serial program is modified from the serial speed test program on teensy++ boards website.
code
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
// To compile on Ubuntu:
// gcc -O3 -Wall -o serial_listen serial_listen.c
int main(int argc, char **argv)
{
int sendata=0;//intiger to move byte into to be seen as a number
int n=0; //character byte for read to return
char buf[16384];//bytes characters
int port;//serial port vareable
struct termios settings;
//check for serial port address
if (argc < 2) {
fprintf(stderr, "Example: serial_listen /dev/ttyACM0\n");
return 1;
}
// Open the serial port at address given in read only state
port = open(argv[1], O_RDONLY);
if (port < 0) {
fprintf(stderr, "Unable to open %s\n", argv[1]);
return 1;
}
// Configure the port by reading the information & set it to raw now
tcgetattr(port, &settings);
cfmakeraw(&settings);
tcsetattr(port, TCSANOW, &settings);
// Read data forever
printf("Reading from %s\n", argv[1]);
while (1) {
n = read(port, buf, sizeof(buf));//read bytes n = number read, buff is a array of characters sizeof tells how large the buffer is.
while (n>0) { //read all that was read one at a time
sendata=buf[n];//convert character into intiger type
sendata=sendata-48;//make character number into numeric number equivelent
printf("%d",sendata);
n--;
}
}
}
code
here is where the board files are if anyone wants to take a look at the newest ones go by date...
gbulmer
Moderator
Did that file contain a copyright message, e.g.
Copyright (c) 2008 PJRC.COM, LLC"
and did it contain a permission statement like this:
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
I interpret the part saying
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
as meaning even copies posted in forums should carry the whole notice.
josheeg
Member
actualy you can look at the code and I referenced the code describing it was used for the teensy++ but it does not have any sort of header the comments say what to tipe in to compile it.
here is the link
http://www.pjrc.com/teensy/usb_serial.html
it is called serial_listen.c
now the chip I am using is a FIFO first in first out buffer if my software printed first in to first out that would make the most sence first being closer to bottom right...
gbulmer
Moderator
josheeg - Thank you very much for clearing up my concern.
I follow the LUFA blog and mailing list, and have looked at the Teensy stuff, so I believe PJRC are careful about copyright.
As you point out, that file has no explicit copyright statement.
So how fast does this go?
josheeg
Member
Well I do not know I know the ft2232h is supposed to have usb high speed ability.
so since each analog to digital converter outputs 16K samples per second. Also eatch converter outputs 24 bits per channel their are 8 per chip and 24 bits of status information.
216 bits per chip 16k samples per second
so if ther is one chip per data in pin of the ft2232h chip the rate required would be 216 bytes every sample 16k samples per second.
every 64 samples passes a send imediately pin would be toggled.
How I change this part I do not know help?
Data written to the transmit buffer is sent to the host PC within the TX buffer timeout value (default 16mS) and placed in the buffer that was created when the USB port was opened. The FT245R allows the TX buffer timeout value to be reprogrammed to a value between 1 and 255mS.
I am confused when you said before
"for (int i=0; i<n; ++i){
putchar(buf[i]);
}"
That is clearer to add than subtract...
But this confuses me I wanted to let the first in be the first out...
"This will act like a dumb terminal.
It print exactly the characters sent, and not 32-bit numbers (which may be what you wanted, but is less useful in general).
It will print the characters in the order sent, rather than reverse order.
HTH"
gbulmer
Moderator
The sequence of bytes received by the host program will be the same sequence as sent by the microcontroller.
so, if the microcontroller has something like:
void loop() {
byte b = ...;
Serial.print(b, BYTE);
}The the host code will read the bytes in a block:
n = read(port, buf, sizeof(buf));
Then the for loop will print them out in the same order as they are sent.
But
while(n>0){
printf("%d",buf[n]);
n--;
}Will print the block out backwards (last into the block, first to be printed), but each block will be printed 'forwards' (block 0 will precede block 1). That is probably not what is wanted as the FTDI chip will be packing bytes on the basis of time, and the size of its buffer
It gets more complex if the microcontroller tries to send a block of binary, for example an int (e.g. using write) because the host may store the bytes of an int in a different sequence from the microcontroller (big-endian vs little-endian). So I always control the sequence of bytes (marshalling) sent by writing my code rather than rely on the systems.
HTH
josheeg
Member
The code compiles...
I thought sending 8 bit bytes from my ft2232h chip because that is all it sends.
The maple controls the sclk or serial clock of the ads1298 biopotential mesurement chip made by TI.
So you can see I don't want to read if as characters letters because eatch bit of the 8 bits is the 24th to 1st bit of eatch ads1298 chip they output serial data.
they sample 24 bit samples 8 of them at once per chip so 8 chips is 64 measurements.
the chip takes in 16k samples per second outputing them when data ready pin goes low then the maple toggles sclk on sclk going high the bit of eatch chip is shifted out on low eatch bit is captured in the write buffer of the ft2232h.
My open source project is here please if you want check out the latest kicad files the boards are made using open source software in linux.
https://sites.google.com/site/openloopproject/
// Read data forever
printf("Reading from %s\n", argv[1]);
while (1) {
n = read(port, buf, sizeof(buf));//read bytes n = number read, buff is a array of characters sizeof tells how large the buffer is.
for (i=0; i<n; ++i){
sendata=buf[i];//convert character into intiger type
sendata=sendata-48;//make character number into numeric number equivelent
printf("%d",sendata);
}
}//end of infinite while loop
}//end of main
josheeg
Member
I agree the characters are simpler to transfer over the serial port and probably still work based on linux and mac using differen endian systems or different hardware etc.
But I am stuck having to send a lot of data fast. Also since I will have to do masking I think to take the bits of the data and split it back up into the channels specific samples.
8 chips with 1 serial line eatch go to the ft2232h high speed usb module called the usb1232h. eatch chip sends msb first 24 bits data then 24 bits chanel 1-8 or 0-7 how ever you count it.
so if all 8 chips are syncronised to complete their conversion at the same time the msb first to least goes out as bytes to the pc.
gbulmer
Moderator
josheeg - I do not understand exactly what needs to happen to the data once the host has received it.
I would expect that the 24-bit samples will have to be extracted and turned into 24bit numbers anyway so that they can be used, so I don't feel that is extra work.
If a Maple (or Arduino) were sending the data, then using SerialUSB.print(value, BYTE) sends it as binary data.
It is exactly 8 bits of binary data, it has not been converted to a ASCII digit character, so it shouldn't significantly impact the transfer time, because it doesn't cause the data to get bigger or even change.
So there is no need to do:
sendata=sendata-48;//make character number into numeric number equivelent
that subtracts 48 from a number who's value is in the range 0 to 255, and so creates a number in the range -48 to 207.
I think I now understand what the data looks like. I think it is 8 ADC's x 24bits/ADC, or 8x3bytes = 24bytes
The 1st byte contains 8 bits, msb from each ADC, then the next byte is has the msb-1 bit from each of the 8 ADC's, and so on.
In a pseudo notation, the first byte is
ADC[7].bit(23) << 7 | ADC[6].bit(23) << 6 | ADC[5].bit(23) << 5 | ADC[4].bit(23) << 4
| ADC[3].bit(23) << 3 | ADC[2].bit(23) << 2 | ADC[1].bit(23) << 1 | ADC[0].bit(23) << 0 |
then next is bit 22, and so on, down to bit 0.
I think I understand why you want to stream it that way.
If I have understood, what is needed is to read data at the host, and assemble blocks of exactly the right size, which is 24bytes , then extract the 8 x 24-bit values, process them, then move on, and get the next 24byte block.
(A complication is the read() system call does not have to return the number of bytes requested, it can return fewer. But maybe ignore that for now.)
Do I understand what is happening?
josheeg
Member
If a Maple (or Arduino) were sending the data, then using SerialUSB.print(value, BYTE) sends it as binary data.
But read() reads returns characters and that would mean it would return the character representation of the number. ... can I setup read differently?
Or should I printf some way to make the number show up not the character symbols? Like printing the hex or octal equivalent.???
Fgetc() fputc() both have characters defined in their name is their a one for 8 bit numbers?
I think when I set a character to a number it does a character to number conversion.
That I think is why I did...
sendata=sendata-48;//make character number into numeric number equivalent
I think I tried this with the button being what is sent up the maples port that button should be on arduinos. So it printed 1 and 0 instead of 48... the same happens if I toggle the lowest data bit on the usb1232h module with the ft2232h chip on it.
I read here that I am reading charactrers as if I am reading a file...
http://www.cprogramming.com/tutorial/cfileio.html
Binary Output: For binary File Output you use fread.
The declarations for each are similar:
size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);
The data looks like.: there is 16 differential inputs per adc 8 samples are taken 24 bits per sample or 8x3 bytes eatch + 24 bits of status registers gain GPIO status etc. 24X8=192+24=216 bits per chip 1728 bits per 8 chips at 16ksps.
Bandwith required 27.648 Mbits per second 3.456 M Bytes per second.
On teensy++ virtual com port usb serial transfer benchmark is
1.157 MBytes/sec
That is why the teensy and maple USB is not fast enough and I had soo much trouble finding a way to get the data to the pc fast enough.The maple controls the System clock or sclk and that same pin actuates the write on the ft2232h.The FT2232H is a USB 2.0 Hi-Speed (480Mb/s) to UART/FIFO IC.
Page 29 on adobe reader & 29 on the ads1298 data sheet show.
Most significant bit first, 24 status bits, channel 1 MSB first for all 24 bits eatch, ch2, ch3, ch4, ch5, ch6, ch7, ch8
(A complication is the read() system call does not have to return the number of bytes requested, it can return fewer. But maybe ignore that for now.)
This is true but I know for the teensy++ reading 64Bytes at a time is the most efficent transfer of USB data. That is the packet size unless it is larger for High Speed USB it could be....
so you can see how if it trys to read 64 and the device sent 64 that would match up over time.
Do I understand what is happening? Mostly every sample is 24 bits there is 8 and before that there is 24 bits of status info transmited MSB first.
gbulmer
Moderator
Let's try to break the problem into pieces.
But read() reads returns characters and that would mean it would return the character representation of the number. ... can I setup read differently?
The read() system call reads bytes from a file or raw stream without any interpretation or change. It is the appropriate way to read raw binary data.
Or should I printf some way to make the number show up not the character symbols? Like printing the hex or octal equivalent.???
Let's put the problem of how to output the numbers from the host program to one side for a moment, and focus on getting the data across correctly. It may be correct to printf() each 24-bit value, but that depends on what needs to happen to the data once the program has got it.
Fgetc() fputc() both have characters defined in their name is their a one for 8 bit numbers?
The names may be causing some confusion. fgetc() and fputc() both handle a byte (fgetc() can return a non-byte value to signal end of file or an error, too), so they are the ones for 8 bit numbers.
I think when I set a character to a number it does a character to number conversion.
read(), write(), fgetc() and fputc() should not change the binary representation of values written or read from a stream once the stream is set to 'raw' on a normal operating system. So no, if you Serial.print(value, BYTE) the number 0x30, it will not be converted, but will be sent as the byte with hexadecimal value 0x30.
I think I tried this with the button being what is sent up the maples port that button should be on arduinos. So it printed 1 and 0 instead of 48... the same happens if I toggle the lowest data bit on the usb1232h module with the ft2232h chip on it.
I'd need to understand what all of the parts in the stream were to give an answer. A conversion may have happened, or not.
I read here that I am reading charactrers as if I am reading a file...
http://www.cprogramming.com/tutorial/cfileio.html
That is correct. Reading and writing characters is reading and writing bytes.
Binary Output: For binary File Output you use fread.
For FILE* output, you'd use fwrite(), but I think I understand what you mean. fread() and fwrite() work for FILE*.
But open() does not return a FILE*, it returns a file descriptor (a small integer, which the Operating system uses to keep track of the underlying file).
I don't think you need to change to using FILE*. You can use open() and read() to get the data into the host program.
so you can see how if it trys to read 64 and the device sent 64 that would match up over time.
Don't focus on the most efficient size to do the transfer. Try to get the program working correctly first. The underlying operating system will be handling buffers, and should smooth things out.
Try to focus on getting the data blocks communicated correctly, and decode it into something easier to use.
I'd recommend finding a way to slow down the data rate so that it is easy to test, and ensure everything works correctly.
You must log in to post.