hi,
nachdem ichs jetzt dank euch geschafft habe, die pins vom parallelen port einzeln anzusteuern, gleich das nächste problem:
servos werden wie folgt angesteuert:
1.5 ms signal solltn den servo mittig ausrichten.
jetzt habe ich ein kleines c-programm geschrieben, dass den servo bis zum anschlag drehen sollte:
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
#include <stdio.h>
#include <parapin.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
inline void mysleep(int usecsleep) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = usecsleep;
select(1, NULL, NULL, NULL, &tv);
}
int main() {
#define D1 LP_PIN02
#define D2 LP_PIN03
#define D3 LP_PIN04
#define D4 LP_PIN05
#define D5 LP_PIN06
#define D6 LP_PIN07
#define D7 LP_PIN08
#define D8 LP_PIN09
if( pin_init_user(LPT1) == -1 ) {
printf("Initialisierung Fehlgeschlagen!\n");
}
pin_output_mode(D6);
printf("Setze D2 an (Spannungsversorgung)\n");
set_pin(D2);
sleep(1);
printf("Und los gehts\n");
int timetosleep = 1000, i;
for( i = 0; i < 1000; i++) {
set_pin(D6);
mysleep(timetosleep);
clear_pin(D6);
mysleep(20000 - timetosleep);
}
clear_pin(D2);
printf("Setze D2 aus... (Spannungsversorgung)\n");
printf("Fertig!!\n");
return 0;
}
|
wie man sieht, schlafe ich die pausen nicht mit usleep, sleep o.ä., sondern mit select, weil usleep ticks zählt und die mit 20ms vieel zu lang sind.
das ist mit sleep leider nur beding besser:
|
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
#include <stdio.h>
#include <unistd.h>
#include <sys/times.h>
#include <sys/types.h>
void my_usleep(unsigned int microseconds);
int main()
{
my_usleep(1e6);
my_usleep(1e5);
my_usleep(1e4);
my_usleep(1e3);
my_usleep(1e2);
my_usleep(1);
printf("Finished\n");
}
void mysleep(int usecsleep) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = usecsleep;
select(1, NULL, NULL, NULL, &tv);
}
void my_usleep(unsigned int microseconds)
{
clock_t tick1=-1, tick2=-1;
double dClock = -1;
struct tms tStruct1, tStruct2;
if((tick1 = times(&tStruct1))== -1) printf("Error time 1\n");
mysleep(microseconds);
if((tick2 = times(&tStruct2))== -1) printf("Error time 2\n");
if((dClock = sysconf(_SC_CLK_TCK)) < 0) printf("Error sysconf \n");
printf("mysleep(%d) takes %6.2f ms\n", microseconds, (1000*(tick2 -
tick1)/dClock) );
return;
}
|
gibt
|
|
Quellcode
|
1
2
3
4
5
6
7
|
mysleep(1000000) takes 1000.00 ms
mysleep(100000) takes 100.00 ms
mysleep(10000) takes 20.00 ms
mysleep(1000) takes 0.00 ms
mysleep(100) takes 0.00 ms
mysleep(1) takes 10.00 ms
Finished
|
manchmal auch leicht anders.
eigentlich sollte man doch denken, dass das dabei rauskäme:
|
|
Quellcode
|
1
2
3
4
5
6
7
|
mysleep(1000000) takes 1000.00 ms
mysleep(100000) takes 100.00 ms
mysleep(10000) takes 10.00 ms
mysleep(1000) takes 1.00 ms
mysleep(100) takes 0.10 ms
mysleep(1) takes 0.01 ms
Finished
|
tuts aber nicht.
also tut auch der servo nix, obwohl alle spannungen stimmen und alles richtig verkabelt ist. das warten auf den nächsten puls geht einfach nicht.
frage ist: wie kann ich microsekundengenau warten / kann ich das überhaupt?
danke,
Lorenz
