# HG changeset patch # User Alexis Jeandet # Date 2015-04-14 20:48:54 # Node ID 3311a844031e5d5eb9d972c98a6b8aead5240405 # Parent 988f7eae7e79884937c49bf1c924b6ae08112e03 Added OpenOCD target for olimex-arm-usb-tiny. Working D51E5TA7601 driver. Added Framebuffer interface. Added generic memory to memory DMA api, mmainly used by framebuffer API. ADS7843 work in progress. Added SOSmartPSU bsp. diff --git a/bin/qt.conf b/bin/qt.conf new file mode 100644 --- /dev/null +++ b/bin/qt.conf @@ -0,0 +1,4 @@ +[Paths] +Prefix=.. +Examples=../../Examples/Qt-5.4 +Documentation=../../Docs/Qt-5.4 diff --git a/bin/syncqt.pl b/bin/syncqt.pl new file mode 100755 --- /dev/null +++ b/bin/syncqt.pl @@ -0,0 +1,1227 @@ +#!/usr/bin/env perl +############################################################################# +## +## Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +## Contact: http://www.qt-project.org/legal +## +## This file is part of the build configuration tools of the Qt Toolkit. +## +## $QT_BEGIN_LICENSE:LGPL$ +## Commercial License Usage +## Licensees holding valid commercial Qt licenses may use this file in +## accordance with the commercial license agreement provided with the +## Software or, alternatively, in accordance with the terms contained in +## a written agreement between you and Digia. For licensing terms and +## conditions see http://qt.digia.com/licensing. For further information +## use the contact form at http://qt.digia.com/contact-us. +## +## GNU Lesser General Public License Usage +## Alternatively, this file may be used under the terms of the GNU Lesser +## General Public License version 2.1 as published by the Free Software +## Foundation and appearing in the file LICENSE.LGPL included in the +## packaging of this file. Please review the following information to +## ensure the GNU Lesser General Public License version 2.1 requirements +## will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +## +## In addition, as a special exception, Digia gives you certain additional +## rights. These rights are described in the Digia Qt LGPL Exception +## version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +## +## GNU General Public License Usage +## Alternatively, this file may be used under the terms of the GNU +## General Public License version 3.0 as published by the Free Software +## Foundation and appearing in the file LICENSE.GPL included in the +## packaging of this file. Please review the following information to +## ensure the GNU General Public License version 3.0 requirements will be +## met: http://www.gnu.org/copyleft/gpl.html. +## +## +## $QT_END_LICENSE$ +## +############################################################################# + +# +# Synchronizes Qt header files - internal development tool. +# + +# use packages ------------------------------------------------------- +use File::Basename; +use File::Path; +use File::Spec; +use Cwd; +use Cwd 'abs_path'; +use Config; +use strict; +use warnings; +use English qw(-no_match_vars ); + +my $normalizePath_fixDrive = ($^O eq "msys" ? 1 : 0); + +###################################################################### +# Syntax: normalizePath(\$path) +# Params: Reference to a path that's going to be normalized. +# +# Purpose: Converts the path into a form that can be used as include +# path from C++ sources and qmake's .pro files. +# Only relevant on Windows. +# Returns: -none- +###################################################################### +sub normalizePath { + my $s = shift; + $$s =~ s=\\=/=g; + if ($normalizePath_fixDrive && ($$s =~ m,^/([a-zA-Z])/(.*), || $$s =~ m,^([a-zA-Z]):/(.*),)) { + $$s = lc($1) . ":/$2"; + } +} + +# set output basedir to be where ever syncqt is run from +our $out_basedir = getcwd(); +normalizePath(\$out_basedir); +our $basedir; +our $quoted_basedir; + +# Make sure we use Windows line endings for chomp and friends on Windows. +$INPUT_RECORD_SEPARATOR = "\r\n" if ($^O eq "msys"); + +# will be defined based on the modules sync.profile +our (%modules, %moduleheaders, @allmoduleheadersprivate, %classnames, %deprecatedheaders); +our @qpa_headers = (); + +# will be derived from sync.profile +our %reverse_classnames = (); + +# global variables (modified by options) +my $isunix = 0; +my $module = 0; +my $showonly = 0; +my $verbose_level = 1; +my $remove_stale = 1; +my $force_win = 0; +my $force_relative = 0; +my $check_includes = 0; +my $copy_headers = 0; +my $create_private_headers = 1; +my $minimal = 0; +my $module_version = 0; +my @modules_to_sync ; +$force_relative = 1 if ( -d "/System/Library/Frameworks" ); + + +# functions ---------------------------------------------------------- + +###################################################################### +# Syntax: showUsage() +# Params: -none- +# +# Purpose: Show the usage of the script. +# Returns: -none- +###################################################################### +sub showUsage +{ + print "$0 usage:\n"; + print " Specifies which module to sync header files for (required for shadow builds!)\n\n"; + + print " -copy Copy headers instead of include-fwd(default: " . ($copy_headers ? "yes" : "no") . ")\n"; + print " -remove-stale Removes stale headers (default: " . ($remove_stale ? "yes" : "no") . ")\n"; + print " -relative Force relative symlinks (default: " . ($force_relative ? "yes" : "no") . ")\n"; + print " -windows Force platform to Windows (default: " . ($force_win ? "yes" : "no") . ")\n"; + print " -showonly Show action but not perform (default: " . ($showonly ? "yes" : "no") . ")\n"; + print " -minimal Do not create CamelCase headers (default: " . ($minimal ? "yes" : "no") . ")\n"; + print " -outdir Specify output directory for sync (default: $out_basedir)\n"; + print " -version Specify the module's version (default: detect from qglobal.h)\n"; + print " -quiet Only report problems, not activity (same as -verbose 0)\n"; + print " -v, -verbose Sets the verbosity level (max. 4) (default: $verbose_level)\n"; + print " The short form increases the level by +1\n"; + print " -separate-module ::\n"; + print " Create headers for with original headers in\n"; + print " relative to \n"; + print " -private Force copy private headers (default: " . ($create_private_headers ? "yes" : "no") . ")\n"; + print " -help This help\n"; + exit 0; +} + +###################################################################### +# Syntax: checkUnix() +# Params: -none- +# +# Purpose: Check if script runs on a Unix system or not. Cygwin +# systems are _not_ detected as Unix systems. +# Returns: 1 if a unix system, else 0. +###################################################################### +sub checkUnix { + my ($r) = 0; + if ( $force_win != 0) { + return 0; + } elsif ( -f "/bin/uname" ) { + $r = 1; + (-f "\\bin\\uname") && ($r = 0); + } elsif ( -f "/usr/bin/uname" ) { + $r = 1; + (-f "\\usr\\bin\\uname") && ($r = 0); + } + if($r) { + $_ = $Config{'osname'}; + $r = 0 if( /(ms)|(cyg)win/i ); + } + return $r; +} + +sub checkRelative { + my ($dir) = @_; + return 0 if($dir =~ /^\//); + return 0 if(!checkUnix() && $dir =~ /[a-zA-Z]:[\/\\]/); + return 1; +} + +###################################################################### +# Syntax: shouldMasterInclude(iheader) +# Params: iheader, string, filename to verify inclusion +# +# Purpose: Determines if header should be in the master include file. +# Returns: 0 if file contains "#pragma qt_no_master_include" or not +# able to open, else 1. +###################################################################### +sub shouldMasterInclude { + my ($iheader) = @_; + return 0 if (basename($iheader) =~ /_/); + return 0 if (basename($iheader) =~ /qconfig/); + if (open(F, "<$iheader")) { + while () { + chomp; + return 0 if (/^\#pragma qt_no_master_include$/); + } + close(F); + } else { + return 0; + } + return 1; +} + +###################################################################### +# Syntax: classNames(iheader) +# Params: iheader, string, filename to parse for classname "symlinks" +# +# Purpose: Scans through iheader to find all classnames that should be +# synced into library's include structure. +# Returns: List of all class names in a file. +###################################################################### +sub classNames { + my @ret; + my ($iheader) = @_; + + my $ihdrbase = basename($iheader); + my $classname = $classnames{$ihdrbase}; + push @ret, split(/,/, $classname) if ($classname); + + my $parsable = ""; + if(open(F, "<$iheader")) { + while() { + my $line = $_; + chomp $line; + chop $line if ($line =~ /\r$/); + if($line =~ /^\#/) { + return @ret if($line =~ m/^#pragma qt_sync_stop_processing/); + push(@ret, $1) if($line =~ m/^#pragma qt_class\(([^)]*)\)[\r\n]*$/); + $line = 0; + } + if($line) { + $line =~ s,//.*$,,; #remove c++ comments + $line .= ";" if($line =~ m/^Q_[A-Z_]*\(.*\)[\r\n]*$/); #qt macro + $line .= ";" if($line =~ m/^QT_(BEGIN|END)_HEADER[\r\n]*$/); #qt macro + $line .= ";" if($line =~ m/^QT_(BEGIN|END)_NAMESPACE(_[A-Z]+)*[\r\n]*$/); #qt macro + $line .= ";" if($line =~ m/^QT_MODULE\(.*\)[\r\n]*$/); # QT_MODULE macro + $parsable .= " " . $line; + } + } + close(F); + } + + my $last_definition = 0; + my @namespaces; + for(my $i = 0; $i < length($parsable); $i++) { + my $definition = 0; + my $character = substr($parsable, $i, 1); + if($character eq "/" && substr($parsable, $i+1, 1) eq "*") { #I parse like this for greedy reasons + for($i+=2; $i < length($parsable); $i++) { + my $end = substr($parsable, $i, 2); + if($end eq "*/") { + $last_definition = $i+2; + $i++; + last; + } + } + } elsif($character eq "{") { + my $brace_depth = 1; + my $block_start = $i + 1; + BLOCK: for($i+=1; $i < length($parsable); $i++) { + my $ignore = substr($parsable, $i, 1); + if($ignore eq "{") { + $brace_depth++; + } elsif($ignore eq "}") { + $brace_depth--; + unless($brace_depth) { + for(my $i2 = $i+1; $i2 < length($parsable); $i2++) { + my $end = substr($parsable, $i2, 1); + if($end eq ";" || $end ne " ") { + $definition = substr($parsable, $last_definition, $block_start - $last_definition) . "}"; + $i = $i2 if($end eq ";"); + $last_definition = $i + 1; + last BLOCK; + } + } + } + } + } + } elsif($character eq ";") { + $definition = substr($parsable, $last_definition, $i - $last_definition + 1); + $last_definition = $i + 1; + } elsif($character eq "}") { + # a naked } must be a namespace ending + # if it's not a namespace, it's eaten by the loop above + pop @namespaces; + $last_definition = $i + 1; + } + + if (substr($parsable, $last_definition, $i - $last_definition + 1) =~ m/ namespace ([^ ]*) / + && substr($parsable, $i+1, 1) eq "{") { + push @namespaces, $1; + + # Eat the opening { so that the condensing loop above doesn't see it + $i++; + $last_definition = $i + 1; + } + + if($definition) { + $definition =~ s=[\n\r]==g; + my @symbols; + my $post_kw = qr/Q_DECL_FINAL|final|sealed/; # add here macros and keywords that go after the class-name of a class definition + if($definition =~ m/^ *typedef *.*\(\*([^\)]*)\)\(.*\);$/) { + push @symbols, $1; + } elsif($definition =~ m/^ *typedef +(.*) +([^ ]*);$/) { + push @symbols, $2; + } elsif($definition =~ m/^ *(template *<.*> *)?(class|struct) +([^ <>]* +)?((?!$post_kw)[^<\s]+) ?(<[^>]*> ?)?\s*(?:$post_kw)?\s*((,|:)\s*(public|protected|private) *.*)? *\{\}$/o) { + push @symbols, $4; + } elsif($definition =~ m/^ *Q_DECLARE_.*ITERATOR\((.*)\);$/) { + push @symbols, "Q" . $1 . "Iterator"; + push @symbols, "QMutable" . $1 . "Iterator"; + } + + our $publicclassregexp; + foreach my $symbol (@symbols) { + $symbol = (join("::", @namespaces) . "::" . $symbol) if (scalar @namespaces); + + my $revhdr = $reverse_classnames{$symbol}; + next if (defined($revhdr) and $revhdr ne $ihdrbase); + if ($symbol =~ /^Q[^:]*$/) { # no-namespace, starting with Q + push @ret, $symbol; + } elsif (defined($publicclassregexp)) { + push @ret, $symbol if ($symbol =~ $publicclassregexp); + } + } + } + } + return @ret; +} + +sub make_path { + my ($dir, $lib, $be_verbose) = @_; + unless(-e $dir) { + mkpath $dir; + $dir = "" . substr($dir, length($out_basedir)) if ($be_verbose < 3); + print "$lib: mkpath $dir\n" if ($be_verbose > 1); + } +} + +###################################################################### +# Syntax: syncHeader(header, iheader, copy, timestamp) +# Params: header, string, filename to create "symlink" for +# iheader, string, destination name of symlink +# copy, forces header to be a copy of iheader +# timestamp, the requested modification time if copying +# +# Purpose: Syncronizes header to iheader +# Returns: 1 if successful, else 0. +###################################################################### +sub syncHeader { + my ($lib, $header, $iheader, $copy, $ts) = @_; + normalizePath(\$iheader); + normalizePath(\$header); + return copyFile($lib, $iheader, $header) if($copy); + + unless(-e $header) { + my $header_dir = dirname($header); + make_path($header_dir, $lib, $verbose_level); + + #write it + my $iheader_out = fixPaths($iheader, $header_dir); + open(HEADER, ">$header") || die "Could not open $header for writing: $!\n"; + print HEADER "#include \"$iheader_out\"\n"; + close HEADER; + if(defined($ts)) { + utime(time, $ts, $header) or die "$iheader, $header"; + } + return 1; + } + return 0; +} + +###################################################################### +# Syntax: fixPaths(file, dir) +# Params: file, string, filepath to be made relative to dir +# dir, string, dirpath for point of origin +# +# Purpose: file is made relative (if possible) of dir. +# Returns: String with the above applied conversion. +###################################################################### + +sub cleanupPath { + my ($file) = @_; + normalizePath(\$file); + while ($file =~ s,/[^/]+/\.\./,/,) {} + return $file; +} + +sub fixPaths { + my ($file, $dir) = @_; + + my $out = File::Spec->abs2rel(cleanupPath($file), cleanupPath($dir)); + $out =~ s,\\,/,g; + return $out; +} + +###################################################################### +# Syntax: fileContents(filename) +# Params: filename, string, filename of file to return contents +# +# Purpose: Get the contents of a file. +# Returns: String with contents of the file, or empty string if file +# doens't exist. +# Warning: Dies if it does exist but script cannot get read access. +###################################################################### +sub fileContents { + my ($filename) = @_; + my $filecontents = ""; + if (-e $filename) { + open(I, "< $filename") || die "Could not open $filename for reading, read block?"; + local $/; + binmode I; + $filecontents = ; + close I; + } + return $filecontents; +} + +###################################################################### +# Syntax: writeFile(filename, contents) +# Params: filename, string, filename of file to write +# contents, string, new contents for the file +# +# Purpose: Write file with given contents. If new contents match old +# ones, do no change the file's timestamp. +# Returns: 1 if the file's contents changed. +###################################################################### +sub writeFile { + my ($filename, $contents, $lib, $what) = @_; + my $oldcontents = fileContents($filename); + $oldcontents =~ s/\r//g; # remove \r's , so comparison is ok on all platforms + if ($oldcontents ne $contents) { + open(O, "> " . $filename) || die "Could not open $filename for writing: $!\n"; + print O $contents; + close O; + if ($lib && $verbose_level) { + my $action = ($oldcontents eq "") ? "created" : "updated"; + print "$lib: $action $what\n"; + } + return 1; + } + return 0; +} + +###################################################################### +# Syntax: fileCompare(file1, file2) +# Params: file1, string, filename of first file +# file2, string, filename of second file +# +# Purpose: Determines if files are equal, and which one is newer. +# Returns: 0 if files are equal no matter the timestamp, -1 if file1 +# is newer, 1 if file2 is newer. +###################################################################### +sub fileCompare { + my ($file1, $file2) = @_; + my $file1contents = fileContents($file1); + my $file2contents = fileContents($file2); + if (! -e $file1) { return 1; } + if (! -e $file2) { return -1; } + return $file1contents ne $file2contents ? (stat($file2))[9] <=> (stat($file1))[9] : 0; +} + +###################################################################### +# Syntax: copyFile(file, ifile) +# Params: file, string, filename to create duplicate for +# ifile, string, destination name of duplicate +# +# Purpose: Keeps files in sync so changes in the newer file will be +# written to the other. +# Returns: 1 if files were synced, else 0. +# Warning: Dies if script cannot get write access. +###################################################################### +sub copyFile +{ + my ($lib, $file,$ifile, $copy,$knowdiff,$filecontents,$ifilecontents) = @_; + # Bi-directional synchronization + open( I, "< " . $file ) || die "Could not open $file for reading"; + local $/; + binmode I; + $filecontents = ; + close I; + if ( open(I, "< " . $ifile) ) { + local $/; + binmode I; + $ifilecontents = ; + close I; + $copy = fileCompare($file, $ifile); + $knowdiff = 0, + } else { + $copy = -1; + $knowdiff = 1; + } + + if ( $knowdiff || ($filecontents ne $ifilecontents) ) { + if ( $copy > 0 ) { + my $file_dir = dirname($file); + make_path($file_dir, $lib, $verbose_level); + open(O, "> " . $file) || die "Could not open $file for writing (no write permission?)"; + local $/; + binmode O; + print O $ifilecontents; + close O; + utime time, (stat($ifile))[9], $file; + return 1; + } elsif ( $copy < 0 ) { + my $ifile_dir = dirname($ifile); + make_path($ifile_dir, $lib, $verbose_level); + open(O, "> " . $ifile) || die "Could not open $ifile for writing (no write permission?)"; + local $/; + binmode O; + print O $filecontents; + close O; + utime time, (stat($file))[9], $ifile; + return 1; + } + } + return 0; +} + +###################################################################### +# Syntax: findFiles(dir, match, descend) +# Params: dir, string, directory to search for name +# match, string, regular expression to match in dir +# descend, integer, 0 = non-recursive search +# 1 = recurse search into subdirectories +# +# Purpose: Finds files matching a regular expression. +# Returns: List of matching files. +# +# Examples: +# findFiles("/usr","\.cpp$",1) - finds .cpp files in /usr and below +# findFiles("/tmp","^#",0) - finds #* files in /tmp +###################################################################### +sub findFiles { + my ($dir,$match,$descend) = @_; + my ($file,$p,@files); + local(*D); + normalizePath(\$dir); + ($dir eq "") && ($dir = "."); + if ( opendir(D,$dir) ) { + if ( $dir eq "." ) { + $dir = ""; + } else { + ($dir =~ /\/$/) || ($dir .= "/"); + } + foreach $file ( sort readdir(D) ) { + next if ( $file =~ /^\.\.?$/ ); + $p = $file; + ($file =~ /$match/) && (push @files, $p); + if ( $descend && -d $p && ! -l $p ) { + push @files, &findFiles($p,$match,$descend); + } + } + closedir(D); + } + return @files; +} + +sub listSubdirs { + my @subdirs = @_; + foreach my $subdir (@subdirs) { + opendir DIR, $subdir or die "Huh, directory ".$subdir." cannot be opened."; + foreach my $t (sort readdir(DIR)) { + push @subdirs, "$subdir/$t" if(-d "$subdir/$t" && !($t eq ".") && + !($t eq "..") && !($t eq ".obj") && + !($t eq ".moc") && !($t eq ".rcc") && + !($t eq ".uic") && !($t eq "build") && + !($t eq "doc")); + } + closedir DIR; + } + return @subdirs; +} + +###################################################################### +# Syntax: loadSyncProfile() +# +# Purpose: Locates the sync.profile. +# Returns: Hashmap of module name -> directory. +###################################################################### +sub loadSyncProfile { + my ($srcbase, $outbase) = @_; + if ($verbose_level) { + print(" = $$srcbase \n"); + print(" = $$outbase \n"); + } + + my $syncprofile = "$$srcbase/sync.profile"; + my $result; + unless ($result = do "$syncprofile") { + die "syncqt couldn't parse $syncprofile: $@" if $@; + die "syncqt couldn't execute $syncprofile: $!" unless defined $result; + } + + for my $fn (keys %classnames) { + for my $cn (split(/,/, $classnames{$fn})) { + $reverse_classnames{$cn} = $fn; + } + } + + return $result; +} + +sub basePrettify { + my ($arg) = @_; + $$arg =~ s,^\Q$basedir\E,,; + $$arg =~ s,^\Q$out_basedir\E,,; +} + +sub cleanPath { + my ($arg) = @_; + while ($arg =~ s,[^/]+/\.\.(/|$),,) {} + return $arg; +} + +sub locateSyncProfile +{ + my ($directory) = @_; + $directory = abs_path($directory); + while (1) { + my $file = $directory."/sync.profile"; + return $file if (-e $file); + my $odir = $directory; + $directory = dirname($directory); + return undef if ($directory eq $odir); + } +} + +sub isQpaHeader +{ + my ($header) = @_; + foreach my $qpa_header (@qpa_headers) { + return 1 if ($header =~ $qpa_header); + } + return 0; +} + +# check if this is an in-source build, and if so use that as the basedir too +$basedir = locateSyncProfile($out_basedir); +if ($basedir) { + $basedir = dirname($basedir) ; + normalizePath(\$basedir); + $quoted_basedir = "\Q$basedir"; +} + +# -------------------------------------------------------------------- +# "main" function +# -------------------------------------------------------------------- + +while ( @ARGV ) { + my $var = 0; + my $val = 0; + + #parse + my $arg = shift @ARGV; + if ($arg eq "-h" || $arg eq "-help" || $arg eq "-?" || $arg eq "?") { + $var = "show_help"; + $val = "yes"; + } elsif($arg eq "-copy") { + $var = "copy"; + $val = "yes"; + } elsif($arg eq "-o" || $arg eq "-outdir") { + $var = "output"; + $val = shift @ARGV; + } elsif($arg eq "-showonly" || $arg eq "-remove-stale" || $arg eq "-windows" || + $arg eq "-relative" || $arg eq "-check-includes") { + $var = substr($arg, 1); + $val = "yes"; + } elsif($arg =~ /^-no-(.*)$/) { + $var = $1; + $val = "no"; + #these are for commandline compat + } elsif($arg eq "-inc") { + $var = "output"; + $val = shift @ARGV; + } elsif($arg eq "-module") { + $var = "module"; + $val = shift @ARGV; + } elsif($arg eq "-separate-module") { + $var = "separate-module"; + $val = shift @ARGV; + } elsif($arg eq "-show") { + $var = "showonly"; + $val = "yes"; + } elsif($arg eq "-quiet") { + $var = "verbose"; + $val = "0"; + } elsif($arg eq "-v") { + $var = "verbose"; + $val = "yes"; + } elsif($arg eq "-verbose") { + $var = "verbose"; + $val = shift @ARGV; + } elsif($arg eq "-minimal") { + $var = "minimal"; + $val = "yes"; + } elsif($arg eq "-private") { + $var = "create_private_headers"; + $val = "yes"; + } elsif($arg eq "-version") { + $var = "version"; + $val = shift @ARGV; + } elsif($arg =~/^-/) { + print "Unknown option: $arg\n\n" if(!$var); + showUsage(); + } else { + $basedir = locateSyncProfile($arg); + die "Could not find a sync.profile for '$arg'\n" if (!$basedir); + $basedir = dirname($basedir); + normalizePath(\$basedir); + $quoted_basedir = "\Q$basedir"; + $var = "ignore"; + } + + #do something + if(!$var || $var eq "show_help") { + print "Unknown option: $arg\n\n" if(!$var); + showUsage(); + } elsif ($var eq "copy") { + if($val eq "yes") { + $copy_headers++; + } elsif($showonly) { + $copy_headers--; + } + } elsif ($var eq "showonly") { + if($val eq "yes") { + $showonly++; + } elsif($showonly) { + $showonly--; + } + } elsif ($var eq "verbose") { + if($val eq "yes") { + $verbose_level++; + } elsif($val eq "no" && $verbose_level) { + $verbose_level--; + } else { + $verbose_level = int($val); + } + } elsif ($var eq "check-includes") { + if($val eq "yes") { + $check_includes++; + } elsif($check_includes) { + $check_includes--; + } + } elsif ($var eq "remove-stale") { + if($val eq "yes") { + $remove_stale++; + } elsif($remove_stale) { + $remove_stale--; + } + } elsif ($var eq "windows") { + if($val eq "yes") { + $force_win++; + } elsif($force_win) { + $force_win--; + } + } elsif ($var eq "relative") { + if($val eq "yes") { + $force_relative++; + } elsif($force_relative) { + $force_relative--; + } + } elsif ($var eq "minimal") { + if($val eq "yes") { + $minimal++; + } elsif($minimal) { + $minimal--; + } + } elsif ($var eq "module") { + push @modules_to_sync, $val; + } elsif ($var eq "separate-module") { + my ($module, $prodir, $headerdir) = split(/:/, $val); + $modules{$module} = $prodir; + push @modules_to_sync, $module; + $moduleheaders{$module} = $headerdir; + } elsif ($var eq "version") { + if($val) { + $module_version = $val; + } else { + die "The -version option requires an argument"; + } + } elsif ($var eq "output") { + my $outdir = $val; + if(checkRelative($outdir)) { + $out_basedir = getcwd(); + chomp $out_basedir; + $out_basedir .= "/" . $outdir; + } else { + $out_basedir = $outdir; + } + normalizePath(\$out_basedir); + } +} + +# if we have no $basedir we cannot be sure which sources you want, so die +die "Could not find any sync.profile for your module!\nPass to syncqt to sync your header files.\nsyncqt failed" if (!$basedir); + +our @ignore_headers = (); +our @ignore_for_master_contents = (); +our @ignore_for_include_check = (); +our @ignore_for_qt_begin_namespace_check = (); +our @ignore_for_qt_module_check = (); +our %inject_headers = (); + +# load the module's sync.profile here, before we can +loadSyncProfile(\$basedir, \$out_basedir); + +@modules_to_sync = keys(%modules) if($#modules_to_sync == -1); + +my %allmoduleheadersprivate = map { $_ => 1 } @allmoduleheadersprivate; + +$isunix = checkUnix; #cache checkUnix + +if (!$module_version) { + my $filco = fileContents($basedir."/src/corelib/global/qglobal.h"); + if ($filco !~ m,.*^#[ \t]*define[ \t]+QT_VERSION_STR[ \t]+"([^"]+)".*,sm) { + die "Cannot determine Qt/Module version. Use -version.\n"; + } + $module_version = $1; +} +foreach my $lib (@modules_to_sync) { + die "No such module: $lib" unless(defined $modules{$lib}); + + #iteration info + my $module = $modules{$lib}; + my $is_qt = !($module =~ s/^!//); + my @dirs = split(/;/, $module); + my $dir = $dirs[0]; + + my $pathtoheaders = ""; + $pathtoheaders = $moduleheaders{$lib} if ($moduleheaders{$lib}); + + my $allheadersprivate = 0; + $allheadersprivate = 1 if $allmoduleheadersprivate{$lib}; + + #information used after the syncing + my $pri_install_classes = ""; + my $pri_install_files = ""; + my $pri_install_pfiles = ""; + my $pri_install_qpafiles = ""; + my $pri_injections = ""; + + my $libcapitals = uc($lib); + my $master_contents = + "#ifndef QT_".$libcapitals."_MODULE_H\n" . + "#define QT_".$libcapitals."_MODULE_H\n" . + "#include <$lib/${lib}Depends>\n"; + + #remove the old files + if($remove_stale) { + my %injections = (); + for my $p (keys %inject_headers) { + next unless ($p =~ /^\Q$dir\E(\/|$)/); + my $sp = $p; + $sp =~ s,^\Q$basedir\E/,$out_basedir/,; + for my $n (@{$inject_headers{$p}}) { + $injections{$sp."/".$n} = 1; + } + } + my @subdirs = ("$out_basedir/include/$lib"); + foreach my $subdir (@subdirs) { + if (opendir DIR, $subdir) { + foreach my $t (sort { $b cmp $a } readdir(DIR)) { + my $file = "$subdir/$t"; + if(-d $file) { + push @subdirs, $file unless($t eq "." || $t eq ".."); + } else { + my @files = ($file); + #push @files, "$out_basedir/include/Qt/$t" if(-e "$out_basedir/include/Qt/$t"); + foreach my $file (@files) { + my $remove_file = 0; + if(open(F, "<$file")) { + while(my $line = ) { + chomp $line; + if($line =~ /^\#include \"([^\"]*)\"$/) { + my $include = $1; + $include = $subdir . "/" . $include unless(substr($include, 0, 1) eq "/"); + $remove_file = 1 unless(-e $include or defined $injections{cleanPath($include)}); + } else { + $remove_file = 0; + last; + } + } + close(F); + unlink $file if($remove_file); + } + } + } + } + closedir DIR; + } + + } + } + + #create the new ones + foreach my $current_dir (@dirs) { + my $thisprivate = 0; + ($current_dir =~ s/^\^//) and $thisprivate = 1; + my @headers_paths = split(/;/, $pathtoheaders); + if (@headers_paths) { + @headers_paths = map { "$current_dir/$_" } @headers_paths; + } else { + push @headers_paths, $current_dir; + } + + foreach my $headers_dir (@headers_paths) { + #calc subdirs + my @subdirs = listSubdirs($headers_dir); + + #calc files and "copy" them + foreach my $subdir (@subdirs) { + my @headers = findFiles($subdir, "^[-a-z0-9_]*\\.h\$" , 0); + if (defined $inject_headers{$subdir}) { + foreach my $if (@{$inject_headers{$subdir}}) { + @headers = grep(!/^\Q$if\E$/, @headers); #in case we configure'd previously + push @headers, "*".$if; + } + } + my $header_dirname = ""; + foreach my $header (@headers) { + my $shadow = ($header =~ s/^\*//); + $header = 0 if($header =~ /^ui_.*.h/); + foreach (@ignore_headers) { + $header = 0 if($header eq $_); + } + if($header) { + my $header_copies = 0; + #figure out if it is a public header + my $public_header = $header; + my $qpa_header = 0; + if(isQpaHeader($public_header)) { + $public_header = 0; + $qpa_header = 1; + } elsif($allheadersprivate || $thisprivate || $public_header =~ /_p.h$/ || $public_header =~ /_pch.h$/) { + $public_header = 0; + } else { + foreach (@ignore_for_master_contents) { + $public_header = 0 if($header eq $_); + } + } + + my $iheader = $subdir . "/" . $header; + $iheader =~ s/^\Q$basedir\E/$out_basedir/ if ($shadow); + my @classes = $public_header && (!$minimal && $is_qt) ? classNames($iheader) : (); + if($showonly) { + print "$header [$lib]\n"; + foreach(@classes) { + print "SYMBOL: $_\n"; + } + } else { + my $ts = $shadow ? 0 : (stat($iheader))[9]; + #find out all the places it goes.. + my $oheader; + if ($public_header) { + $oheader = "$out_basedir/include/$lib/$header"; + foreach my $full_class (@classes) { + my $header_base = basename($header); + # Strip namespaces: + my $class = $full_class; + $class =~ s/^.*:://; + # if ($class =~ m/::/) { + # class =~ s,::,/,g; + # } + + $header_copies++ if (!$shadow && syncHeader($lib, "$out_basedir/include/$lib/$class", "$out_basedir/include/$lib/$header", 0, $ts)); + } + } elsif ($create_private_headers && !$qpa_header) { + $oheader = "$out_basedir/include/$lib/$module_version/$lib/private/$header"; + } elsif ($create_private_headers) { + $oheader = "$out_basedir/include/$lib/$module_version/$lib/qpa/$header"; + } + $header_copies++ if (!$shadow && syncHeader($lib, $oheader, $iheader, $copy_headers, $ts)); + + my $pri_install_iheader = fixPaths($iheader, $dir); + my $injection = ""; + if($public_header) { + #put it into the master file + $master_contents .= "#include \"$public_header\"\n" if (!$shadow && shouldMasterInclude($iheader)); + + #deal with the install directives + foreach my $class (@classes) { + # Strip namespaces: + $class =~ s/^.*:://; +# if ($class =~ m/::/) { +# $class =~ s,::,/,g; +# } + my $class_header = fixPaths("$out_basedir/include/$lib/$class", $dir) . " "; + $pri_install_classes .= $class_header + unless($pri_install_classes =~ $class_header); + $injection .= ":$class"; + } + $pri_install_files.= "$pri_install_iheader ";; + } + elsif ($qpa_header) { + $pri_install_qpafiles.= "$pri_install_iheader ";; + } + else { + $pri_install_pfiles.= "$pri_install_iheader ";; + } + $pri_injections .= fixPaths($iheader, "$out_basedir/include/$lib") + .":".fixPaths($oheader, "$out_basedir/include/$lib") + .$injection." " if ($shadow); + } + + if ($verbose_level && $header_copies) { + my $new_header_dirname = dirname($iheader); + basePrettify(\$new_header_dirname) if ($new_header_dirname && $verbose_level < 2); + my $header_base = basename($iheader); + if ($verbose_level < 3) { + my $line_prefix = ","; + if ($new_header_dirname ne $header_dirname) { + $line_prefix = "$lib: created fwd-include header(s) for $new_header_dirname/ {"; + $line_prefix = " }\n".$line_prefix if ($header_dirname); + $header_dirname = $new_header_dirname; + } else { + $line_prefix = ","; + } + print "$line_prefix $header_base ($header_copies)"; + } else { # $verbose_level >= 3 + basePrettify(\$iheader) if ($verbose_level == 3); + print "$lib: created $header_copies fwd-include headers for $iheader\n"; + } + } + } + } + print " }\n" if ($header_dirname && $verbose_level > 0 && $verbose_level < 3); + } + } + } + + # close the master include: + $master_contents .= + "#include \"".lc($lib)."version.h\"\n" . + "#endif\n"; + + unless ($showonly || $minimal || !$is_qt) { + # create deprecated headers + my $first = 1; + while (my ($header, $include) = each %{$deprecatedheaders{$lib}}) { + my $public_header = 0; + $public_header = 1 unless ($allheadersprivate || ($header =~ /_p\.h$/)); + next unless ($public_header || $create_private_headers); + + my $header_path = "$out_basedir/include/$lib/"; + unless ($public_header) { + $header_path .= "$module_version/$lib/private/"; + } + $header_path .= "$header"; + + unless (-e $header_path) { + my $guard = "DEPRECATED_HEADER_" . $lib . "_" . $header; + $guard =~ s/([^a-zA-Z0-9_])/_/g; + + my $header_dir = dirname($header_path); + make_path($header_dir, $lib, $verbose_level); + + my $hdrcont = + "#ifndef $guard\n" . + "#define $guard\n"; + my $warning = "Header <$lib/"; + $warning .= "private/" unless ($public_header); + $warning .= "$header> is deprecated. Please include <$include> instead."; + $hdrcont .= + "#if defined(__GNUC__)\n" . + "# warning $warning\n" . + "#elif defined(_MSC_VER)\n" . + "# pragma message (\"$warning\")\n" . + "#endif\n" . + "#include <$include>\n"; + if ($public_header) { + $hdrcont .= + "#if 0\n" . + "#pragma qt_no_master_include\n" . + "#endif\n"; + } + $hdrcont .= + "#endif\n"; + if (writeFile($header_path, $hdrcont)) { + if ($verbose_level < 3) { + my $line_prefix = ","; + $line_prefix = "$lib: created deprecated header(s) {" if ($first); + print "$line_prefix $header"; + } else { + print "$lib: created deprecated header $header => $include\n"; + } + $first = 0; + } + } + + my $addendum = fixPaths($header_path, $dir) . " "; + if ($public_header) { + $pri_install_files .= $addendum; + } else { + $pri_install_pfiles .= $addendum; + } + } + if ($verbose_level < 3) { + print " }\n" unless ($first); + } + + # module version header + my $vheader = "$out_basedir/include/$lib/".lc($lib)."version.h"; + my $VHeader = "$out_basedir/include/$lib/${lib}Version"; + syncHeader($lib, $VHeader, $vheader, 0); + $pri_install_files .= fixPaths($vheader, $dir) . " "; + $pri_install_classes .= fixPaths($VHeader, $dir) . " "; + my @versions = split(/\./, $module_version); + my $modulehexstring = sprintf("0x%02X%02X%02X", $versions[0], $versions[1], $versions[2]); + my $vhdrcont = + "/* This file was generated by syncqt. */\n". + "#ifndef QT_".uc($lib)."_VERSION_H\n". + "#define QT_".uc($lib)."_VERSION_H\n". + "\n". + "#define ".uc($lib)."_VERSION_STR \"".$module_version."\"\n". + "\n". + "#define ".uc($lib)."_VERSION ".$modulehexstring."\n". + "\n". + "#endif // QT_".uc($lib)."_VERSION_H\n"; + writeFile($vheader, $vhdrcont, $lib, "version header"); + + my $master_include = "$out_basedir/include/$lib/$lib"; + $pri_install_files .= fixPaths($master_include, $dir) . " "; + writeFile($master_include, $master_contents, $lib, "master header"); + } + + unless ($showonly || $minimal) { + #handle the headers.pri for each module + my $headers_pri_contents = ""; + $headers_pri_contents .= "SYNCQT.HEADER_FILES = $pri_install_files\n"; + $headers_pri_contents .= "SYNCQT.HEADER_CLASSES = $pri_install_classes\n"; + $headers_pri_contents .= "SYNCQT.PRIVATE_HEADER_FILES = $pri_install_pfiles\n"; + $headers_pri_contents .= "SYNCQT.QPA_HEADER_FILES = $pri_install_qpafiles\n"; + $headers_pri_contents .= "SYNCQT.INJECTIONS = $pri_injections\n"; + my $headers_pri_file = "$out_basedir/include/$lib/headers.pri"; + writeFile($headers_pri_file, $headers_pri_contents, $lib, "headers.pri file"); + } +} + +if($check_includes) { + foreach my $lib (@modules_to_sync) { + next if ($modules{$lib} =~ /^!/); + #calc subdirs + my @subdirs = listSubdirs(map { s/^\^//; $_ } split(/;/, $modules{$lib})); + + foreach my $subdir (@subdirs) { + my @headers = findFiles($subdir, "^[-a-z0-9_]*\\.h\$" , 0); + foreach my $header (@headers) { + my $header_skip_qt_begin_namespace_test = 0; + $header = 0 if($header =~ /^ui_.*.h/); + $header = 0 if ($header eq lc($lib)."version.h"); + foreach (@ignore_headers) { + $header = 0 if($header eq $_); + } + if($header) { + my $public_header = $header; + if($public_header =~ /_p.h$/ || $public_header =~ /_pch.h$/) { + $public_header = 0; + } elsif (isQpaHeader($public_header)) { + $public_header = 0; + } else { + foreach (@ignore_for_master_contents) { + $public_header = 0 if($header eq $_); + } + if($public_header) { + foreach (@ignore_for_include_check) { + $public_header = 0 if($header eq $_); + } + foreach(@ignore_for_qt_begin_namespace_check) { + $header_skip_qt_begin_namespace_test = 1 if ($header eq $_); + } + } + } + + my $iheader = $subdir . "/" . $header; + if($public_header) { + if(open(F, "<$iheader")) { + my $qt_begin_namespace_found = 0; + my $qt_end_namespace_found = 0; + my $qt_namespace_suffix = ""; + my $line; + my $stop_processing = 0; + while($line = ) { + chomp $line; + my $output_line = 1; + if($line =~ /^ *\# *pragma (qt_no_included_check|qt_sync_stop_processing)/) { + $stop_processing = 1; + last; + } elsif($line =~ /^ *\# *include/) { + my $include = $line; + if($line =~ /<.*>/) { + $include =~ s,.*<(.*)>.*,$1,; + } elsif($line =~ /".*"/) { + $include =~ s,.*"(.*)".*,$1,; + } else { + $include = 0; + } + if($include) { + for my $trylib (keys(%modules)) { + if(-e "$out_basedir/include/$trylib/$include") { + print "$lib: WARNING: $iheader includes $include when it should include $trylib/$include\n"; + } + } + } + } elsif ($header_skip_qt_begin_namespace_test == 0 and $line =~ /^QT_BEGIN_NAMESPACE(_[A-Z_]+)?\s*$/) { + $qt_namespace_suffix = defined($1) ? $1 : ""; + $qt_begin_namespace_found = 1; + } elsif ($header_skip_qt_begin_namespace_test == 0 and $line =~ /^QT_END_NAMESPACE$qt_namespace_suffix\s*$/) { + $qt_end_namespace_found = 1; + } + } + + if ($header_skip_qt_begin_namespace_test == 0 and $stop_processing == 0) { + if ($qt_begin_namespace_found == 0) { + print "$lib: WARNING: $iheader does not include QT_BEGIN_NAMESPACE\n"; + } + + if ($qt_begin_namespace_found && $qt_end_namespace_found == 0) { + print "$lib: WARNING: $iheader has QT_BEGIN_NAMESPACE$qt_namespace_suffix but no QT_END_NAMESPACE$qt_namespace_suffix\n"; + } + } + + close(F); + } + } + } + } + } + } +} + +exit 0; diff --git a/bsp/src/stm32f4/BEAGLESYNTH/bsp.pri b/bsp/src/stm32f4/BEAGLESYNTH/bsp.pri --- a/bsp/src/stm32f4/BEAGLESYNTH/bsp.pri +++ b/bsp/src/stm32f4/BEAGLESYNTH/bsp.pri @@ -1,9 +1,9 @@ CPU=stm32f4xxxG DEFINES+=BSP=\\\"BEAGLESYNTH\\\" beagleCp.target = beagleCp -beagleCp.commands = cd bin && scp $(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin +beagleCp.commands = cd $(DESTDIR) && scp $(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin beagleCp131.target = beagleCp131 -beagleCp131.commands = cd bin && scp $(QMAKE_TARGET).bin root@129.104.27.131://opt/stm32flashAje/hello.bin +beagleCp131.commands = cd $(DESTDIR) && scp $(QMAKE_TARGET).bin root@129.104.27.131://opt/stm32flashAje/hello.bin QMAKE_EXTRA_TARGETS += beagleCp beagleCp131 UCMODEL=stm32f4 diff --git a/bsp/src/stm32f4/OPLAYER/bsp.c b/bsp/src/stm32f4/OPLAYER/bsp.c --- a/bsp/src/stm32f4/OPLAYER/bsp.c +++ b/bsp/src/stm32f4/OPLAYER/bsp.c @@ -140,7 +140,7 @@ void bsp_uart_init() int bsp_TC_init() { - ads7843init(&TC0,TC_SPI,tcsetncs,tcbusy); + ads7843init(&TC0,TC_SPI,ADS7843_POWER_ADC_ON|ADS7843_MODE_12BITS,tcsetncs,tcbusy); } diff --git a/bsp/src/stm32f4/SOSmartPSU/SOSmartPSU.pro b/bsp/src/stm32f4/SOSmartPSU/SOSmartPSU.pro new file mode 100644 --- /dev/null +++ b/bsp/src/stm32f4/SOSmartPSU/SOSmartPSU.pro @@ -0,0 +1,22 @@ +TEMPLATE = lib + +TARGET=bsp + +CONFIG += bsp +CONFIG += gui power + +BSP = SOSmartPSU + +UCMODEL=stm32f4 + +SOURCES += bsp.c + +HEADERS += bsp.h + +LIBS+= -lgpio -luart -li2c -lspi -lpwm + + +BSPFILE = bsp.pri + + + diff --git a/bsp/src/stm32f4/SOSmartPSU/bsp.c b/bsp/src/stm32f4/SOSmartPSU/bsp.c new file mode 100644 --- /dev/null +++ b/bsp/src/stm32f4/SOSmartPSU/bsp.c @@ -0,0 +1,516 @@ +/*------------------------------------------------------------------------------ +-- This file is a part of the libuc, microcontroler library +-- Copyright (C) 2011, Alexis Jeandet +-- +-- This program is free software; you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation; either version 3 of the License, or +-- (at your option) any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program; if not, write to the Free Software +-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +------------------------------------------------------------------------------- +-- Author : Alexis Jeandet +-- Mail : alexis.jeandet@member.fsf.org +-------------------------------------------------------------------------------*/ +#include "bsp.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +uint32_t OSC0 =12000000; +uint32_t INTOSC =16000000; +uint32_t RTCOSC =32768; +uint32_t currentCpuFreq=0; +extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__]; +gpio_t TickLed = LED1; + +LCD_IF_t lcdIF0={ + .init = &bsp_FSMC_init, + .status = &bsp_lcd0_status, + .writereg = &bsp_lcd0_write_reg, + .readreg = &bsp_lcd0_read_reg, + .writeGRAM = &bsp_lcd0_writeGRAM, + .readGRAM = &bsp_lcd0_readGRAM +}; + +LCD_t lcd0={ + .interface = &lcdIF0, + .init = &D51E5TA7601init, + .paint = &D51E5TA7601paint, + .paintFB = D51E5TA7601paintFB, + .setFrame = &D51E5TA7601setFrame, + .paintText = &D51E5TA7601paintText, + .paintFilRect = &D51E5TA7601paintFilRect, + .getPix = &D51E5TA7601getPix, + .refreshenable = &D51E5TA7601refreshenable, + .width= 320, + .height = 480, + .isFrameBuffer = 0 +}; + +terminal_t terminal0; + +volatile int16_t* lcd0_CMD=(volatile int16_t*)0x60000000; +volatile int16_t* lcd0_DATA=(volatile int16_t*)0x61FFFFF0; +volatile int16_t* SRAM_DATA=(volatile int16_t*)0x64000000; + +// Frame buffers 300kB per buffer, RAM size=1M*16 -> 6.8 buffers max +volatile int16_t* FRAME_BUFFER0_data=(volatile int16_t*)0x64000000; +volatile int16_t* FRAME_BUFFER1_data=((volatile int16_t*)0x64000000)+(320*480); //300kB per buffer +LCD_t __attribute__ ((aligned (4))) FRAME_BUFFER0= +{ + .interface.buffer=(int16_t*)0x64000000, + .init = &D51E5TA7601init_FrameBuff, + .paint = &D51E5TA7601paint_FrameBuff, + .setFrame = &D51E5TA7601setFrame_FrameBuff, + .paintText = &D51E5TA7601paintText_FrameBuff, + .paintFilRect = &D51E5TA7601paintFilRect_FrameBuff, + .getPix = &D51E5TA7601getPix_FrameBuff, + .refreshenable = &D51E5TA7601refreshenable_FrameBuff, + .width= 480, + .height = 320, + .isFrameBuffer = 1 + }; + +LCD_t __attribute__ ((aligned (4))) FRAME_BUFFER1= +{ + .interface.buffer=(((int16_t*)0x64000000)+(320*480)), + .init = &D51E5TA7601init_FrameBuff, + .paint = &D51E5TA7601paint_FrameBuff, + .setFrame = &D51E5TA7601setFrame_FrameBuff, + .paintText = &D51E5TA7601paintText_FrameBuff, + .paintFilRect = &D51E5TA7601paintFilRect_FrameBuff, + .getPix = &D51E5TA7601getPix_FrameBuff, + .refreshenable = &D51E5TA7601refreshenable_FrameBuff, + .width= 480, + .height = 320, + .isFrameBuffer = 1 + }; +LCD_t* FRAME_BUFFER=&FRAME_BUFFER0; + +float VREF0 =(float)3.3; + +int bsp_init() +{ + int i=0; + for(i=0;i<32;i++) + { + __opnfiles__[i] = NULL; + } + bsp_GPIO_init(); + // bsp_uart_init(); + bsp_iic_init(); + bsp_spi_init(); + bsp_TC_init(); + bsp_FSMC_init(); + bsp_GTerm_init(); + printf("\r=====================\n\r"); + printf( "=====================\n\r"); + printf(BSP); + printf(" initialised\n\r"); + printf( "=====================\n\r"); + return 1; +} + +void bsp_GPIO_init() +{ + gpio_t gpio1 = gpioopen(LED1); + gpio_t gpio2 = gpioopen(LED2); + gpio_t gpio3 = gpioopen(LED3); + gpio_t gpio4 = gpioopen(PSU_DISABLE); + gpio_t gpio5 = gpioopen(PSU_ALERT_5V); + gpio_t gpio6 = gpioopen(PSU_ALERT_1_5V); + gpio_t gpio7 = gpioopen(PSU_ALERT_3_3V); + gpio_t gpio8 = gpioopen(BP1); + gpio_t gpio9 = gpioopen(BP2); + gpio_t gpio10 = gpioopen(BP3); + gpio_t gpio11 = gpioopen(BP4); + gpio_t gpio12 = gpioopen(TC_IRQ); + gpiosetspeed(&gpio1,gpiohighspeed); + gpiosetspeed(&gpio2,gpiohighspeed); + gpiosetspeed(&gpio3,gpiohighspeed); + gpiosetspeed(&gpio4,gpiohighspeed); + gpiosetspeed(&gpio5,gpiohighspeed); + gpiosetspeed(&gpio6,gpiohighspeed); + gpiosetspeed(&gpio7,gpiohighspeed); + gpiosetspeed(&gpio8,gpiohighspeed); + gpiosetspeed(&gpio9,gpiohighspeed); + gpiosetspeed(&gpio10,gpiohighspeed); + gpiosetspeed(&gpio11,gpiohighspeed); + gpiosetspeed(&gpio12,gpiohighspeed); + gpioclr(PSU_DISABLE); + gpiosetdir(&gpio1,gpiooutdir); + gpiosetdir(&gpio3,gpiooutdir); + gpiosetdir(&gpio2,gpiooutdir); + gpiosetdir(&gpio4,gpiooutdir); + gpiosetdir(&gpio5,gpioindir); + gpiosetdir(&gpio6,gpioindir); + gpiosetdir(&gpio7,gpioindir); + gpiosetdir(&gpio8,gpioindir); + gpiosetdir(&gpio9,gpioindir); + gpiosetdir(&gpio10,gpioindir); + gpiosetdir(&gpio11,gpioindir); + gpiosetdir(&gpio12,gpioindir); + gpiosetpulltype(&gpio4,gpiopushpulltype); + gpiosetpulltype(&gpio12,gpiopulluptype); + gpioclr(PSU_DISABLE); + pwmopen(PWM9_CH2,LCD_BACKLIGHT); + int error = pwmsetconfig(PWM9_CH2,100,80.0); +} + +void bsp_uart_init() +{ + if(__opnfiles__[1]==NULL) + { + streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice)); + uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1); + uartmkstreamdev(uart,fd1); + __opnfiles__[1] = fd1; + } + else + { + uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1); + } +} + + + +int bsp_FSMC_init() +{ +#define GPIOGETPORT(gpio) ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA)) +#define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) + + gpio_t gpio1 = gpioopen(LCD_RESET); + gpiosetspeed(&gpio1,gpiohighspeed); + gpiosetdir(&gpio1,gpiooutdir); + gpioclr(LCD_RESET); + + gpio_t LCD_DBxList[]={ + LCD_CS, + LCD_RS, + LCD_WR, + LCD_RD, + LCD_D0, + LCD_D1, + LCD_D2, + LCD_D3, + LCD_D4, + LCD_D5, + LCD_D6, + LCD_D7, + LCD_D8, + LCD_D9, + LCD_D10, + LCD_D11, + LCD_D12, + LCD_D13, + LCD_D14, + LCD_D15}; + + for(int i=0;i<20;i++) + { + gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); + LCD_DBx |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype; + gpiosetconfig(&LCD_DBx); + GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); + } + + FSMC_NORSRAMInitTypeDef FSMC_NORSRAMInitStructure; + FSMC_NORSRAMTimingInitTypeDef p,readtim; + + /* Enable FSMC clock */ + RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE); + + /*-- FSMC Configuration ------------------------------------------------------*/ + /*----------------------- SRAM Bank 3 ----------------------------------------*/ + /* FSMC_Bank1_NORSRAM3 configuration */ + p.FSMC_AddressSetupTime = 0xf; + p.FSMC_AddressHoldTime = 0xf; + //ili9328 -> data setup time > 10ns + p.FSMC_DataSetupTime = 0xf; + if(getCpuFreq()>100*1000*1000) + p.FSMC_DataSetupTime = 0xf;// 11; + p.FSMC_BusTurnAroundDuration = 0xf; + p.FSMC_CLKDivision = 0; + p.FSMC_DataLatency = 0xf; + //ili9328 -> data hold time > 15ns + if(getCpuFreq()>66*1000*1000) + p.FSMC_DataLatency = 0xf; + p.FSMC_AccessMode = FSMC_AccessMode_A; + + readtim.FSMC_AddressSetupTime = 0xf; + readtim.FSMC_AddressHoldTime = 0xf; + //p.FSMC_DataSetupTime = 9; + readtim.FSMC_DataSetupTime = 0xf ;// 11; + if(getCpuFreq()>100*1000*1000) + readtim.FSMC_DataSetupTime = 0xf;// 11; + readtim.FSMC_BusTurnAroundDuration = 0xf; + readtim.FSMC_CLKDivision = 2; + readtim.FSMC_DataLatency = 0xf; + if(getCpuFreq()>66*1000*1000) + readtim.FSMC_DataLatency = 0xf; + readtim.FSMC_AccessMode = FSMC_AccessMode_A; + + FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1; + FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable; + FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM; + FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b; + FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable; + FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable; + FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low; + FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable; + FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState; + FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable; + FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable; + FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable; + FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable; + FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &readtim; + FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p; + + FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure); + + /* Enable FSMC NOR/SRAM Bank1 */ + FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE); + gpio_t SRAM_DBxList[]={ + SRAM_A0, + SRAM_A1, + SRAM_A2, + SRAM_A3, + SRAM_A4, + SRAM_A5, + SRAM_A6, + SRAM_A7, + SRAM_A8, + SRAM_A9, + SRAM_A10, + SRAM_A11, + SRAM_A12, + SRAM_A13, + SRAM_A14, + SRAM_A15, + SRAM_A16, + SRAM_A17, + SRAM_A18, + SRAM_A19, + SRAM_NBL0, + SRAM_NBL1, + SRAM_NCE + }; + + for(int i=0;i<23;i++) + { + gpio_t SRAM_DBx = gpioopen(SRAM_DBxList[i]); + SRAM_DBx |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype; + gpiosetconfig(&SRAM_DBx); + GPIO_PinAFConfig(GPIOGETPORT(SRAM_DBx), (uint8_t)(SRAM_DBx & 0xF), GPIO_AF_FSMC); + } + /*-- FSMC Configuration ------------------------------------------------------*/ + // p.FSMC_AddressSetupTime = 3; + p.FSMC_AddressSetupTime = 1; + p.FSMC_AddressHoldTime = 1; + // p.FSMC_DataSetupTime = 6; + p.FSMC_DataSetupTime = 1; + p.FSMC_BusTurnAroundDuration = 1; + p.FSMC_CLKDivision = 0; + p.FSMC_DataLatency = 1; + p.FSMC_AccessMode = FSMC_AccessMode_A; + + FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM2; + FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable; + FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_PSRAM; + FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b; + FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable; + FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable; + FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low; + FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable; + FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState; + FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable; + FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable; + FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable; + FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable; + FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p; + FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p; + + FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure); + + /*!< Enable FSMC Bank1_SRAM2 Bank */ + FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM2, ENABLE); + gpioset(LCD_RESET); + delay_100us(500); + gpioclr(LCD_RESET); + delay_100us(500); + gpioset(LCD_RESET); + lcd0.init(&lcd0); + return 1; +} + +void bsp_spi_init() +{ + +// ads7843init(&tc_dev,spi1,ADS7843_POWER_ADC_ON|ADS7843_MODE_12BITS,&TC_setnCS,&TC_busy); + spiopenandconfig(spi1,spimaster|spi8bits|spimsbfirst|spiclkfirstedge,10000000,TC_DIN,TC_DOUT,TC_CLK,-1); +} + + +void bsp_iic_init() +{ + i2copenandconfig(i2c3,0,10000,PH8,PH7); +} + +void bsp_SD_init() +{ + +} + +void vs10XXclearXCS(){} +void vs10XXsetXCS(){} +int vs10XXDREQ() +{ + return 1; +} + + +void bsppowersdcard(char onoff) //always ON +{ + +} + +char bspsdcardpresent() +{ + return 0; +} + +char bspsdcardwriteprotected() +{ + return 0; +} + +void bspsdcardselect(char YESNO) +{ + +} + + +void bsp_lcd0_write_reg(uint32_t reg,uint32_t data) +{ + *lcd0_CMD=(uint16_t)reg; + *lcd0_DATA=(uint16_t)data; +} + +uint32_t bsp_lcd0_read_reg(uint32_t reg) +{ + uint16_t value; + *lcd0_CMD=(uint16_t)reg; + value = *lcd0_DATA; + value = *lcd0_DATA; + return value; +} + +void bsp_lcd0_writeGRAM(void* buffer,uint32_t count) +{ + *lcd0_CMD=(uint16_t)D51E5TA7601_REGISTER_WRITEDATATOGRAM; + uint16_t* castedBuff=(uint16_t*)buffer; + for(int i=0;i<(int)count;i++) + { + *lcd0_DATA=castedBuff[i]; + } +} + +void bsp_lcd0_setGRAM() +{ + *lcd0_CMD=(uint16_t)D51E5TA7601_REGISTER_WRITEDATATOGRAM; +} + +void bsp_lcd0_readGRAM(void* buffer,uint32_t count) +{ + uint16_t* castedBuff=(uint16_t*)buffer; + *lcd0_CMD=(uint16_t)D51E5TA7601_REGISTER_WRITEDATATOGRAM; + castedBuff[0]=lcd0_DATA[0]; + for(int i=0;i<(int)count;i++) + { + castedBuff[i]=lcd0_DATA[0]; + } +} + +uint32_t bsp_lcd0_status() +{ + uint16_t status = lcd0_CMD[0]; + return (uint32_t)status; +} + +void TC_setnCS(char val) +{ + return gpiosetval(TC_BUSY,val); +} + +int TC_busy() +{ + return gpiogetval(TC_BUSY); +} + +void bsp_TC_init() +{ +#define GPIOGETPORT(gpio) ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA)) +#define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) + + gpio_t gpio1 = gpioopen(TC_BUSY); + gpio1 |= gpiohighspeed | gpioindir | gpionopulltype; + gpiosetconfig(&gpio1); + + gpio1 = gpioopen(TC_IRQ); + gpio1 |= gpiohighspeed | gpioindir | gpiopulluptype; + gpiosetconfig(&gpio1); + + gpio1 = gpioopen(TC_CS); + gpio1 |= gpiohighspeed | gpiooutdir | gpionopulltype; + gpiosetconfig(&gpio1); + + gpio1 = gpioopen(TC_CLK); + gpio1 |= gpiohighspeed | gpioaf | gpionopulltype; + gpiosetconfig(&gpio1); + GPIO_PinAFConfig(GPIOGETPORT(TC_CLK), (uint8_t)(TC_CLK & 0xF), GPIO_AF_SPI1); + + gpio1 = gpioopen(TC_DIN); + gpio1 |= gpiohighspeed | gpioaf | gpionopulltype; + gpiosetconfig(&gpio1); + GPIO_PinAFConfig(GPIOGETPORT(gpio1), (uint8_t)(gpio1 & 0xF), GPIO_AF_SPI1); + + gpio1 = gpioopen(TC_DOUT); + gpio1 |= gpiohighspeed | gpioaf | gpionopulltype; + gpiosetconfig(&gpio1); + GPIO_PinAFConfig(GPIOGETPORT(gpio1), (uint8_t)(gpio1 & 0xF), GPIO_AF_SPI1); +} + + +void bsp_GTerm_init() +{ + FRAME_BUFFER->init(FRAME_BUFFER); + if(__opnfiles__[1]==NULL) + { + //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t)); + streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice)); + terminal_init(&terminal0 ,FRAME_BUFFER,&ComicSansMS_8,fd1); + __opnfiles__[1] = fd1; + } + else + { + + } +} + diff --git a/bsp/src/stm32f4/SOSmartPSU/bsp.h b/bsp/src/stm32f4/SOSmartPSU/bsp.h new file mode 100644 --- /dev/null +++ b/bsp/src/stm32f4/SOSmartPSU/bsp.h @@ -0,0 +1,202 @@ +/*------------------------------------------------------------------------------ +-- This file is a part of the libuc, microcontroler library +-- Copyright (C) 2011, Alexis Jeandet +-- +-- This program is free software; you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation; either version 3 of the License, or +-- (at your option) any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program; if not, write to the Free Software +-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +------------------------------------------------------------------------------- +-- Author : Alexis Jeandet +-- Mail : alexis.jeandet@member.fsf.org +-------------------------------------------------------------------------------*/ +#ifndef BSP_H +#define BSP_H +#include +#include +#include +#include +#include +#include +#include + +#define __MAX_OPENED_FILES__ 4 +#define __FS_ROOT_SIZE__ 4 +/* +#ifndef PD8 + #define PD8 +#endif +#ifndef PD9 + #define PD9 +#endif +*/ + + +#define LED1 PF6 +#define LED2 PF7 +#define LED3 PF8 + +#define PSU_DISABLE PH2 +#define DCIN_ALERT PH12 +#define PSU_ALERT_5V PH9 +#define PSU_ALERT_1_5V PH10 +#define PSU_ALERT_3_3V PH11 + +#define LCD_RESET PE2 +#define LCD_BACKLIGHT PE6 +#define BP1 PI1 +#define BP2 PI2 +#define BP3 PD2 +#define BP4 PD3 + +#define TC_IRQ PA3 +#define TC_CS PA4 +#define TC_CLK PA5 +#define TC_DOUT PA6 +#define TC_DIN PA7 +#define TC_BUSY PB0 + + + +//LCD Signals +#define LCD_CS PD7 //FSMC_NE1 +#define LCD_RS PE4 //FSMC_A20 +#define LCD_WR PD5 //FSMC_NWE +#define LCD_RD PD4 //FSMC_NOE +#define LCD_RST PE2 + +#define LCD_D0 PD14 +#define LCD_D1 PD15 +#define LCD_D2 PD0 +#define LCD_D3 PD1 +#define LCD_D4 PE7 +#define LCD_D5 PE8 +#define LCD_D6 PE9 +#define LCD_D7 PE10 +#define LCD_D8 PE11 +#define LCD_D9 PE12 +#define LCD_D10 PE13 +#define LCD_D11 PE14 +#define LCD_D12 PE15 +#define LCD_D13 PD8 +#define LCD_D14 PD9 +#define LCD_D15 PD10 + +//SSRAM Signals +#define SRAM_NBL0 PE0 //FSMC_NBL0 +#define SRAM_NBL1 PE1 //FSMC_NBL1 +#define SRAM_NOE PD4 //FSMC_NOE +#define SRAM_NWE PD5 //FSMC_NWE +#define SRAM_NCE PG9 //FSMC_NE2 + +#define SRAM_A0 PF0 //FSMC_A0 +#define SRAM_A1 PF1 //FSMC_A1 +#define SRAM_A2 PF2 //FSMC_A2 +#define SRAM_A3 PF3 //FSMC_A3 +#define SRAM_A4 PF4 //FSMC_A4 +#define SRAM_A5 PF5 //FSMC_A5 +#define SRAM_A6 PF12 //FSMC_A6 +#define SRAM_A7 PF13 //FSMC_A7 +#define SRAM_A8 PF14 //FSMC_A8 +#define SRAM_A9 PF15 //FSMC_A9 +#define SRAM_A10 PG0 //FSMC_A10 +#define SRAM_A11 PG1 //FSMC_A11 +#define SRAM_A12 PG2 //FSMC_A12 +#define SRAM_A13 PG3 //FSMC_A13 +#define SRAM_A14 PG4 //FSMC_A14 +#define SRAM_A15 PG5 //FSMC_A15 +#define SRAM_A16 PD11 //FSMC_A16 +#define SRAM_A17 PD12 //FSMC_A17 +#define SRAM_A18 PD13 //FSMC_A18 +#define SRAM_A19 PE3 //FSMC_A19 + +#define SRAM_D0 PD14 +#define SRAM_D1 PD15 +#define SRAM_D2 PD0 +#define SRAM_D3 PD1 +#define SRAM_D4 PE7 +#define SRAM_D5 PE8 +#define SRAM_D6 PE9 +#define SRAM_D7 PE10 +#define SRAM_D8 PE11 +#define SRAM_D9 PE12 +#define SRAM_D10 PE13 +#define SRAM_D11 PE14 +#define SRAM_D12 PE15 +#define SRAM_D13 PD8 +#define SRAM_D14 PD9 +#define SRAM_D15 PD10 + + +extern float VREF0; + +extern uint32_t currentCpuFreq; +extern LCD_t lcd0; + +extern LCD_t* FRAME_BUFFER; +extern LCD_t FRAME_BUFFER0; +extern LCD_t FRAME_BUFFER1; + + +extern int bsp_init(); + +extern void bsp_GPIO_init(); +extern void bsp_uart_init(); +extern void bsp_iic_init(); +extern void bsp_spi_init(); +extern void bsp_SD_init(); +extern void bsp_TC_init(); +extern void bsp_GTerm_init(); +extern int bsp_FSMC_init(); + +extern void TC_setnCS(char val); +extern int TC_busy(); + +/* VS1053 */ +extern void clearXCS(); +extern void setXCS(); +extern int vs10XXDREQ(); + +/* SD CARD */ +void bsppowersdcard(char onoff); +char bspsdcardpresent(); +void bspsdcardselect(char YESNO); +char bspsdcardwriteprotected(); + + +void bsp_lcd0_write_reg(uint32_t reg,uint32_t data); +uint32_t bsp_lcd0_read_reg(uint32_t reg); +void bsp_lcd0_writeGRAM(void *buffer, uint32_t count); +void bsp_lcd0_readGRAM(void *buffer, uint32_t count); +uint32_t bsp_lcd0_status(); +void bsp_lcd0_setGRAM(); + +#endif + + + + + + + + + + + + + + + + + + + diff --git a/bsp/src/stm32f4/SOSmartPSU/bsp.pri b/bsp/src/stm32f4/SOSmartPSU/bsp.pri new file mode 100644 --- /dev/null +++ b/bsp/src/stm32f4/SOSmartPSU/bsp.pri @@ -0,0 +1,4 @@ +CPU=stm32f4xxxG +DEFINES+=BSP=\\\"SOSmartPSU\\\" + +UCMODEL=stm32f4 diff --git a/bsp/src/stm32f4/stm32f4.pro b/bsp/src/stm32f4/stm32f4.pro --- a/bsp/src/stm32f4/stm32f4.pro +++ b/bsp/src/stm32f4/stm32f4.pro @@ -11,7 +11,8 @@ SUBDIRS += STM32F4Discovery \ OPLAYER \ STM32-E407 \ STM32F429Discovery \ - STM32F4Discovery_35LCD + STM32F4Discovery_35LCD \ + SOSmartPSU diff --git a/examples/helloWorld/helloWorld.pro b/examples/helloWorld/helloWorld.pro --- a/examples/helloWorld/helloWorld.pro +++ b/examples/helloWorld/helloWorld.pro @@ -4,7 +4,8 @@ contains( UCMODEL , simulator ) { BSP = SIMULATOR } contains( UCMODEL , stm32f4 ) { - BSP = STM32F4Eval + #BSP = STM32F4Eval + BSP = SOSmartPSU } SOURCES += \ diff --git a/include/GRAPHIC/CONTROLERS/D51E5TA7601.h b/include/GRAPHIC/CONTROLERS/D51E5TA7601.h --- a/include/GRAPHIC/CONTROLERS/D51E5TA7601.h +++ b/include/GRAPHIC/CONTROLERS/D51E5TA7601.h @@ -39,6 +39,7 @@ extern int D51E5TA7601init(struct LCD_t extern void D51E5TA7601setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H); extern void D51E5TA7601setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress); extern void D51E5TA7601paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height); +extern void D51E5TA7601paintFB(struct LCD_t* LCD,struct LCD_t* frameBuffer); extern void D51E5TA7601paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color); extern void D51E5TA7601paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor); extern void D51E5TA7601paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor); @@ -47,56 +48,84 @@ extern void D51E5TA7601getPix(struct LCD extern void D51E5TA7601refreshenable(struct LCD_t* LCD,int enable); extern void D51E5TA7601paintChar(LCD_t* LCD,char buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color); -#define ILI9328_REGISTER_DRIVERCODEREAD ((uint32_t) 0x0000 ) -#define ILI9328_REGISTER_DRIVEROUTPUTCONTROL1 ((uint32_t) 0x0001 ) -#define ILI9328_REGISTER_LCDDRIVINGCONTROL ((uint32_t) 0x0002 ) -#define ILI9328_REGISTER_ENTRYMODE ((uint32_t) 0x0003 ) -#define ILI9328_REGISTER_RESIZECONTROL ((uint32_t) 0x0004 ) -#define ILI9328_REGISTER_DISPLAYCONTROL1 ((uint32_t) 0x0007 ) -#define ILI9328_REGISTER_DISPLAYCONTROL2 ((uint32_t) 0x0008 ) -#define ILI9328_REGISTER_DISPLAYCONTROL3 ((uint32_t) 0x0009 ) -#define ILI9328_REGISTER_DISPLAYCONTROL4 ((uint32_t) 0x000A ) -#define ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL1 ((uint32_t) 0x000C ) -#define ILI9328_REGISTER_FRAMEMAKERPOSITION ((uint32_t) 0x000D ) -#define ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL2 ((uint32_t) 0x000F ) -#define ILI9328_REGISTER_POWERCONTROL1 ((uint32_t) 0x0010 ) -#define ILI9328_REGISTER_POWERCONTROL2 ((uint32_t) 0x0011 ) -#define ILI9328_REGISTER_POWERCONTROL3 ((uint32_t) 0x0012 ) -#define ILI9328_REGISTER_POWERCONTROL4 ((uint32_t) 0x0013 ) -#define ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET ((uint32_t) 0x0020 ) -#define ILI9328_REGISTER_VERTICALGRAMADDRESSSET ((uint32_t) 0x0021 ) -#define ILI9328_REGISTER_WRITEDATATOGRAM ((uint32_t) 0x0022 ) -#define ILI9328_REGISTER_POWERCONTROL7 ((uint32_t) 0x0029 ) -#define ILI9328_REGISTER_FRAMERATEANDCOLORCONTROL ((uint32_t) 0x002B ) -#define ILI9328_REGISTER_GAMMACONTROL1 ((uint32_t) 0x0030 ) -#define ILI9328_REGISTER_GAMMACONTROL2 ((uint32_t) 0x0031 ) -#define ILI9328_REGISTER_GAMMACONTROL3 ((uint32_t) 0x0032 ) -#define ILI9328_REGISTER_GAMMACONTROL4 ((uint32_t) 0x0035 ) -#define ILI9328_REGISTER_GAMMACONTROL5 ((uint32_t) 0x0036 ) -#define ILI9328_REGISTER_GAMMACONTROL6 ((uint32_t) 0x0037 ) -#define ILI9328_REGISTER_GAMMACONTROL7 ((uint32_t) 0x0038 ) -#define ILI9328_REGISTER_GAMMACONTROL8 ((uint32_t) 0x0039 ) -#define ILI9328_REGISTER_GAMMACONTROL9 ((uint32_t) 0x003C ) -#define ILI9328_REGISTER_GAMMACONTROL10 ((uint32_t) 0x003D ) -#define ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION ((uint32_t) 0x0050 ) -#define ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION ((uint32_t) 0x0051 ) -#define ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION ((uint32_t) 0x0052 ) -#define ILI9328_REGISTER_VERTICALADDRESSENDPOSITION ((uint32_t) 0x0053 ) -#define ILI9328_REGISTER_DRIVEROUTPUTCONTROL2 ((uint32_t) 0x0060 ) -#define ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL ((uint32_t) 0x0061 ) -#define ILI9328_REGISTER_VERTICALSCROLLCONTROL ((uint32_t) 0x006A ) -#define ILI9328_REGISTER_PARTIALIMAGE1DISPLAYPOSITION ((uint32_t) 0x0080 ) -#define ILI9328_REGISTER_PARTIALIMAGE1AREASTARTLINE ((uint32_t) 0x0081 ) -#define ILI9328_REGISTER_PARTIALIMAGE1AREAENDLINE ((uint32_t) 0x0082 ) -#define ILI9328_REGISTER_PARTIALIMAGE2DISPLAYPOSITION ((uint32_t) 0x0083 ) -#define ILI9328_REGISTER_PARTIALIMAGE2AREASTARTLINE ((uint32_t) 0x0084 ) -#define ILI9328_REGISTER_PARTIALIMAGE2AREAENDLINE ((uint32_t) 0x0085 ) -#define ILI9328_REGISTER_PANELINTERFACECONTROL1 ((uint32_t) 0x0090 ) -#define ILI9328_REGISTER_PANELINTERFACECONTROL2 ((uint32_t) 0x0092 ) -#define ILI9328_REGISTER_PANELINTERFACECONTROL4 ((uint32_t) 0x0095 ) -#define ILI9328_REGISTER_OTPVCMPROGRAMMINGCONTROL ((uint32_t) 0x00A1 ) -#define ILI9328_REGISTER_OTPVCMSTATUSANDENABLE ((uint32_t) 0x00A2 ) -#define ILI9328_REGISTER_OTPPROGRAMMINGIDKEY ((uint32_t) 0x00A5 ) + + +extern int D51E5TA7601init_FrameBuff(struct LCD_t* LCD); +extern void D51E5TA7601setFrame_FrameBuff(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H); +extern void D51E5TA7601paint_FrameBuff(LCD_t *frameBuff, void *buffer, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height); +extern void D51E5TA7601paintText_FrameBuff(LCD_t *frameBuff,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color); +extern void D51E5TA7601paintFilRect_FrameBuff(LCD_t *frameBuff,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor); +extern void D51E5TA7601getPix_FrameBuff(LCD_t *frameBuff,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h); +extern void D51E5TA7601refreshenable_FrameBuff(struct LCD_t* LCD,int enable); + + + +#define D51E5TA7601_DEV_ID ((uint32_t) 0x7601 ) + +#define D51E5TA7601_REGISTER_DRIVERCODEREAD ((uint32_t) 0x0000 ) +#define D51E5TA7601_REGISTER_STARTOSCILATION ((uint32_t) 0x0000 ) +#define D51E5TA7601_REGISTER_DRIVEROUTPUTCONTROL1 ((uint32_t) 0x0001 ) +#define D51E5TA7601_REGISTER_LCDDRIVINGCONTROL ((uint32_t) 0x0002 ) +#define D51E5TA7601_REGISTER_ENTRYMODE ((uint32_t) 0x0003 ) +#define D51E5TA7601_REGISTER_DISPLAYCONTROL1 ((uint32_t) 0x0004 ) +#define D51E5TA7601_REGISTER_DISPLAYCONTROL2 ((uint32_t) 0x0005 ) +#define D51E5TA7601_REGISTER_DISPLAYCONTROL3 ((uint32_t) 0x0006 ) +#define D51E5TA7601_REGISTER_DISPLAYCONTROL4 ((uint32_t) 0x0007 ) +#define D51E5TA7601_REGISTER_BLANKPERDIODCTRL ((uint32_t) 0x0008 ) +#define D51E5TA7601_REGISTER_DISPLAYCONTROL5 ((uint32_t) 0x0009 ) +#define D51E5TA7601_REGISTER_FRAMECYCLECONTROL ((uint32_t) 0x000A ) +#define D51E5TA7601_REGISTER_EXTERNALDISPLAYCTRL ((uint32_t) 0x000B ) +#define D51E5TA7601_REGISTER_LCDINTERFACECONTROL ((uint32_t) 0x000C ) +#define D51E5TA7601_REGISTER_GATESCANPOSITIONCTRL ((uint32_t) 0x000D ) +#define D51E5TA7601_REGISTER_FRAMESIGNALCONTROL ((uint32_t) 0x000E ) +#define D51E5TA7601_REGISTER_DISPLAYCONTROL6 ((uint32_t) 0x000F ) +#define D51E5TA7601_REGISTER_POWERCONTROL1 ((uint32_t) 0x0010 ) +#define D51E5TA7601_REGISTER_POWERCONTROL2 ((uint32_t) 0x0011 ) +#define D51E5TA7601_REGISTER_POWERCONTROL3 ((uint32_t) 0x0012 ) +#define D51E5TA7601_REGISTER_POWERCONTROL4 ((uint32_t) 0x0013 ) +#define D51E5TA7601_REGISTER_POWERCONTROL5 ((uint32_t) 0x0014 ) +#define D51E5TA7601_REGISTER_POWERCONTROL6 ((uint32_t) 0x0015 ) +#define D51E5TA7601_REGISTER_POWERCONTROL7 ((uint32_t) 0x0016 ) +#define D51E5TA7601_REGISTER_VERTICALGRAMADDRESSSET ((uint32_t) 0x0020 ) +#define D51E5TA7601_REGISTER_HORIZONTALGRAMADDRESSSET ((uint32_t) 0x0021 ) +#define D51E5TA7601_REGISTER_WRITEDATATOGRAM ((uint32_t) 0x0022 ) + +#define D51E5TA7601_REGISTER_GAMMACONTROL1 ((uint32_t) 0x0028 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL2 ((uint32_t) 0x0029 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL3 ((uint32_t) 0x002A) +#define D51E5TA7601_REGISTER_GAMMACONTROL4 ((uint32_t) 0x002B ) +#define D51E5TA7601_REGISTER_GAMMACONTROL5 ((uint32_t) 0x002C ) +#define D51E5TA7601_REGISTER_GAMMACONTROL6 ((uint32_t) 0x002D ) +#define D51E5TA7601_REGISTER_GAMMACONTROL7 ((uint32_t) 0x002E ) +#define D51E5TA7601_REGISTER_GAMMACONTROL8 ((uint32_t) 0x002F ) +#define D51E5TA7601_REGISTER_GAMMACONTROL9 ((uint32_t) 0x0030 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL10 ((uint32_t) 0x0031 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL11 ((uint32_t) 0x0032 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL12 ((uint32_t) 0x0033 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL13 ((uint32_t) 0x0034 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL14 ((uint32_t) 0x0035 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL15 ((uint32_t) 0x0036 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL16 ((uint32_t) 0x0037 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL17 ((uint32_t) 0x0038 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL18 ((uint32_t) 0x0039 ) +#define D51E5TA7601_REGISTER_GAMMACONTROL19 ((uint32_t) 0x003A ) +#define D51E5TA7601_REGISTER_GAMMACONTROL20 ((uint32_t) 0x003B ) +#define D51E5TA7601_REGISTER_GAMMACONTROL21 ((uint32_t) 0x003C ) +#define D51E5TA7601_REGISTER_PARTIALSPLTSCREENS1 ((uint32_t) 0x0040 ) +#define D51E5TA7601_REGISTER_PARTIALSPLTSCREENE1 ((uint32_t) 0x0041 ) +#define D51E5TA7601_REGISTER_PARTIALSPLTSCREENS2 ((uint32_t) 0x0042 ) +#define D51E5TA7601_REGISTER_PARTIALSPLTSCREENE2 ((uint32_t) 0x0043 ) +#define D51E5TA7601_REGISTER_HORIZONTALADDRESSSTARTPOSITION ((uint32_t) 0x0045 ) +#define D51E5TA7601_REGISTER_HORIZONTALADDRESSENDPOSITION ((uint32_t) 0x0044 ) +#define D51E5TA7601_REGISTER_VERTICALADDRESSSTARTPOSITION ((uint32_t) 0x0047 ) +#define D51E5TA7601_REGISTER_VERTICALADDRESSENDPOSITION ((uint32_t) 0x0046 ) +#define D51E5TA7601_REGISTER_BACKLIGHTCONTROL1 ((uint32_t) 0x0048 ) +#define D51E5TA7601_REGISTER_BACKLIGHTCONTROL2 ((uint32_t) 0x0049 ) +#define D51E5TA7601_REGISTER_BACKLIGHTCONTROL3 ((uint32_t) 0x004A ) +#define D51E5TA7601_REGISTER_BACKLIGHTCONTROL4 ((uint32_t) 0x004B ) +#define D51E5TA7601_REGISTER_VCOMCONTROL1 ((uint32_t) 0x0050 ) +#define D51E5TA7601_REGISTER_VCOMCONTROL2 ((uint32_t) 0x0051 ) +#define D51E5TA7601_REGISTER_CABCCONTROL ((uint32_t) 0x0067 ) #ifdef _PRVATE_D51E5TA7601_ void ili9328cpFrame(LCD_t* LCD,void* buffer,int x,int y,int w, int h); diff --git a/include/GRAPHIC/CONTROLERS/genericLCD_Controler.h b/include/GRAPHIC/CONTROLERS/genericLCD_Controler.h --- a/include/GRAPHIC/CONTROLERS/genericLCD_Controler.h +++ b/include/GRAPHIC/CONTROLERS/genericLCD_Controler.h @@ -29,6 +29,7 @@ typedef struct LCD_IF_t { int (*init)(); + uint32_t (*status)(); void (*writereg)(uint32_t reg,uint32_t data); uint32_t (*readreg)(uint32_t reg); void (*writeGRAM)(void* buffer,uint32_t count); @@ -43,7 +44,7 @@ typedef struct LCD_IF_t typedef struct LCD_BUFFER_t { - void* buffer; /**< Buffer pointer write on pixels you want to print*/ + volatile void* buffer; /**< Buffer pointer write on pixels you want to print*/ uint32_t size; /**< The size of the buffer in bytes*/ uint16_t X; /**< The X position of the buffer*/ uint16_t Y; /**< The Y position of the buffer*/ @@ -51,19 +52,29 @@ typedef struct LCD_BUFFER_t uint16_t H; /**< The height of the buffer*/ }LCD_BUFFER_t; +typedef union interface_u +{ + LCD_IF_t* lcd_interface; + volatile void* buffer; +}interface_u; + typedef struct LCD_t { - LCD_IF_t* interface; +// LCD_IF_t* interface; + interface_u interface; int (*init)(struct LCD_t* LCD); void (*paint)(struct LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height); + void (*paintFB)(struct LCD_t* LCD,struct LCD_t* frameBuffer); + void (*setFrame)(struct LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H); void (*paintText)(struct LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color); void (*paintFilRect)(struct LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor); void (*getPix)(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h); void (*refreshenable)(struct LCD_t* LCD,int enable); - LCD_BUFFER_t* (*getBuffer)(struct LCD_t* LCD); +// LCD_BUFFER_t* (*getBuffer)(struct LCD_t* LCD); void (*writeBuffer)(struct LCD_t* LCD,LCD_BUFFER_t* buffer); uint16_t width; uint16_t height; + char isFrameBuffer; }LCD_t; diff --git a/include/GRAPHIC/TC_CONTROLERS/ADS7843.h b/include/GRAPHIC/TC_CONTROLERS/ADS7843.h --- a/include/GRAPHIC/TC_CONTROLERS/ADS7843.h +++ b/include/GRAPHIC/TC_CONTROLERS/ADS7843.h @@ -25,16 +25,58 @@ #include #include +#define ADS7843_CONFIG_MASK 0x0F +#define ADS7843_MODE_8BITS 0x08 +#define ADS7843_MODE_12BITS 0x00 +#define ADS7843_REFMODE_SINGLE 0x04 +#define ADS7843_REFMODE_DIFF 0x00 +#define ADS7843_POWER_ADC_ON 0x01 +#define ADS7843_POWER_ADC_OFF 0x00 +#define ADS7843_POWER_REF_ON 0x02 +#define ADS7843_POWER_REF_OFF 0x00 +#define ADS7843_START 0x80 +#define ADS7843_MEAS_X_POS 0x50 +#define ADS7843_MEAS_Y_POS 0x10 +#define ADS7843_MEAS_Z1_POS 0x30 +#define ADS7843_MEAS_Z2_POS 0x40 + +#define ADS7843_MEAS_X_POS_SINGLE (ADS7843_MEAS_X_POS |ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_Y_POS_SINGLE (ADS7843_MEAS_Y_POS |ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_Z1_POS_SINGLE (ADS7843_MEAS_Z1_POS|ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_Z2_POS_SINGLE (ADS7843_MEAS_Z2_POS|ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_TEMP0_SINGLE ( 0x00 |ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_TEMP1_SINGLE ( 0x70 |ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_AUX_SINGLE ( 0x60 |ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_VBAT_SINGLE ( 0x20 |ADS7843_REFMODE_SINGLE) +#define ADS7843_MEAS_Z2_POS_SINGLE (ADS7843_MEAS_Z2_POS|ADS7843_REFMODE_SINGLE) + +#define ADS7843_MEAS_X_POS_DIFF (ADS7843_MEAS_X_POS |ADS7843_REFMODE_DIFF) +#define ADS7843_MEAS_Y_POS_DIFF (ADS7843_MEAS_Y_POS |ADS7843_REFMODE_DIFF) +#define ADS7843_MEAS_Z1_POS_DIFF (ADS7843_MEAS_Z1_POS|ADS7843_REFMODE_DIFF) +#define ADS7843_MEAS_Z2_POS_DIFF (ADS7843_MEAS_Z2_POS|ADS7843_REFMODE_DIFF) + typedef struct ADS7843_t { spi_t spidev; void (*setnCS)(char); int (*busy)(); + char config; + uint16_t zeroX; + uint16_t zeroY; + uint16_t zeroRtouch; + uint16_t xMin; + uint16_t xMax; + uint16_t yMin; + uint16_t yMax; + char delta; }ADS7843_t; -extern int ads7843init(ADS7843_t *dev, spi_t spidev,void (*setnCS)(char),int (*busy)()); +extern int ads7843init(ADS7843_t *dev, spi_t spidev,char config,void (*setnCS)(char),int (*busy)()); extern int ads7843read(ADS7843_t *dev,int* x,int* y); +extern int ads7843readRtouch(ADS7843_t *dev); +extern int ads7843calibrate(ADS7843_t *dev,uint16_t zeroX,uint16_t zeroY,uint16_t zeroRtouch,uint16_t xMin,uint16_t xMax,uint16_t yMin,uint16_t yMax,char delta); +extern int ads7843isPenTouching(ADS7843_t *dev); diff --git a/include/PERIPHERALS/dma.h b/include/PERIPHERALS/dma.h new file mode 100644 --- /dev/null +++ b/include/PERIPHERALS/dma.h @@ -0,0 +1,53 @@ +/*------------------------------------------------------------------------------ +-- This file is a part of the libuc, microcontroler library +-- Copyright (C) 2015, Alexis Jeandet +-- +-- This program is free software; you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation; either version 3 of the License, or +-- (at your option) any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program; if not, write to the Free Software +-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +------------------------------------------------------------------------------- +-- Author : Alexis Jeandet +-- Mail : alexis.jeandet@gmail.com +-------------------------------------------------------------------------------*/ + +#ifndef DMA_H +#define DMA_H +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef int dmaID_t; + +dmaID_t dmacopy(uint32_t source, uint32_t dest, int size, int count, char incSrc, char incDest); +dmaID_t dmamemset(uint32_t dest,int val, int size); +int dmaIsReady(dmaID_t dmaID); +int dmaLockStream(int stream,int dmaDev); + +#ifdef __cplusplus +} +#endif +#endif //DMA_H + + + + + + + + + + + + diff --git a/mkspecs/features/boards/BEAGLESYNTH/bsp.pri b/mkspecs/features/boards/BEAGLESYNTH/bsp.pri --- a/mkspecs/features/boards/BEAGLESYNTH/bsp.pri +++ b/mkspecs/features/boards/BEAGLESYNTH/bsp.pri @@ -1,9 +1,9 @@ CPU=stm32f4xxxG DEFINES+=BSP=\\\"BEAGLESYNTH\\\" beagleCp.target = beagleCp -beagleCp.commands = cd bin && scp $(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin +beagleCp.commands = cd $(DESTDIR) && scp $(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin beagleCp131.target = beagleCp131 -beagleCp131.commands = cd bin && scp $(QMAKE_TARGET).bin root@129.104.27.131://opt/stm32flashAje/hello.bin +beagleCp131.commands = cd $(DESTDIR) && scp $(QMAKE_TARGET).bin root@129.104.27.131://opt/stm32flashAje/hello.bin QMAKE_EXTRA_TARGETS += beagleCp beagleCp131 UCMODEL=stm32f4 diff --git a/mkspecs/features/boards/SOSmartPSU/bsp.pri b/mkspecs/features/boards/SOSmartPSU/bsp.pri new file mode 100644 --- /dev/null +++ b/mkspecs/features/boards/SOSmartPSU/bsp.pri @@ -0,0 +1,4 @@ +CPU=stm32f4xxxG +DEFINES+=BSP=\\\"SOSmartPSU\\\" + +UCMODEL=stm32f4 diff --git a/mkspecs/features/gui.prf b/mkspecs/features/gui.prf --- a/mkspecs/features/gui.prf +++ b/mkspecs/features/gui.prf @@ -1,2 +1,2 @@ -LIBS+= -lterminal -lfonts -lili9328 -lssd2119 -lADS7843 -lSTMPE811 +LIBS+= -lterminal -lfonts -lD51E5TA7601 -lili9328 -lssd2119 -lADS7843 -lSTMPE811 diff --git a/mkspecs/features/stm32f4/crt0.s b/mkspecs/features/stm32f4/crt0.s --- a/mkspecs/features/stm32f4/crt0.s +++ b/mkspecs/features/stm32f4/crt0.s @@ -38,7 +38,7 @@ .fpu fpv4-sp-d16 .section .stack - .align 4 + .align 3 #ifdef __STACK_SIZE .equ Stack_Size, __STACK_SIZE #else diff --git a/mkspecs/features/stm32f4/qmake.conf b/mkspecs/features/stm32f4/qmake.conf --- a/mkspecs/features/stm32f4/qmake.conf +++ b/mkspecs/features/stm32f4/qmake.conf @@ -73,7 +73,16 @@ contains( TEMPLATE, app ) { nemiver.target = nemiver nemiver.commands = cd $$DESTDIR && nemiver --remote=localhost:3333 --gdb-binary=`which arm-none-eabi-gdb` $(QMAKE_TARGET) nemiver.depends = gdb-server - QMAKE_EXTRA_TARGETS += dfu_file stflash dfu nemiver gdb-server qstlink2 + openocd.target = openocd + openocd.depends = $$DESTDIR/$(QMAKE_TARGET) + openocd.commands = openocd -f /usr/share/openocd/scripts/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /usr/share/openocd/scripts/target/stm32f4x.cfg + gdb-load.target = gdb-load + gdb-load.commands = cd $$DESTDIR && arm-none-eabi-gdb --eval-command \"set confirm off\" --eval-command \"target remote localhost:3333\" --eval-command \"monitor reset halt\" --eval-command \"load\" --eval-command \"quit\" $(QMAKE_TARGET) + gdb-load.depends = $$DESTDIR/$(QMAKE_TARGET) + nemiver_ocd.target = nemiver_ocd + nemiver_ocd.commands = cd $$DESTDIR && nemiver --remote=localhost:3333 --gdb-binary=`which arm-none-eabi-gdb` $(QMAKE_TARGET) + nemiver_ocd.depends = gdb-load + QMAKE_EXTRA_TARGETS += dfu_file stflash dfu nemiver gdb-server qstlink2 openocd nemiver_ocd gdb-load } diff --git a/src/common/GRAPHIC/CONTROLERS/D51E5TA7601/D51E5TA7601.c b/src/common/GRAPHIC/CONTROLERS/D51E5TA7601/D51E5TA7601.c --- a/src/common/GRAPHIC/CONTROLERS/D51E5TA7601/D51E5TA7601.c +++ b/src/common/GRAPHIC/CONTROLERS/D51E5TA7601/D51E5TA7601.c @@ -30,15 +30,328 @@ #ifdef __OPTIMIZED_MATH #include #endif +extern void bsp_lcd0_setGRAM(); + +int D51E5TA7601init(LCD_t *LCD) +{ + if((LCD!=NULL) && (LCD->interface.lcd_interface!=NULL) && (LCD->interface.lcd_interface->writereg!=NULL)) + { + //first check which LCD controller is connected + if(0x7601==LCD->interface.lcd_interface->readreg(0)) + { + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_DRIVEROUTPUTCONTROL1, 0x003C); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_LCDDRIVINGCONTROL, 0x0100); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_ENTRYMODE, 0x1030); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_BLANKPERDIODCTRL, 0x0808); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_FRAMECYCLECONTROL, 0x0500); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_EXTERNALDISPLAYCTRL, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_LCDINTERFACECONTROL, 0x0770); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GATESCANPOSITIONCTRL, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_FRAMESIGNALCONTROL, 0x0001); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL2, 0x0406); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL3, 0x000E); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL4, 0x0222); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL5, 0x0015); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL6, 0x4277); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL7, 0x0000); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL9, 0x6A50); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL10, 0x00C9); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL11, 0xC7BE); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL12, 0x0003); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL15, 0x3443); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL20, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL21, 0x0000); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL5, 0x6A50); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL6, 0x00C9); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL7, 0xC7BE); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL8, 0x0003); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL14, 0x3443); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL18, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL19, 0x0000); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL1, 0x6A50); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL2, 0x00C9); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL3, 0xC7BE); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL4, 0x0003); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL13, 0x3443); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL16, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_GAMMACONTROL17, 0x0000); + + delay_100us(500); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL3, 0x200E); + + delay_100us(500); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_POWERCONTROL3, 0x2003); + + delay_100us(500); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALADDRESSENDPOSITION, 0x013F); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALADDRESSSTARTPOSITION, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALADDRESSENDPOSITION, 0x01DF); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALADDRESSSTARTPOSITION, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALGRAMADDRESSSET, 0x0000); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALGRAMADDRESSSET, 0x013F); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_DISPLAYCONTROL4, 0x0012); + + delay_100us(500); + + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_DISPLAYCONTROL4, 0x0017); + delay_100us(500); + + bsp_lcd0_setGRAM(); + + delay_100us(5000); + bsp_lcd0_setGRAM(); + + } + + } +} +void D51E5TA7601setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress) +{ + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALGRAMADDRESSSET,Vaddress); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALGRAMADDRESSSET,Haddress); +} +void D51E5TA7601setFrame(LCD_t *LCD, uint16_t X, uint16_t Y, uint16_t W, uint16_t H) +{ + // printf("X=%d Y=%d W=%d H=%d\n\r",X,Y,W,H); + if((X>(LCD->width-1)) || (Y>(LCD->height-1)) || ((X+W)>LCD->width) || ((Y+H)>LCD->height)) + { + printf("Error painting out of screen! %dx%d @%d;%d\n",W,H,X,Y); + return; + } + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALADDRESSENDPOSITION,(uint32_t)(X+W-1)); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALADDRESSSTARTPOSITION,(uint32_t)X); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALADDRESSENDPOSITION,(uint32_t)(Y+H-1)); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALADDRESSSTARTPOSITION,(uint32_t)Y); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)(Y)); + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)(X)); +} + + +void D51E5TA7601paint(LCD_t *LCD, void *buffer, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + if((LCD!=NULL) && (LCD->interface.lcd_interface!=NULL) && (LCD->interface.lcd_interface->writeGRAM!=NULL) && (LCD->width>=(Xpos+Width)) && (LCD->height>=(Ypos+Height))) + { + D51E5TA7601setFrame(LCD,Xpos,Ypos,Width,Height); + LCD->interface.lcd_interface->writeGRAM(buffer,Width*Height); + } +} + + +void D51E5TA7601paintFilRect(LCD_t *LCD, uint16_t Xpos, uint16_t Ypos, uint16_t w, uint16_t h, uint32_t contColor, uint16_t contSz, uint32_t fillColor) +{ + D51E5TA7601setFrame(LCD,Xpos,Ypos,w,h); + uint16_t tmp[32]; + for(int i=0;i<32;i++)tmp[i]=fillColor; + for(int i=0;i<(h*w);i+=32) + { + LCD->interface.lcd_interface->writeGRAM(tmp,32); + } + int rem=(w*h)%32; + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); + if(contSz) + { + D51E5TA7601setFrame(LCD,Xpos,Ypos,w,contSz); + for(int i=0;i<32;i++)tmp[i]=contColor; + rem=(w*contSz)%32; + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); + for(int i=rem;i<(w*contSz);i+=32) + { + LCD->interface.lcd_interface->writeGRAM(tmp,32); + } + + D51E5TA7601setFrame(LCD,Xpos,Ypos+h-contSz,w,contSz); + rem=(w*contSz)%32; + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); + for(int i=rem;i<(w*contSz);i+=32) + { + LCD->interface.lcd_interface->writeGRAM(tmp,32); + } + + D51E5TA7601setFrame(LCD,Xpos,Ypos,contSz,h); + rem=(h*contSz)%32; + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); + for(int i=rem;i<(h*contSz);i+=32) + { + LCD->interface.lcd_interface->writeGRAM(tmp,32); + } + + D51E5TA7601setFrame(LCD,Xpos+w-contSz,Ypos,contSz,h); + rem=(h*contSz)%32; + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); + for(int i=rem;i<(h*contSz);i+=32) + { + LCD->interface.lcd_interface->writeGRAM(tmp,32); + } + } +} + + +void D51E5TA7601getPix(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h) +{ +#define __set__Address__(_x_,_y_) LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)(_x_)); \ + LCD->interface.lcd_interface->writereg(D51E5TA7601_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)(_y_)) + int cx=Xpos,cy=Ypos; + D51E5TA7601setFrame(LCD,Xpos,Ypos,w,h); + int status; + do + { + status = LCD->interface.lcd_interface->status()>>8; + // }while (status>=Ypos && status<=(Ypos+h)); + }while (status!=0); + + LCD->interface.lcd_interface->readGRAM((void*)(buffer),w*h); +} + + +void D51E5TA7601paint_FrameBuff(LCD_t *frameBuff, void *buffer, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + volatile uint16_t* OUTbuffer = (volatile uint16_t*)(frameBuff->interface.buffer); + volatile uint16_t* INbuffer = (volatile uint16_t*)buffer; + int index =0; + for(int Col=Xpos;Col<(Xpos+Width);Col++) + { + for(int Line=Ypos;Line<(Ypos+Height);Line++) + { + int i=Line+(Col*frameBuff->height); + OUTbuffer[i] = INbuffer[index++]; + } + } +} +void D51E5TA7601getPix_FrameBuff(LCD_t *frameBuff, uint16_t *buffer, uint16_t Xpos, uint16_t Ypos, uint16_t w, uint16_t h) +{ + volatile uint16_t* OUTbuffer = (volatile uint16_t*)(frameBuff->interface.buffer); + volatile uint16_t* INbuffer = (volatile uint16_t*)buffer; + int index =0; + for(int Col=Xpos;Col<(Xpos+w);Col++) + { + for(int Line=Ypos;Line<(Ypos+h);Line++) + { + int i=Line+(Col*frameBuff->height); + INbuffer[index++] = OUTbuffer[i]; + } + } +} + + +int D51E5TA7601init_FrameBuff(LCD_t *LCD) +{ + memset((void*)LCD->interface.buffer,-1,LCD->height*LCD->width*2); + return 0; +} + + +void D51E5TA7601setFrame_FrameBuff(LCD_t *LCD, uint16_t X, uint16_t Y, uint16_t W, uint16_t H) +{ + return; +} + + +void D51E5TA7601refreshenable_FrameBuff(LCD_t *LCD, int enable) +{ + +} + + +void D51E5TA7601paintText(LCD_t *LCD, char *buffer, uint16_t Xpos, uint16_t Ypos, sFONT *font, uint32_t color) +{ + +} + + +void D51E5TA7601refreshenable(LCD_t *LCD, int enable) +{ + +} +void D51E5TA7601paintText_FrameBuff(LCD_t *frameBuff, char *buffer, uint16_t Xpos, uint16_t Ypos, sFONT *font, uint32_t color) +{ + int w=font->Width,h=font->Height,bpl=font->bytesPerLine,pix=0,tableoffset=0; + uint16_t tmp[w]; + uint16_t linenum=0,charnum=0; + uint8_t line=0; + while(*buffer!='\0') + { + if(*buffer<32)*buffer=32; + if(*buffer>127)*buffer=32; + // LCD->setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1); + // LCD->interface->readGRAM(tmp,w); + frameBuff->getPix(frameBuff,tmp,Xpos+(charnum*w),Ypos-h,w,1); + for(int i=0;i<(h*w);i++) + { + if( ((i%w)==0) ) //read current line to apply text pixmap + { + if(linenum++>0) + { + // LCD->setFrame(LCD,Xpos+(charnum*w),Ypos + linenum -h,w,1); + // LCD->interface->writeGRAM(tmp,w); + frameBuff->paint(frameBuff,tmp,Xpos+(charnum*w),Ypos + linenum -h,w,1); + //ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1); + // LCD->interface->readGRAM(tmp,w); + frameBuff->getPix(frameBuff,tmp,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1); + pix=0; + } + } + if((pix%8) == 0) + { + line=font->table[(((*buffer)-32)*h*bpl)+tableoffset++]; + } + //tmp[pix]=0; + if((line & (uint8_t)0x01)==(uint8_t)1)tmp[pix]=(uint16_t)color; + pix++; + line>>=1; + } + linenum=0; + tableoffset=0; + charnum++; + buffer++; + } +} + +void D51E5TA7601paintFilRect_FrameBuff(LCD_t *frameBuff, uint16_t Xpos, uint16_t Ypos, uint16_t w, uint16_t h, uint32_t contColor, uint16_t contSz, uint32_t fillColor) +{ + volatile uint16_t* buffer= frameBuff->interface.buffer; + +#define drawR(_X_,_Y_,_W_,_H_,_color_) \ + for(int line=0;line<(_H_);line++)\ + {\ + for(int col=0;col<(_W_);col++)\ + {\ + buffer[(((_X_)+col)*frameBuff->height)+line+(_Y_)]=(_color_);\ + }\ + } + if(((2*contSz)<=w) && ((2*contSz)<=h)) + { + drawR(Xpos+contSz,Ypos+contSz,w-(2*contSz),h-(2*contSz),fillColor); + if(contSz) + { + drawR(Xpos,Ypos,w,contSz,contColor); + drawR(Xpos,Ypos,contSz,h,contColor); + drawR(Xpos,Ypos+h-contSz,w,contSz,contColor); + drawR(Xpos+w-contSz,Ypos,contSz,h,contColor); + } + } +} + + +void D51E5TA7601paintFB(LCD_t *LCD, LCD_t *frameBuffer) +{ + LCD->paint(LCD,(void*)frameBuffer->interface.buffer,0,0,frameBuffer->height,frameBuffer->width); +} diff --git a/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c b/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c --- a/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c +++ b/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c @@ -37,10 +37,10 @@ {\ ili9328setFrame(LCD,X,Y,W,1);\ int rem=(W)%buffsize;\ - if(rem)LCD->interface->writeGRAM(buffer,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(buffer,rem);\ for(int i=rem;i<(W);i+=buffsize)\ {\ - LCD->interface->writeGRAM(buffer,buffsize);\ + LCD->interface.lcd_interface->writeGRAM(buffer,buffsize);\ }\ } @@ -49,25 +49,25 @@ {\ ili9328setFrame(LCD,X,Y,W,1);\ int rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ if((2*ContSz)interface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(W-(2*ContSz));i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ }\ @@ -77,25 +77,25 @@ {\ ili9328setFrame(LCD,X,Y,1,H);\ int rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ if((2*ContSz)interface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(H-(2*ContSz));i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ }\ @@ -105,18 +105,18 @@ {\ ili9328setFrame(LCD,X,Y,1,H);\ int rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ if(ContSzinterface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(H-ContSz);i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ }\ @@ -130,36 +130,36 @@ if(ContSzinterface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(H-ContSz);i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ }\ void ili9328setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress) { - LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,Haddress); - LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,Vaddress); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,Haddress); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,Vaddress); } void ili9328refreshenable(struct LCD_t* LCD,int enable) { if(enable) { - //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1018); + //LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1018); } else { - //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1008); + //LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1008); } } @@ -168,22 +168,23 @@ void ili9328setFrame(LCD_t* LCD,uint16_t { if((X>(LCD->width-1)) || (Y>(LCD->height-1)) || ((X+W)>LCD->width) || ((Y+H)>LCD->height)) { - while (1); + printf("Error painting out of screen!\n"); + return; } - LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,(uint32_t)X); - LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,(uint32_t)(W+X-1)); - LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,(uint32_t)Y); - LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,(uint32_t)(Y+H-1)); - LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)X); - LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)Y); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,(uint32_t)X); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,(uint32_t)(W+X-1)); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,(uint32_t)Y); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,(uint32_t)(Y+H-1)); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)X); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)Y); } void ili9328paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height) { - if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writeGRAM!=NULL) && (LCD->width>=(Xpos+Width)) && (LCD->height>=(Ypos+Height))) + if((LCD!=NULL) && (LCD->interface.lcd_interface!=NULL) && (LCD->interface.lcd_interface->writeGRAM!=NULL) && (LCD->width>=(Xpos+Width)) && (LCD->height>=(Ypos+Height))) { ili9328setFrame(LCD,Xpos,Ypos,Width,Height); - LCD->interface->writeGRAM(buffer,Width*Height); + LCD->interface.lcd_interface->writeGRAM(buffer,Width*Height); } } @@ -257,10 +258,10 @@ void ili9328paintFilCirc_old(LCD_t* LCD, contSz2= Val1-Val2; ili9328setFrame(LCD,X1,line+Ypos,2*Val1,1); rem=(contSz2)%16; - if(rem)LCD->interface->writeGRAM(outterbuffer,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(outterbuffer,rem); for(int i=rem;i<(contSz2);i+=16) { - LCD->interface->writeGRAM(outterbuffer,16); + LCD->interface.lcd_interface->writeGRAM(outterbuffer,16); } W=2*Val1; @@ -268,18 +269,18 @@ void ili9328paintFilCirc_old(LCD_t* LCD, { W-=2*contSz2; rem=(W)%16; - if(rem)LCD->interface->writeGRAM(innerbuffer,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(innerbuffer,rem); for(int i=rem;i<(W);i+=16) { - LCD->interface->writeGRAM(innerbuffer,16); + LCD->interface.lcd_interface->writeGRAM(innerbuffer,16); } } rem=(contSz2)%16; - if(rem)LCD->interface->writeGRAM(outterbuffer,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(outterbuffer,rem); for(int i=rem;i<(contSz2);i+=16) { - LCD->interface->writeGRAM(outterbuffer,16); + LCD->interface.lcd_interface->writeGRAM(outterbuffer,16); } } } @@ -295,43 +296,43 @@ void ili9328paintFilRect(LCD_t* LCD,uint for(int i=0;i<32;i++)tmp[i]=fillColor; for(int i=0;i<(h*w);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } int rem=(w*h)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); if(contSz) { ili9328setFrame(LCD,Xpos,Ypos,w,contSz); for(int i=0;i<32;i++)tmp[i]=contColor; rem=(w*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(w*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } ili9328setFrame(LCD,Xpos,Ypos+h-contSz,w,contSz); rem=(w*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(w*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } ili9328setFrame(LCD,Xpos,Ypos,contSz,h); rem=(h*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(h*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } ili9328setFrame(LCD,Xpos+w-contSz,Ypos,contSz,h); rem=(h*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(h*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } } } @@ -346,20 +347,20 @@ void ili9328paintText(LCD_t* LCD,char* b { if(*buffer<32)*buffer=32; if(*buffer>127)*buffer=32; - ili9328setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1); + LCD->setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1); // LCD->interface->readGRAM(tmp,w); - ili9328getPix(LCD,tmp,Xpos+(charnum*w),Ypos-h,w,1); + LCD->getPix(LCD,tmp,Xpos+(charnum*w),Ypos-h,w,1); for(int i=0;i<(h*w);i++) { if( ((i%w)==0) ) //read current line to apply text pixmap { if(linenum++>0) { - ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum -h,w,1); - LCD->interface->writeGRAM(tmp,w); + LCD->setFrame(LCD,Xpos+(charnum*w),Ypos + linenum -h,w,1); + LCD->interface.lcd_interface->writeGRAM(tmp,w); //ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1); // LCD->interface->readGRAM(tmp,w); - ili9328getPix(LCD,tmp,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1); + LCD->getPix(LCD,tmp,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1); pix=0; } } @@ -403,7 +404,7 @@ void ili9328paintChar(LCD_t* LCD,char bu if(linenum++>0) { ili9328setFrame(LCD,Xpos,Ypos + linenum -h,w,1); - LCD->interface->writeGRAM(tmp,w); + LCD->interface.lcd_interface->writeGRAM(tmp,w); //ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1); // LCD->interface->readGRAM(tmp,w); ili9328getPix(LCD,tmp2,Xpos,Ypos + linenum + 1-h,w,1); @@ -428,47 +429,47 @@ void ili9328paintChar(LCD_t* LCD,char bu int ili9328init(struct LCD_t* LCD) { - if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writereg!=NULL)) + if((LCD!=NULL) && (LCD->interface.lcd_interface!=NULL) && (LCD->interface.lcd_interface->writereg!=NULL)) { - LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL1, 0x0100); // Driver Output Control Register (R01h) - LCD->interface->writereg(ILI9328_REGISTER_LCDDRIVINGCONTROL, 0x0700); // LCD Driving Waveform Control (R02h) - LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x0230); // Entry Mode (R03h) - LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0xC000); - LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL2, 0x0302); - LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL3, 0x0000); - LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL4, 0x0000); // Fmark On - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x0000); // Power Control 1 (R10h) - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007); // Power Control 2 (R11h) - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x0000); // Power Control 3 (R12h) - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0000); // Power Control 4 (R13h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL1, 0x0100); // Driver Output Control Register (R01h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_LCDDRIVINGCONTROL, 0x0700); // LCD Driving Waveform Control (R02h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x0230); // Entry Mode (R03h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0xC000); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL2, 0x0302); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL3, 0x0000); + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL4, 0x0000); // Fmark On + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x0000); // Power Control 1 (R10h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007); // Power Control 2 (R11h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x0000); // Power Control 3 (R12h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0000); // Power Control 4 (R13h) delay_100us(1000); - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x14B0); // Power Control 1 (R10h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x14B0); // Power Control 1 (R10h) delay_100us(500); - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007); // Power Control 2 (R11h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007); // Power Control 2 (R11h) delay_100us(500); - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x008E); // Power Control 3 (R12h) - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0C00); // Power Control 4 (R13h) - LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL7, 0x0015); // NVM read data 2 (R29h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x008E); // Power Control 3 (R12h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0C00); // Power Control 4 (R13h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_POWERCONTROL7, 0x0015); // NVM read data 2 (R29h) delay_100us(500); - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL1, 0x0000); // Gamma Control 1 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL2, 0x0107); // Gamma Control 2 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL3, 0x0000); // Gamma Control 3 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL4, 0x0203); // Gamma Control 4 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL5, 0x0402); // Gamma Control 5 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL6, 0x0000); // Gamma Control 6 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL7, 0x0207); // Gamma Control 7 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL8, 0x0000); // Gamma Control 8 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL9, 0x0203); // Gamma Control 9 - LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL10, 0x0403); // Gamma Control 10 - LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION, 0x0000); // Window Horizontal RAM Address Start (R50h) - LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION, LCD->width - 1); // Window Horizontal RAM Address End (R51h) - LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION, 0X0000); // Window Vertical RAM Address Start (R52h) - LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION, LCD->height - 1); // Window Vertical RAM Address End (R53h) - LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL2, 0xa700); // Driver Output Control (R60h) - LCD->interface->writereg(ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL, 0x0003); // Driver Output Control (R61h) - enable VLE - LCD->interface->writereg(ILI9328_REGISTER_PANELINTERFACECONTROL1, 0X0010); // Panel Interface Control 1 (R90h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL1, 0x0000); // Gamma Control 1 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL2, 0x0107); // Gamma Control 2 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL3, 0x0000); // Gamma Control 3 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL4, 0x0203); // Gamma Control 4 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL5, 0x0402); // Gamma Control 5 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL6, 0x0000); // Gamma Control 6 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL7, 0x0207); // Gamma Control 7 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL8, 0x0000); // Gamma Control 8 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL9, 0x0203); // Gamma Control 9 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_GAMMACONTROL10, 0x0403); // Gamma Control 10 + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION, 0x0000); // Window Horizontal RAM Address Start (R50h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION, LCD->width - 1); // Window Horizontal RAM Address End (R51h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION, 0X0000); // Window Vertical RAM Address Start (R52h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION, LCD->height - 1); // Window Vertical RAM Address End (R53h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL2, 0xa700); // Driver Output Control (R60h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL, 0x0003); // Driver Output Control (R61h) - enable VLE + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_PANELINTERFACECONTROL1, 0X0010); // Panel Interface Control 1 (R90h) // Display On - LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0x0133); // Display Control (R07h) + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0x0133); // Display Control (R07h) delay_100us(500); LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,0xFFFF); } @@ -477,15 +478,15 @@ int ili9328init(struct LCD_t* LCD) void ili9328cpFrame(LCD_t* LCD,void* buffer,int x,int y,int w, int h) { -#define __set__Address__(_x_,_y_) LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,_x_); \ - LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,_y_) +#define __set__Address__(_x_,_y_) LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,_x_); \ + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,_y_) uint16_t* castedBuff = (uint16_t*)buffer; int cx=x,cy=y; for(int i=0;i<(w*h);i++) { __set__Address__(cx,cy); - LCD->interface->readGRAM((void*)(&castedBuff[i]),1); + LCD->interface.lcd_interface->readGRAM((void*)(&castedBuff[i]),1); cx+=1; if(cx>=(w+x)) { @@ -499,15 +500,15 @@ void ili9328cpFrame(LCD_t* LCD,void* buf void ili9328getPix(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h) { -#define __set__Address__(_x_,_y_) LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,_x_); \ - LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,_y_) +#define __set__Address__(_x_,_y_) LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,_x_); \ + LCD->interface.lcd_interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,_y_) int cx=Xpos,cy=Ypos; ili9328setFrame(LCD,Xpos,Ypos,w,h); for(int i=0;i<(w*h);i++) { __set__Address__(cx,cy); - LCD->interface->readGRAM((void*)(&buffer[i]),1); + LCD->interface.lcd_interface->readGRAM((void*)(&buffer[i]),1); cx+=1; if(cx>=(w+Xpos)) { diff --git a/src/common/GRAPHIC/CONTROLERS/SSD2119/ssd2119.c b/src/common/GRAPHIC/CONTROLERS/SSD2119/ssd2119.c --- a/src/common/GRAPHIC/CONTROLERS/SSD2119/ssd2119.c +++ b/src/common/GRAPHIC/CONTROLERS/SSD2119/ssd2119.c @@ -36,10 +36,10 @@ {\ ssd2119setFrame(LCD,X,Y,W,1);\ int rem=(W)%buffsize;\ - if(rem)LCD->interface->writeGRAM(buffer,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(buffer,rem);\ for(int i=rem;i<(W);i+=buffsize)\ {\ - LCD->interface->writeGRAM(buffer,buffsize);\ + LCD->interface.lcd_interface->writeGRAM(buffer,buffsize);\ }\ } @@ -48,25 +48,25 @@ {\ ssd2119setFrame(LCD,X,Y,W,1);\ int rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ if((2*ContSz)interface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(W-(2*ContSz));i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ }\ @@ -76,25 +76,25 @@ {\ ssd2119setFrame(LCD,X,Y,1,H);\ int rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ if((2*ContSz)interface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(H-(2*ContSz));i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ }\ @@ -104,18 +104,18 @@ {\ ssd2119setFrame(LCD,X,Y,1,H);\ int rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ if(ContSzinterface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(H-ContSz);i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ }\ @@ -129,25 +129,25 @@ if(ContSzinterface->writeGRAM(bufferInt,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferInt,rem);\ for(int i=rem;i<(H-ContSz);i+=buffIntsize)\ {\ - LCD->interface->writeGRAM(bufferInt,buffIntsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferInt,buffIntsize);\ }\ }\ rem=(ContSz)%buffContsize;\ - if(rem)LCD->interface->writeGRAM(bufferCont,rem);\ + if(rem)LCD->interface.lcd_interface->writeGRAM(bufferCont,rem);\ for(int i=rem;i<(ContSz);i+=buffContsize)\ {\ - LCD->interface->writeGRAM(bufferCont,buffContsize);\ + LCD->interface.lcd_interface->writeGRAM(bufferCont,buffContsize);\ }\ }\ void ssd2119setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress) { - LCD->interface->writereg(SSD2119_REGISTER_X_RAM_ADDR,Haddress); - LCD->interface->writereg(SSD2119_REGISTER_Y_RAM_ADDR,Vaddress); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_X_RAM_ADDR,Haddress); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_Y_RAM_ADDR,Vaddress); } void ssd2119refreshenable(struct LCD_t* LCD,int enable) @@ -165,19 +165,19 @@ void ssd2119refreshenable(struct LCD_t* void ssd2119setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H) { - LCD->interface->writereg(SSD2119_REGISTER_X_RAM_ADDR,(uint32_t)X); - LCD->interface->writereg(SSD2119_REGISTER_Y_RAM_ADDR,(uint32_t)Y); - LCD->interface->writereg(SSD2119_REGISTER_H_RAM_START,(uint32_t)X); - LCD->interface->writereg(SSD2119_REGISTER_H_RAM_END,(uint32_t)(W+X-1)); - LCD->interface->writereg(SSD2119_REGISTER_V_RAM_POS,(((uint32_t)(Y+H-1))<<8) + (uint32_t)Y); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_X_RAM_ADDR,(uint32_t)X); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_Y_RAM_ADDR,(uint32_t)Y); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_H_RAM_START,(uint32_t)X); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_H_RAM_END,(uint32_t)(W+X-1)); + LCD->interface.lcd_interface->writereg(SSD2119_REGISTER_V_RAM_POS,(((uint32_t)(Y+H-1))<<8) + (uint32_t)Y); } void ssd2119paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height) { - if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writeGRAM!=NULL) && (LCD->width>(Xpos+Width)) && (LCD->height>(Ypos+Height))) + if((LCD!=NULL) && (LCD->interface.lcd_interface!=NULL) && (LCD->interface.lcd_interface->writeGRAM!=NULL) && (LCD->width>(Xpos+Width)) && (LCD->height>(Ypos+Height))) { ssd2119setFrame(LCD,Xpos,Ypos,Width,Height); - LCD->interface->writeGRAM(buffer,Width*Height); + LCD->interface.lcd_interface->writeGRAM(buffer,Width*Height); } } @@ -251,10 +251,10 @@ void ssd2119paintFilCirc_old(LCD_t* LCD, contSz2= Val1-Val2; ssd2119setFrame(LCD,X1,line+Ypos,2*Val1,1); rem=(contSz2)%16; - if(rem)LCD->interface->writeGRAM(outterbuffer,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(outterbuffer,rem); for(int i=rem;i<(contSz2);i+=16) { - LCD->interface->writeGRAM(outterbuffer,16); + LCD->interface.lcd_interface->writeGRAM(outterbuffer,16); } W=2*Val1; @@ -262,18 +262,18 @@ void ssd2119paintFilCirc_old(LCD_t* LCD, { W-=2*contSz2; rem=(W)%16; - if(rem)LCD->interface->writeGRAM(innerbuffer,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(innerbuffer,rem); for(int i=rem;i<(W);i+=16) { - LCD->interface->writeGRAM(innerbuffer,16); + LCD->interface.lcd_interface->writeGRAM(innerbuffer,16); } } rem=(contSz2)%16; - if(rem)LCD->interface->writeGRAM(outterbuffer,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(outterbuffer,rem); for(int i=rem;i<(contSz2);i+=16) { - LCD->interface->writeGRAM(outterbuffer,16); + LCD->interface.lcd_interface->writeGRAM(outterbuffer,16); } } } @@ -289,43 +289,43 @@ void ssd2119paintFilRect(LCD_t* LCD,uint for(int i=0;i<32;i++)tmp[i]=fillColor; for(int i=0;i<(h*w);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } int rem=(w*h)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); if(contSz) { ssd2119setFrame(LCD,Xpos,Ypos,w,contSz); for(int i=0;i<32;i++)tmp[i]=contColor; rem=(w*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(w*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } ssd2119setFrame(LCD,Xpos,Ypos+h-contSz,w,contSz); rem=(w*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(w*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } ssd2119setFrame(LCD,Xpos,Ypos,contSz,h); rem=(h*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(h*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } ssd2119setFrame(LCD,Xpos+w-contSz,Ypos,contSz,h); rem=(h*contSz)%32; - if(rem)LCD->interface->writeGRAM(tmp,rem); + if(rem)LCD->interface.lcd_interface->writeGRAM(tmp,rem); for(int i=rem;i<(h*contSz);i+=32) { - LCD->interface->writeGRAM(tmp,32); + LCD->interface.lcd_interface->writeGRAM(tmp,32); } } } @@ -339,7 +339,7 @@ void ssd2119paintText(LCD_t* LCD,char* b while(*buffer!='\0') { ssd2119setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1); - LCD->interface->readGRAM(tmp,w); + LCD->interface.lcd_interface->readGRAM(tmp,w); for(int i=0;i<(h*w);i++) { if( ((i%w)==0) ) //read current line to apply text pixmap @@ -347,9 +347,9 @@ void ssd2119paintText(LCD_t* LCD,char* b if(linenum++>0) { ssd2119setFrame(LCD,Xpos+(charnum*(w-10)),Ypos + linenum -h,w,1); // TODO remove -10 and generate good fonts! - LCD->interface->writeGRAM(tmp,w); + LCD->interface.lcd_interface->writeGRAM(tmp,w); ssd2119setFrame(LCD,Xpos+(charnum*(w-10)),Ypos + linenum + 1-h,w,1); - LCD->interface->readGRAM(tmp,w); + LCD->interface.lcd_interface->readGRAM(tmp,w); pix=0; } } @@ -371,42 +371,42 @@ void ssd2119paintText(LCD_t* LCD,char* b int ssd2119init(struct LCD_t* LCD) { - if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writereg!=NULL)) + if((LCD!=NULL) && (LCD->interface.lcd_interface!=NULL) && (LCD->interface.lcd_interface->writereg!=NULL)) { - LCD->interface->writereg(0x28,0x0006); // VCOM OTP - Page 55-56 of SSD2119 datasheet - LCD->interface->writereg(0x00,0x0001); // start Oscillator - Page 36 of SSD2119 datasheet - LCD->interface->writereg(0x10,0x0000); // Sleep mode - Page 49 of SSD2119 datasheet - LCD->interface->writereg(0x01,0x72ef); // Driver Output Control - Page 36-39 of SSD2119 datasheet - LCD->interface->writereg(0x02,0x0600); // LCD Driving Waveform Control - Page 40-42 of SSD2119 datasheet - LCD->interface->writereg(0x03,0x6a38); // Power Control 1 - Page 43-44 of SSD2119 datasheet - LCD->interface->writereg(0x11,0x6870); // Entry Mode - Page 50-52 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x28,0x0006); // VCOM OTP - Page 55-56 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x00,0x0001); // start Oscillator - Page 36 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x10,0x0000); // Sleep mode - Page 49 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x01,0x72ef); // Driver Output Control - Page 36-39 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x02,0x0600); // LCD Driving Waveform Control - Page 40-42 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x03,0x6a38); // Power Control 1 - Page 43-44 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x11,0x6870); // Entry Mode - Page 50-52 of SSD2119 datasheet // RAM WRITE DATA MASK - LCD->interface->writereg(0x0f,0x0000); // Gate Scan Position - Page 49 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x0f,0x0000); // Gate Scan Position - Page 49 of SSD2119 datasheet // RAM WRITE DATA MASK - LCD->interface->writereg(0x0b,0x5308); // Frame Cycle Control - Page 45 of SSD2119 datasheet - LCD->interface->writereg(0x0c,0x0003); // Power Control 2 - Page 47 of SSD2119 datasheet - LCD->interface->writereg(0x0d,0x000a); // Power Control 3 - Page 48 of SSD2119 datasheet - LCD->interface->writereg(0x0e,0x2e00); // Power Control 4 - Page 48 of SSD2119 datasheet - LCD->interface->writereg(0x1e,0x00be); // Power Control 5 - Page 53 of SSD2119 datasheet - LCD->interface->writereg(0x25,0x8000); // Frame Frequency Control - Page 53 of SSD2119 datasheet - LCD->interface->writereg(0x26,0x7800); // Analog setting - Page 54 of SSD2119 datasheet - LCD->interface->writereg(0x4e,0x0000); // Ram Address Set - Page 58 of SSD2119 datasheet - LCD->interface->writereg(0x4f,0x0000); // Ram Address Set - Page 58 of SSD2119 datasheet - LCD->interface->writereg(0x12,0x08d9); // Sleep mode - Page 49 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x0b,0x5308); // Frame Cycle Control - Page 45 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x0c,0x0003); // Power Control 2 - Page 47 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x0d,0x000a); // Power Control 3 - Page 48 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x0e,0x2e00); // Power Control 4 - Page 48 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x1e,0x00be); // Power Control 5 - Page 53 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x25,0x8000); // Frame Frequency Control - Page 53 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x26,0x7800); // Analog setting - Page 54 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x4e,0x0000); // Ram Address Set - Page 58 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x4f,0x0000); // Ram Address Set - Page 58 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x12,0x08d9); // Sleep mode - Page 49 of SSD2119 datasheet // -----------------Adjust the Gamma Curve----// - LCD->interface->writereg(0x30,0x0000); //0007 - LCD->interface->writereg(0x31,0x0104); //0203 - LCD->interface->writereg(0x32,0x0100); //0001 - LCD->interface->writereg(0x33,0x0305); //0007 - LCD->interface->writereg(0x34,0x0505); //0007 - LCD->interface->writereg(0x35,0x0305); //0407 - LCD->interface->writereg(0x36,0x0707); //0407 - LCD->interface->writereg(0x37,0x0300); //0607 - LCD->interface->writereg(0x3a,0x1200); //0106 - LCD->interface->writereg(0x3b,0x0800); - LCD->interface->writereg(0x07,0x0033); // Display Control - Page 45 of SSD2119 datasheet + LCD->interface.lcd_interface->writereg(0x30,0x0000); //0007 + LCD->interface.lcd_interface->writereg(0x31,0x0104); //0203 + LCD->interface.lcd_interface->writereg(0x32,0x0100); //0001 + LCD->interface.lcd_interface->writereg(0x33,0x0305); //0007 + LCD->interface.lcd_interface->writereg(0x34,0x0505); //0007 + LCD->interface.lcd_interface->writereg(0x35,0x0305); //0407 + LCD->interface.lcd_interface->writereg(0x36,0x0707); //0407 + LCD->interface.lcd_interface->writereg(0x37,0x0300); //0607 + LCD->interface.lcd_interface->writereg(0x3a,0x1200); //0106 + LCD->interface.lcd_interface->writereg(0x3b,0x0800); + LCD->interface.lcd_interface->writereg(0x07,0x0033); // Display Control - Page 45 of SSD2119 datasheet } return 0; } diff --git a/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.c b/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.c --- a/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.c +++ b/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.c @@ -23,81 +23,85 @@ #include #include -int ads7843init(ADS7843_t *dev, spi_t spidev,void (*setnCS)(char),int (*busy)()) +int ads7843init(ADS7843_t *dev, spi_t spidev, char config, void (*setnCS)(char), int (*busy)()) { dev->spidev = spidev; dev->setnCS = setnCS; dev->busy = busy; dev->setnCS(1); + dev->config = config & ADS7843_CONFIG_MASK; + dev->xMax = 1000; + dev->xMin = 0; + dev->yMax = 1000; + dev->yMin = 0; + dev->zeroRtouch = 0; + dev->zeroX = 500; + dev->zeroY = 500; + dev->delta = 200; + return 1; +} + +unsigned int __ads7843read(ADS7843_t *dev,char cfg) +{ + unsigned int data; + dev->setnCS(0); + while(dev->busy()); + spiputw(dev->spidev,ADS7843_START|dev->config|cfg); + data= (0x0FF & spigetw2(dev->spidev,0))<<8; + data+= 0x0FF & spigetw2(dev->spidev,0); + dev->setnCS(1); + return (data>>4); +} + +int ads7843read(ADS7843_t *dev,int* x,int* y) +{ + *x=0; + *y=0; + for(int i=0;i<32;i++) + { + *x += __ads7843read(dev,ADS7843_MEAS_X_POS_DIFF|ADS7843_POWER_REF_ON|ADS7843_POWER_ADC_ON); + *y += __ads7843read(dev,ADS7843_MEAS_Y_POS_DIFF|ADS7843_POWER_REF_ON|ADS7843_POWER_ADC_ON); + } + *x>>=5; + *y>>=5; + *x = ((*x-dev->xMin)*1000)/(dev->xMax-dev->xMin); + *y = ((*y-dev->yMin)*1000)/(dev->yMax-dev->yMin); return 1; } -int ads7843read(ADS7843_t *dev,int* x,int* y) +int ads7843readRtouch(ADS7843_t *dev) { - int data; - *x=0; - *y=0; - spiputw(dev->spidev,0x97); -// delay_100us(2); - while(dev->busy()); - spigetw2(dev->spidev,0); - spigetw2(dev->spidev,0); - delay_100us(100); - for(int i=0;i<32;i++) +#define avg 32 + int z1=0,z2=0,x=0; + for(int i=0;isetnCS(0); - spiputw(dev->spidev,0x97); - //delay_100us(2); - while(dev->busy()); - data= (0x0FF & spigetw2(dev->spidev,0))<<8; - data+= 0x0FF & spigetw2(dev->spidev,0); - *x+=data>>4; - dev->setnCS(1); - delay_100us(10); + x += __ads7843read(dev,ADS7843_MEAS_X_POS_DIFF|ADS7843_POWER_REF_ON|ADS7843_POWER_ADC_ON); + z1 += __ads7843read(dev,ADS7843_MEAS_Z1_POS_DIFF|ADS7843_POWER_REF_ON|ADS7843_POWER_ADC_ON); + z2 += __ads7843read(dev,ADS7843_MEAS_Z2_POS_DIFF|ADS7843_POWER_REF_ON|ADS7843_POWER_ADC_ON); } - spiputw(dev->spidev,0xd7); -// delay_100us(2); - while(dev->busy()); - spigetw2(dev->spidev,0); - spigetw2(dev->spidev,0); - delay_100us(10); - for(int i=0;i<32;i++) - { - data=0; - dev->setnCS(0); - spiputw(dev->spidev,0xd7); -// delay_100us(2); - while(dev->busy()); - data= (spigetw2(dev->spidev,0))<<8; - data+= spigetw2(dev->spidev,0); - *y+=data>>4; - dev->setnCS(1); - delay_100us(10); - } - *x/=32; - *y/=32; - return 1; + return (x/(4096/avg))*((z2/z1)-1); } - - - - - - - +int ads7843calibrate(ADS7843_t *dev, uint16_t zeroX, uint16_t zeroY, uint16_t zeroRtouch, uint16_t xMin, uint16_t xMax, uint16_t yMin, uint16_t yMax, char delta) +{ + dev->xMax = xMax; + dev->xMin = xMin; + dev->yMax = yMax; + dev->yMin = yMin; + dev->zeroRtouch = zeroRtouch; + dev->zeroX = zeroX; + dev->zeroY = zeroY; + dev->delta = delta; +} - - - +int ads7843isPenTouching(ADS7843_t *dev) +{ + int rtc= ads7843readRtouch(dev); + return ((rtc+dev->delta) < dev->zeroRtouch); - - - - +} diff --git a/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.pro b/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.pro --- a/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.pro +++ b/src/common/GRAPHIC/TC_CONTROLERS/ADS7843/ADS7843.pro @@ -5,5 +5,9 @@ TARGET = ADS7843 SOURCES += \ ADS7843.c +HEADERS += \ + ../../../../../include/GRAPHIC/TC_CONTROLERS/ADS7843.h + + diff --git a/src/common/POWER/ina226/ina226.c b/src/common/POWER/ina226/ina226.c --- a/src/common/POWER/ina226/ina226.c +++ b/src/common/POWER/ina226/ina226.c @@ -55,7 +55,8 @@ int ina226calibrate(INA226_t* dev,uint32 { dev->shuntmOhm = shuntmOhm; dev->CurrentRangeuAmp = CurrentRangeuAmp; - uint32_t CAL= (uint32_t)(5210000/(shuntmOhm*(CurrentRangeuAmp>>15))); +// uint32_t CAL= (uint32_t)(5210000/(shuntmOhm*(CurrentRangeuAmp>>15))); + float CAL=(5210000.0/((float)shuntmOhm*((float)CurrentRangeuAmp/32768.0))); return ina226setReg(dev,INA226_Calibration_Reg,(uint16_t)CAL); } diff --git a/src/stm32f4/CORE/irq_handlers.c b/src/stm32f4/CORE/irq_handlers.c --- a/src/stm32f4/CORE/irq_handlers.c +++ b/src/stm32f4/CORE/irq_handlers.c @@ -322,30 +322,6 @@ void TIM7_IRQHandler(void) printf("TIM7_IRQHandler\n"); } -void DMA2_Stream0_IRQHandler(void) -{ - printf("DMA2_Stream0_IRQHandler\n"); -} - -void DMA2_Stream1_IRQHandler(void) -{ - printf("DMA2_Stream1_IRQHandler\n"); -} - -void DMA2_Stream2_IRQHandler(void) -{ - printf("DMA2_Stream2_IRQHandler\n"); -} - -void DMA2_Stream3_IRQHandler(void) -{ - printf("DMA2_Stream3_IRQHandler\n"); -} - -void DMA2_Stream4_IRQHandler(void) -{ - printf("DMA2_Stream4_IRQHandler\n"); -} void ETH_IRQHandler(void) { @@ -382,21 +358,6 @@ void OTG_FS_IRQHandler(void) printf("OTG_FS_IRQHandler\n"); } -void DMA2_Stream5_IRQHandler(void) -{ - printf("DMA2_Stream5_IRQHandler\n"); -} - -void DMA2_Stream6_IRQHandler(void) -{ - printf("DMA2_Stream6_IRQHandler\n"); -} - -void DMA2_Stream7_IRQHandler(void) -{ - printf("DMA2_Stream7_IRQHandler\n"); -} - void USART6_IRQHandler(void) { printf("USART6_IRQHandler\n"); diff --git a/src/stm32f4/DMA/dma.c b/src/stm32f4/DMA/dma.c new file mode 100644 --- /dev/null +++ b/src/stm32f4/DMA/dma.c @@ -0,0 +1,362 @@ +/*------------------------------------------------------------------------------ +-- This file is a part of the libuc, microcontroler library +-- Copyright (C) 2012, Alexis Jeandet +-- +-- This program is free software; you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation; either version 3 of the License, or +-- (at your option) any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program; if not, write to the Free Software +-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +------------------------------------------------------------------------------- +-- Author : Alexis Jeandet +-- Mail : alexis.jeandet@member.fsf.org +-------------------------------------------------------------------------------*/ +#include +#include +#include +#include +#include + +#define GPIOGETPORT(gpio) ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA)) +#define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) +typedef enum dmaStreamState +{ + avail=0, + inUse=1, + locked=2, +}dmaStreamState; + +char __DMA2_streams__[8]={avail,avail,avail,avail,avail,avail,avail,avail}; +DMA_Stream_TypeDef* __DMA2_streams_list__[8]={DMA2_Stream0,DMA2_Stream1,DMA2_Stream2,DMA2_Stream3,DMA2_Stream4,DMA2_Stream5,DMA2_Stream6,DMA2_Stream7}; +int __DMA2_streams_channels__[8]={DMA_Channel_1,DMA_Channel_3,DMA_Channel_2,DMA_Channel_0,DMA_Channel_3,DMA_Channel_5,DMA_Channel_3,DMA_Channel_3}; +uint32_t __DMA2_streams_remainig_data__[8]={0,0,0,0,0,0,0,0}; +int __DMA_Csts__[8]={0,0,0,0,0,0,0,0}; +char __dma_is_initialised =0; +typedef struct _dma_config_ +{ + uint32_t source; + uint32_t dest; + int size; + int count; + char incSrc; + char incDest; +}_dma_config_; + +_dma_config_ __DMA2_streams_config__[8]; + +void __set_DMA_inc__(DMA_InitTypeDef* DMA_InitStructure,int* incsz,int*datacnt) +{ + switch (*incsz) { + case 1: + DMA_InitStructure->DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; + DMA_InitStructure->DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; + break; + case 2: + DMA_InitStructure->DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; + DMA_InitStructure->DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; + break; + case 4: + DMA_InitStructure->DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word; + DMA_InitStructure->DMA_MemoryDataSize = DMA_MemoryDataSize_Word; + break; + default: + DMA_InitStructure->DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; + DMA_InitStructure->DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; + (*datacnt)*=(*incsz); + *incsz=1; + break; + } +} + +void __DMA2_init() +{ + int irq[8]={DMA2_Stream0_IRQn,DMA2_Stream1_IRQn,DMA2_Stream2_IRQn,DMA2_Stream3_IRQn,DMA2_Stream4_IRQn,DMA2_Stream5_IRQn,DMA2_Stream6_IRQn,DMA2_Stream7_IRQn}; + NVIC_InitTypeDef NVIC_InitStructure; + RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); + + for(int i=0;i<8;i++) + { + if(__DMA2_streams__[i]!=locked) + { + DMA_DeInit(__DMA2_streams_list__[i]); + DMA_ITConfig(__DMA2_streams_list__[i], DMA_IT_TC, ENABLE); + NVIC_InitStructure.NVIC_IRQChannel = irq[i]; + NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; + NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; + NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; + NVIC_Init(&NVIC_InitStructure); + } + } + __dma_is_initialised = 1; +} + +void __dmacopy__(uint32_t source, uint32_t dest, int size, int count,char incSrc,char incDest,int streamIndex) +{ + DMA_InitTypeDef DMA_InitStructure; + DMA_Stream_TypeDef* stream=__DMA2_streams_list__[streamIndex]; + while (DMA_GetCmdStatus(stream) != DISABLE); + __set_DMA_inc__(&DMA_InitStructure,&size,&count); + DMA_InitStructure.DMA_Channel = __DMA2_streams_channels__[streamIndex]; + DMA_InitStructure.DMA_PeripheralBaseAddr = source; + DMA_InitStructure.DMA_Memory0BaseAddr = dest; + DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToMemory; + if(count>65535) + { + DMA_InitStructure.DMA_BufferSize = 65535; + __DMA2_streams_config__[streamIndex].count = count-65535; + } + else + { + DMA_InitStructure.DMA_BufferSize = count; + __DMA2_streams_config__[streamIndex].count = 0; + } + __DMA2_streams_config__[streamIndex].incDest = incDest; + __DMA2_streams_config__[streamIndex].incSrc = incSrc; + __DMA2_streams_config__[streamIndex].size = size; + if(incSrc) + { + __DMA2_streams_config__[streamIndex].source = source+(DMA_InitStructure.DMA_BufferSize*size); + DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable; + } + else + { + __DMA2_streams_config__[streamIndex].source = source; + DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; + } + if(incDest) + { + __DMA2_streams_config__[streamIndex].dest = dest+(DMA_InitStructure.DMA_BufferSize*size); + DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; + } + else + { + __DMA2_streams_config__[streamIndex].dest = dest; + DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; + } + DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; + DMA_InitStructure.DMA_Priority = DMA_Priority_High; + DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; + DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; + DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; + DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; + DMA_Init(stream, &DMA_InitStructure); + DMA_Cmd(stream, ENABLE); +} + +dmaID_t dmacopy(uint32_t source, uint32_t dest, int size, int count,char incSrc,char incDest) +{ + int streamIndex; + if(!__dma_is_initialised) + { + __DMA2_init(); + } + for(int i=0;i<8;i++) + { + if(__DMA2_streams__[i]==avail) + { + streamIndex=i; + __DMA2_streams__[i]=inUse; + break; + } + } + __dmacopy__(source,dest,size,count,incSrc,incDest,streamIndex); + return streamIndex; +} + +void DMA2_continueCp(int streamIndex) +{ + DMA_InitTypeDef DMA_InitStructure; + DMA_Stream_TypeDef* stream = __DMA2_streams_list__[streamIndex]; + if ((DMA_GetCmdStatus(stream) != DISABLE) && (__DMA2_streams__[streamIndex]==inUse)) + { + return; + } + if(__DMA2_streams_config__[streamIndex].count==0) + { + __DMA2_streams__[streamIndex]=avail; + return; + } + __set_DMA_inc__(&DMA_InitStructure,&(__DMA2_streams_config__[streamIndex].size),&(__DMA2_streams_config__[streamIndex].count)); + DMA_InitStructure.DMA_Channel = __DMA2_streams_channels__[streamIndex]; + DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToMemory; + DMA_InitStructure.DMA_PeripheralBaseAddr = __DMA2_streams_config__[streamIndex].source; + DMA_InitStructure.DMA_Memory0BaseAddr = __DMA2_streams_config__[streamIndex].dest; + if(__DMA2_streams_config__[streamIndex].count>65535) + { + DMA_InitStructure.DMA_BufferSize = 65535; + __DMA2_streams_config__[streamIndex].count = __DMA2_streams_config__[streamIndex].count-65535; + } + else + { + DMA_InitStructure.DMA_BufferSize = __DMA2_streams_config__[streamIndex].count; + __DMA2_streams_config__[streamIndex].count = 0; + } + if(__DMA2_streams_config__[streamIndex].incSrc) + { + __DMA2_streams_config__[streamIndex].source +=(DMA_InitStructure.DMA_BufferSize*__DMA2_streams_config__[streamIndex].size); + DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable; + } + else + { + __DMA2_streams_config__[streamIndex].source = __DMA2_streams_config__[streamIndex].source; + DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; + } + if(__DMA2_streams_config__[streamIndex].incDest) + { + __DMA2_streams_config__[streamIndex].dest +=(DMA_InitStructure.DMA_BufferSize*__DMA2_streams_config__[streamIndex].size); + DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; + } + else + { + __DMA2_streams_config__[streamIndex].dest = __DMA2_streams_config__[streamIndex].dest; + DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; + } + DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; + DMA_InitStructure.DMA_Priority = DMA_Priority_High; + DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; + DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; + DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; + DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; + DMA_Init(stream, &DMA_InitStructure); + DMA_Cmd(stream, ENABLE); +} + +void DMA2_Stream0_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream0, DMA_IT_TCIF0)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_TCIF0); + DMA2_continueCp(0); + } +} + +void DMA2_Stream1_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream1, DMA_IT_TCIF1)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1); + DMA2_continueCp(1); + } + +} + +void DMA2_Stream2_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream2, DMA_IT_TCIF2)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream2, DMA_IT_TCIF2); + DMA2_continueCp(2); + } +} + +void DMA2_Stream3_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream3, DMA_IT_TCIF3)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream3, DMA_IT_TCIF3); + DMA2_continueCp(3); + } +} + +void DMA2_Stream4_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream4, DMA_IT_TCIF4)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream4, DMA_IT_TCIF4); + DMA2_continueCp(4); + } +} + +void DMA2_Stream5_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream5, DMA_IT_TCIF5)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream5, DMA_IT_TCIF5); + DMA2_continueCp(5); + } +} + +void DMA2_Stream6_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream6, DMA_IT_TCIF6)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream6, DMA_IT_TCIF6); + DMA2_continueCp(6); + } +} + +void DMA2_Stream7_IRQHandler(void) +{ + if(DMA_GetITStatus(DMA2_Stream7, DMA_IT_TCIF7)) + { + /* Clear DMA Stream Transfer Complete interrupt pending bit */ + DMA_ClearITPendingBit(DMA2_Stream7, DMA_IT_TCIF7); + DMA2_continueCp(7); + } +} + + +int dmaIsReady(dmaID_t dmaID) +{ + if(!__dma_is_initialised) + { + __DMA2_init(); + } + return __DMA2_streams__[dmaID]==avail; +} + + +int dmaLockStream(int stream, int dmaDev) +{ + if(!__dma_is_initialised) + { + __DMA2_init(); + } + if(dmaDev==2) + { + if(__DMA2_streams__[stream]==locked) + { + return 0; + } + while(__DMA2_streams__[stream]==inUse); + __DMA2_streams__[stream]=locked; + return 1; + } +} + + +dmaID_t dmamemset(uint32_t dest, int val, int size) +{ + int streamIndex; + if(!__dma_is_initialised) + { + __DMA2_init(); + } + for(int i=0;i<8;i++) + { + if(__DMA2_streams__[i]==avail) + { + streamIndex=i; + __DMA2_streams__[i]=inUse; + break; + } + } + __DMA_Csts__[streamIndex]=val; + __dmacopy__((uint32_t)(__DMA_Csts__ + streamIndex),dest,1,size,0,1,streamIndex); + return streamIndex; +} diff --git a/src/stm32f4/DMA/dma.pro b/src/stm32f4/DMA/dma.pro new file mode 100644 --- /dev/null +++ b/src/stm32f4/DMA/dma.pro @@ -0,0 +1,13 @@ +TEMPLATE = lib +CONFIG += libuc2lib + +SOURCES += dma.c + +UCMODEL=stm32f4 + +HEADERS += \ + ../../../include/PERIPHERALS/dma.h + + + + diff --git a/src/stm32f4/stm32f4.pro b/src/stm32f4/stm32f4.pro --- a/src/stm32f4/stm32f4.pro +++ b/src/stm32f4/stm32f4.pro @@ -10,6 +10,7 @@ SUBDIRS = CORE/core.pro \ I2C/i2c.pro \ PWM/pwm.pro \ DAC/dac.pro\ + DMA/dma.pro\ SDCARD-SDIO/sdcard-sdio.pro