inline static void _draw_char(int c, uint32_t x, uint32_t y, uint16_t fore, uint16_t back) {
uint32_t i, j;
uint8_t line;
unsigned char *p = (unsigned char *) cp437_font + (c * (int) FONT_CHAR_H);
uint16_t buffer[FONT_CHAR_H * FONT_CHAR_W];
uint16_t *q = buffer;
for (i = 0; i < FONT_CHAR_H; i++) {
line = (uint8_t) *p++;
for (j = 0; j < FONT_CHAR_W; j++) {
if ((line & 0x1) != 0) {
*q = __builtin_bswap16(fore);
} else {
*q = __builtin_bswap16(back);
}
line >>= 1;
q++;
}
}
write_command(0x2A);
write_data_word(x);
write_data_word(x + FONT_CHAR_H - 1);
write_command(0x2B);
write_data_word(y);
write_data_word(y + FONT_CHAR_W - 1);
write_command(0x2C);
bcm2835_spi_writenb((char *) buffer, 2 * FONT_CHAR_H * FONT_CHAR_W);
}
void Display_Clear_Rect(unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int co)
{
int i, j;
write_command(0x2a);
write_data(x>>8&0xff);write_data(x&0xff);
x += w -1;
write_data(x>>8&0xff);write_data(x&0xff);
write_command(0x2b);
write_data((y)>>8&0xff);write_data((y)&0xff);
y += h - 1;
write_data((y)>>8&0xff);write_data((y)&0xff);
write_command(0x2C);
for (j=0; j<h; j++) {
for (i=0; i<w; i++) {
LCD_DataWrite(co>>8&0xff, co&0xff);
}
}
#if 0
write_command(0x2a);
write_data(0);write_data(0);
write_data(W>>8&0xff);write_data(W&0xff);
write_command(0x2b);
write_data(0);write_data(0);
write_data(H>>8&0XFF);write_data(H);
#endif
}
void LCD_ExitSleep_ILI9340C(void)
{
write_command(0x11);//Exit Sleep
delay(120);
write_command(0x29);//Display on
write_command(0x2C);
}
void main(){
init_lcd();
clear_screen();
choose_screen(1);
write_command(x|0);
write_command(y|0);
write_data(0x01<<0);
while(1);
}
void addset(unsigned int x,unsigned int y)
{
write_command(ILI9341_CASET); // Column addr set
wr_com16(x>>8,x);
write_command(ILI9341_PASET); // Row addr set
wr_com16(y>>8,y);
write_command(ILI9341_RAMWR); // write to RAM
}
void Address_set (unsigned int x1, unsigned int x2, unsigned int y1, unsigned int y2)
{
write_command (0x2a); // x -axis
write_data (x1);
write_data (x2);
write_command(0x2b); // y -axis
write_data (y1);
write_data (y2);
write_command(0x2c);
}
void clear_screen(){
unsigned char x,y;
choose_screen(0);
for(x=0xb8;x<0xc0;x++){
write_command(x);
write_command(0x40);
for(y=0;y<64;y++){
write_data(0);
}
}
}
void ili9340_clear(void) {
write_command(0x2A);
write_data_word(0);
write_data_word(239);
write_command(0x2B);
write_data_word(0);
write_data_word(319);
write_command(0x2C);
bcm2835_spi_writenb((char *) buffer, 2 * ILI9340_HEIGHT * ILI9340_WIDTH);
}
int hokuyo_init(HokuyoLaser* hokuyoLaser){
if (hokuyoLaser->fd<=0){
return -1;
}
#ifdef HOKUYO_ALWAYS_IN_SCIP20
fprintf(stderr, "\nAssuming laser is already in SCIP2.0 mode!\n");
fprintf(stderr, " (if the dirver hangs, either your Hokuyo has the old\n");
fprintf(stderr, " firmware or you have to disable -DHOKUYO_ALWAYS_IN_SCIP20\n");
fprintf(stderr, " in the Makefile of the laser driver)\n");
hokuyoLaser->isContinuous=0;
hokuyoLaser->isProtocol2=1;
#else
// stop the device anyhow
fprintf(stderr, "Stopping the device... ");
write_command(hokuyoLaser,HK_QUIT);
write_command(hokuyoLaser,HK_QUIT);
write_command(hokuyoLaser,HK_QUIT);
fprintf(stderr, "done\n");
hokuyoLaser->isContinuous=0;
// The UTM-30LX functions only in SCIP2.0 Mode, as do some URG's
fprintf(stderr, "Switching to enhanced mode (SCIP2.0)... ");
fprintf(stderr, " (if the dirver hangs you probably configured your Hokuyo\n");
fprintf(stderr, " so that SCIP is alwas on. IN this case, enable the Option\n");
fprintf(stderr, " CFLAGS += -DHOKUYO_ALWAYS_IN_SCIP20\n");
fprintf(stderr, " in the Makefile of the laser driver)\n");
int status=hokuyo_readStatus(hokuyoLaser, HK_SCIP,1);
if (status==0){
fprintf(stderr, "\nSwitching to SCIP 2.0 was successful!\n");
hokuyoLaser->isProtocol2=1;
} else {
fprintf(stderr, "Error. Unable to switch to SCIP2.0 Mode, please upgrade the firmware of your device.\n");
return -1;
}
#endif
fprintf(stderr, "Device initialized successfully\n");
hokuyoLaser->isInitialized=1;
hokuyo_readStatus(hokuyoLaser, "\nVV\n", 1);
hokuyo_readStatus(hokuyoLaser, "\nPP\n", 1);
hokuyo_readStatus(hokuyoLaser, "\nII\n", 1);
return 1;
}
void Display_Clear(unsigned int co)
{
unsigned char i,j;
write_command(0x2a);
write_data(0x00);write_data(0x00);
write_command(0x2b);
write_data(0x00);write_data(0x00);
write_command(0x2C);
for (i=0;i<H;i++)
for (j=0;j<W;j++)
LCD_DataWrite(co>>8&0xff, co&0xff);
}
int main(int argc, char** argv) {
if (argc < 3) {
printf("Usage: jattach <pid> <cmd> <args> ...\n");
return 1;
}
int pid = atoi(argv[1]);
if (!check_socket(pid) && !start_attach_mechanism(pid)) {
printf("Could not start attach mechanism\n");
return 1;
}
int fd = connect_socket(pid);
if (fd == -1) {
printf("Could not connect to socket\n");
return 1;
}
printf("Connected to remote JVM\n");
write_command(fd, argc - 2, argv + 2);
printf("Response code = ");
read_response(fd);
printf("\n");
close(fd);
return 0;
}
int main(int argc,char *argv[])
{
if(argc < 3) return usage(argc, argv);
// set and check device name
char* tmp=argv[1];
if(strcmp(tmp,"1") && strcmp(tmp,"2")) return usage(argc, argv);
char devname[12];
sprintf(devname, "/dev/schar%s",tmp);
printf("devname %s\n",devname);
int commandnum = atoi( argv[2] );
printf("commandnum=%d\n",commandnum);
int adrnum = 0;
if (argc > 3){
adrnum = atoi( argv[3] );
printf("adrnum=%02x\n",adrnum);
}
// open device
eth_open(devname);
eth_register_mac();
int e=write_command(commandnum,adrnum);
// close device
eth_close();
return e;
}
void ili9340_draw_pixel(uint16_t x, uint16_t y, uint16_t color) {
if (x >= ILI9340_HEIGHT)
return;
if (y >= ILI9340_WIDTH)
return;
write_command(0x2A);
write_data_word(x);
write_data_word(x);
write_command(0x2B);
write_data_word(y);
write_data_word(y);
write_command(0x2C);
write_data_word(color);
}
void process_command(char *command)
{
char *token;
char *search = " ";
strtok(command, "\n");
token = strtok(command, search);
if (strcmp(token, "download") == 0) {
token = strtok(NULL, search);
int download_id = atoi(token);
if (in_download_range(download_id)) {
printf("Downloading %i", download_id);
write_command(download_id);
current_download = download_id;
global_state = GotIndex;
}
else {
printf("Log ID %i outside available range\n", download_id);
need_input = true;
}
}
else if (strcmp(token, "exit") == 0) {
keep_running = false;
}
else {
printf("Possible commands:\n"
" download <lognumber>\n"
" help\n"
" exit\n");
need_input = true;
}
}
int adjust_time()
{
long heure_serveur, heure_locale;
int res,code;
char *buf;
Date_offset=0;
write_command(CMD_DATE, 0, NULL);
res=read_server_with_reconnect(tcp_line_read, 3, MAX_READ_SIZE-1);
if (debug) fprintf(stderr,"Yo :%s\n",tcp_line_read);
if (res<0) return -1;
buf=strchr(tcp_line_read,' ');
code = time(NULL);
if (buf) {
code=strtol(buf+9,&buf,10);
heure_serveur=code %100 + 60*(((code/100)%100) + 60*(((code/10000)%100)));
} else
heure_serveur=code;
heure_locale=time(NULL);
/* heure_locale = mktime(gmtime(&heure_locale))%86400; */
Date_offset = ((heure_serveur - heure_locale)%86400);
if (Date_offset > 43200) Date_offset = Date_offset - 86400;
if (Date_offset < -43200) Date_offset = Date_offset + 86400;
if (debug)
fprintf(stderr,"Yu :%ld %ld %d\n",heure_serveur,
heure_locale,Date_offset);
return 0;
}
static void network_shutdown(struct iio_context *ctx)
{
struct iio_context_pdata *pdata = ctx->pdata;
unsigned int i;
iio_mutex_lock(pdata->lock);
write_command("\r\nEXIT\r\n", pdata->fd);
close(pdata->fd);
iio_mutex_unlock(pdata->lock);
for (i = 0; i < ctx->nb_devices; i++) {
struct iio_device *dev = ctx->devices[i];
struct iio_device_pdata *dpdata = dev->pdata;
if (dpdata) {
network_close(dev);
iio_mutex_destroy(dpdata->lock);
free(dpdata);
}
}
iiod_client_destroy(pdata->iiod_client);
iio_mutex_destroy(pdata->lock);
freeaddrinfo(pdata->addrinfo);
free(pdata);
}
/**
* open_stream_for_write_2
* @filename: Filename of new stream
* @geom_filename: The geometry filename to copy
* @argc: The number of arguments to the program
* @argv: The arguments to the program
*
* Creates a new stream with name @filename, and adds the stream format
* and version header, plus a verbatim copy of the geometry file
*
* You may want to follow this with a call to write_command() to record the
* command line.
*
* Returns: a %Stream, or NULL on failure.
*/
Stream *open_stream_for_write_2(const char *filename,
const char *geom_filename, int argc,
char *argv[])
{
Stream *st;
st = malloc(sizeof(struct _stream));
if ( st == NULL ) return NULL;
st->fh = fopen(filename, "w");
if ( st->fh == NULL ) {
ERROR("Failed to open stream.\n");
free(st);
return NULL;
}
st->major_version = LATEST_MAJOR_VERSION;
st->minor_version = LATEST_MINOR_VERSION;
fprintf(st->fh, "CrystFEL stream format %i.%i\n",
st->major_version, st->minor_version);
fprintf(st->fh, "Generated by CrystFEL "CRYSTFEL_VERSIONSTRING"\n");
fflush(st->fh);
if ( (argc > 0) && (argv != NULL) ) {
write_command(st, argc, argv);
}
if ( geom_filename != NULL ) {
write_geometry_file(st, geom_filename);
}
return st;
}
static long exec_command(const char *cmd, int fd)
{
long resp;
ssize_t ret = write_command(cmd, fd);
if (ret < 0)
return (long) ret;
DEBUG("Reading response\n");
ret = read_integer(fd, &resp);
if (ret < 0) {
char buf[1024];
iio_strerror(-ret, buf, sizeof(buf));
ERROR("Unable to read response: %s\n", buf);
return (long) ret;
}
#if LOG_LEVEL >= DEBUG_L
if (resp < 0) {
char buf[1024];
iio_strerror(-resp, buf, sizeof(buf));
DEBUG("Server returned an error: %s\n", buf);
}
#endif
return resp;
}
static int network_close(const struct iio_device *dev)
{
struct iio_device_pdata *pdata = dev->pdata;
int ret = -EBADF;
iio_mutex_lock(pdata->lock);
if (pdata->fd >= 0) {
ret = iiod_client_close_unlocked(dev->ctx->pdata->iiod_client,
pdata->fd, dev);
write_command("\r\nEXIT\r\n", pdata->fd);
close(pdata->fd);
pdata->fd = -1;
}
#ifdef WITH_NETWORK_GET_BUFFER
if (pdata->memfd >= 0)
close(pdata->memfd);
pdata->memfd = -1;
if (pdata->mmap_addr) {
munmap(pdata->mmap_addr, pdata->mmap_len);
pdata->mmap_addr = NULL;
}
#endif
iio_mutex_unlock(pdata->lock);
return ret;
}
pcap_dumper_t *
priv_pcap_dump_open(pcap_t *p, char *fname)
{
int fd, err;
FILE *f;
if (priv_fd < 0)
errx(1, "%s: called from privileged portion", __func__);
if (fname[0] == '-' && fname[1] == '\0') {
f = stdout;
priv_init_done();
} else {
write_command(priv_fd, PRIV_OPEN_OUTPUT);
fd = receive_fd(priv_fd);
must_read(priv_fd, &err, sizeof(err));
if (fd < 0) {
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
"Failed to open output file %s: %s",
fname, strerror(err));
return (NULL);
}
f = fdopen(fd, "w");
if (f == NULL) {
snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
fname, pcap_strerror(errno));
close(fd);
return (NULL);
}
}
(void)sf_write_header(f, p->linktype, p->tzoff, p->snapshot);
return ((pcap_dumper_t *)f);
}
/*
* Set address window.
*/
static void set_window(int x0, int y0, int x1, int y1)
{
write_command(S6D04H0_Column_Address_Set);
write_data(x0 >> 8);
gpanel_write_byte(x0);
gpanel_write_byte(x1 >> 8);
gpanel_write_byte(x1);
write_command(S6D04H0_Page_Address_Set);
write_data(y0 >> 8);
gpanel_write_byte(y0);
gpanel_write_byte(y1 >> 8);
gpanel_write_byte(y1);
write_command(S6D04H0_Memory_Write);
}
/*
* Switch the screen orientation.
*/
static void set_rotation(int rotation)
{
write_command(S6D04H0_Memory_Data_Access_Control);
switch (rotation & 3) {
case 0: /* Portrait */
write_data(MADCTL_MY | MADCTL_BGR);
_width = 240;
_height = 320;
break;
case 1: /* Landscape */
write_data(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
_width = 320;
_height = 240;
break;
case 2: /* Upside down portrait */
write_data(MADCTL_MX | MADCTL_BGR);
_width = 240;
_height = 320;
break;
case 3: /* Upside down landscape */
write_data(MADCTL_MV | MADCTL_BGR);
_width = 320;
_height = 240;
break;
}
}
main()
{
lcd_initial();
while(1)
{
write_command(0x2C);
// Disp_gradscal(); //»Ò½×
// delay(500);
// dsp_single_colour(0x84,0x10);//»ÒÉ«
// delay(500);
dsp_single_colour(0xff,0xff);//°×É«
delay(500);
dsp_single_colour(0x00,0x00);//ºÚÉ«
delay(500);
dsp_single_colour(0xf8,0x00);//ºìÉ«
delay(500);
dsp_single_colour(0x07,0xe0);//ÂÌÉ«
delay(500);
dsp_single_colour(0x00,0x1f);//À¶É«
delay(500);
}
}
static void byd_9177aa_panel_init(struct dsi_device *dsi)
{
int i;
for(i = 0; i < ARRAY_SIZE(byd_9177aa_cmd_list); i++) {
write_command(dsi, byd_9177aa_cmd_list[i]);
}
}
static int network_close(const struct iio_device *dev)
{
struct iio_device_pdata *pdata = dev->pdata;
int ret = -EBADF;
char buf[1024];
if (pdata->fd >= 0) {
snprintf(buf, sizeof(buf), "CLOSE %s\r\n", dev->id);
network_lock_dev(pdata);
ret = (int) write_rwbuf_command(dev, buf, true);
write_command("\r\nEXIT\r\n", pdata->fd);
close(pdata->fd);
pdata->fd = -1;
network_unlock_dev(pdata);
}
#ifdef WITH_NETWORK_GET_BUFFER
if (pdata->memfd >= 0)
close(pdata->memfd);
pdata->memfd = -1;
if (pdata->mmap_addr) {
munmap(pdata->mmap_addr, pdata->mmap_len);
pdata->mmap_addr = NULL;
}
#endif
return ret;
}
static void network_shutdown(struct iio_context *ctx)
{
struct iio_context_pdata *pdata = ctx->pdata;
unsigned int i;
network_lock(pdata);
write_command("\r\nEXIT\r\n", pdata->fd);
close(pdata->fd);
network_unlock(pdata);
for (i = 0; i < ctx->nb_devices; i++) {
struct iio_device *dev = ctx->devices[i];
struct iio_device_pdata *dpdata = dev->pdata;
if (dpdata) {
network_close(dev);
#if HAVE_PTHREAD
pthread_mutex_destroy(&dpdata->lock);
#endif
free(dpdata);
}
}
#if HAVE_PTHREAD
pthread_mutex_destroy(&pdata->lock);
#endif
freeaddrinfo(pdata->addrinfo);
free(pdata);
}
static int write_to_mipi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int l_count = (argc - 1) % 256; /* parameter count low 8bits */
int h_count = (argc - 1) / 256; /* parameter count high 8bits */
int i;
struct dsi_cmd_packet my_data;
if(argc < 2) {
debug("your parameter is too few\n");
return -1;
}
if(argv[1][0] >= '0' && argv[1][0] <= '9') {
my_data.packet_type = 0x39; /* sent long packet */
my_data.cmd0_or_wc_lsb = l_count;
my_data.cmd1_or_wc_msb = h_count;
for(i = 0; i < argc - 1; i++)
my_data.cmd_data[i] = simple_strtol(argv[i+1],'\0',10);
write_command(dsi,my_data);
debug(" write success \n ");
return 0;
}
else {
debug(" your command is wrong \n");
return -1;
}
}
/* write a one byte command to the controller */
int
write_controller_command(KBDC p, int c)
{
if (!wait_while_controller_busy(kbdcp(p)))
return FALSE;
write_command(kbdcp(p), c);
return TRUE;
}
static void set_addr_window(uint16_t x_0, uint16_t y_0, uint16_t x_1, uint16_t y_1)
{
ASSERT(x_0 < x_1);
ASSERT(y_0 < y_1);
write_command(ILI9341_CASET);
write_data(x_0 >> 8);
write_data(x_0);
write_data(x_1 >> 8);
write_data(x_1);
write_command(ILI9341_PASET);
write_data(y_0 >> 8);
write_data(y_0);
write_data(y_1 >> 8);
write_data(y_1);
write_command(ILI9341_RAMWR);
}
static void set_addr_window(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1)
{
ASSERT(x0 <= x1);
ASSERT(y0 <= y1);
write_command(ST7735_CASET);
write_data(0x00); // For a 128x160 display, it is always 0.
write_data(x0);
write_data(0x00); // For a 128x160 display, it is always 0.
write_data(x1);
write_command(ST7735_RASET);
write_data(0x00); // For a 128x160 display, it is always 0.
write_data(y0);
write_data(0x00); // For a 128x160 display, it is always 0.
write_data(y1);
write_command(ST7735_RAMWR);
}
